sound/pci/hda/patch_via.c

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * HD audio interface patch for VIA VT1708 codec
   5  *
   6  * Copyright (c) 2006 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 /*                                                                           */
  33 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  34
  35
  36 #include <linux/init.h>
  37 #include <linux/delay.h>
  38 #include <linux/slab.h>
  39 #include <sound/core.h>
  40 #include "hda_codec.h"
  41 #include "hda_local.h"
  42
  43
  44 /* amp values */
  45 #define AMP_VAL_IDX_SHIFT       19
  46 #define AMP_VAL_IDX_MASK        (0x0f<<19)
  47
  48 #define NUM_CONTROL_ALLOC       32
  49 #define NUM_VERB_ALLOC          32
  50
  51 /* Pin Widget NID */
  52 #define VT1708_HP_NID           0x13
  53 #define VT1708_DIGOUT_NID       0x14
  54 #define VT1708_DIGIN_NID        0x16
  55 #define VT1708_DIGIN_PIN        0x26
  56
  57 #define VT1709_HP_DAC_NID       0x28
  58 #define VT1709_DIGOUT_NID       0x13
  59 #define VT1709_DIGIN_NID        0x17
  60 #define VT1709_DIGIN_PIN        0x25
  61
  62 #define VT1708B_HP_NID          0x25
  63 #define VT1708B_DIGOUT_NID      0x12
  64 #define VT1708B_DIGIN_NID       0x15
  65 #define VT1708B_DIGIN_PIN       0x21
  66
  67 #define IS_VT1708_VENDORID(x)           ((x) >= 0x11061708 && (x) <= 0x1106170b)
  68 #define IS_VT1709_10CH_VENDORID(x)      ((x) >= 0x1106e710 && (x) <= 0x1106e713)
  69 #define IS_VT1709_6CH_VENDORID(x)       ((x) >= 0x1106e714 && (x) <= 0x1106e717)
  70 #define IS_VT1708B_8CH_VENDORID(x)      ((x) >= 0x1106e720 && (x) <= 0x1106e723)
  71 #define IS_VT1708B_4CH_VENDORID(x)      ((x) >= 0x1106e724 && (x) <= 0x1106e727)
  72
  73
  74 enum {
  75         VIA_CTL_WIDGET_VOL,
  76         VIA_CTL_WIDGET_MUTE,
  77 };
  78
  79 enum {
  80         AUTO_SEQ_FRONT,
  81         AUTO_SEQ_SURROUND,
  82         AUTO_SEQ_CENLFE,
  83         AUTO_SEQ_SIDE
  84 };
  85
  86 static struct snd_kcontrol_new vt1708_control_templates[] = {
  87         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
  88         HDA_CODEC_MUTE(NULL, 0, 0, 0),
  89 };
  90
  91
  92 struct via_spec {
  93         /* codec parameterization */
  94         struct snd_kcontrol_new *mixers[3];
  95         unsigned int num_mixers;
  96
  97         struct hda_verb *init_verbs;
  98
  99         char *stream_name_analog;
 100         struct hda_pcm_stream *stream_analog_playback;
 101         struct hda_pcm_stream *stream_analog_capture;
 102
 103         char *stream_name_digital;
 104         struct hda_pcm_stream *stream_digital_playback;
 105         struct hda_pcm_stream *stream_digital_capture;
 106
 107         /* playback */
 108         struct hda_multi_out multiout;
 109
 110         /* capture */
 111         unsigned int num_adc_nids;
 112         hda_nid_t *adc_nids;
 113         hda_nid_t dig_in_nid;
 114
 115         /* capture source */
 116         const struct hda_input_mux *input_mux;
 117         unsigned int cur_mux[3];
 118
 119         /* PCM information */
 120         struct hda_pcm pcm_rec[2];
 121
 122         /* dynamic controls, init_verbs and input_mux */
 123         struct auto_pin_cfg autocfg;
 124         unsigned int num_kctl_alloc, num_kctl_used;
 125         struct snd_kcontrol_new *kctl_alloc;
 126         struct hda_input_mux private_imux;
 127         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 128
 129 #ifdef CONFIG_SND_HDA_POWER_SAVE
 130         struct hda_loopback_check loopback;
 131 #endif
 132 };
 133
 134 static hda_nid_t vt1708_adc_nids[2] = {
 135         /* ADC1-2 */
 136         0x15, 0x27
 137 };
 138
 139 static hda_nid_t vt1709_adc_nids[3] = {
 140         /* ADC1-2 */
 141         0x14, 0x15, 0x16
 142 };
 143
 144 static hda_nid_t vt1708B_adc_nids[2] = {
 145         /* ADC1-2 */
 146         0x13, 0x14
 147 };
 148
 149 /* add dynamic controls */
 150 static int via_add_control(struct via_spec *spec, int type, const char *name,
 151                            unsigned long val)
 152 {
 153         struct snd_kcontrol_new *knew;
 154
 155         if (spec->num_kctl_used >= spec->num_kctl_alloc) {
 156                 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
 157
 158                 /* array + terminator */
 159                 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL);
 160                 if (!knew)
 161                         return -ENOMEM;
 162                 if (spec->kctl_alloc) {
 163                         memcpy(knew, spec->kctl_alloc,
 164                                sizeof(*knew) * spec->num_kctl_alloc);
 165                         kfree(spec->kctl_alloc);
 166                 }
 167                 spec->kctl_alloc = knew;
 168                 spec->num_kctl_alloc = num;
 169         }
 170
 171         knew = &spec->kctl_alloc[spec->num_kctl_used];
 172         *knew = vt1708_control_templates[type];
 173         knew->name = kstrdup(name, GFP_KERNEL);
 174
 175         if (!knew->name)
 176                 return -ENOMEM;
 177         knew->private_value = val;
 178         spec->num_kctl_used++;
 179         return 0;
 180 }
 181
 182 /* create input playback/capture controls for the given pin */
 183 static int via_new_analog_input(struct via_spec *spec, hda_nid_t pin,
 184                                 const char *ctlname, int idx, int mix_nid)
 185 {
 186         char name[32];
 187         int err;
 188
 189         sprintf(name, "%s Playback Volume", ctlname);
 190         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
 191                               HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
 192         if (err < 0)
 193                 return err;
 194         sprintf(name, "%s Playback Switch", ctlname);
 195         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
 196                               HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
 197         if (err < 0)
 198                 return err;
 199         return 0;
 200 }
 201
 202 static void via_auto_set_output_and_unmute(struct hda_codec *codec,
 203                                            hda_nid_t nid, int pin_type,
 204                                            int dac_idx)
 205 {
 206         /* set as output */
 207         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 208                             pin_type);
 209         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 210                             AMP_OUT_UNMUTE);
 211 }
 212
 213
 214 static void via_auto_init_multi_out(struct hda_codec *codec)
 215 {
 216         struct via_spec *spec = codec->spec;
 217         int i;
 218
 219         for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
 220                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
 221                 if (nid)
 222                         via_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
 223         }
 224 }
 225
 226 static void via_auto_init_hp_out(struct hda_codec *codec)
 227 {
 228         struct via_spec *spec = codec->spec;
 229         hda_nid_t pin;
 230
 231         pin = spec->autocfg.hp_pins[0];
 232         if (pin) /* connect to front */
 233                 via_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
 234 }
 235
 236 static void via_auto_init_analog_input(struct hda_codec *codec)
 237 {
 238         struct via_spec *spec = codec->spec;
 239         int i;
 240
 241         for (i = 0; i < AUTO_PIN_LAST; i++) {
 242                 hda_nid_t nid = spec->autocfg.input_pins[i];
 243
 244                 snd_hda_codec_write(codec, nid, 0,
 245                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 246                                     (i <= AUTO_PIN_FRONT_MIC ?
 247                                      PIN_VREF50 : PIN_IN));
 248
 249         }
 250 }
 251 /*
 252  * input MUX handling
 253  */
 254 static int via_mux_enum_info(struct snd_kcontrol *kcontrol,
 255                              struct snd_ctl_elem_info *uinfo)
 256 {
 257         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 258         struct via_spec *spec = codec->spec;
 259         return snd_hda_input_mux_info(spec->input_mux, uinfo);
 260 }
 261
 262 static int via_mux_enum_get(struct snd_kcontrol *kcontrol,
 263                             struct snd_ctl_elem_value *ucontrol)
 264 {
 265         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 266         struct via_spec *spec = codec->spec;
 267         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 268
 269         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 270         return 0;
 271 }
 272
 273 static int via_mux_enum_put(struct snd_kcontrol *kcontrol,
 274                             struct snd_ctl_elem_value *ucontrol)
 275 {
 276         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 277         struct via_spec *spec = codec->spec;
 278         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 279         unsigned int vendor_id = codec->vendor_id;
 280
 281         /* AIW0  lydia 060801 add for correct sw0 input select */
 282         if (IS_VT1708_VENDORID(vendor_id) && (adc_idx == 0))
 283                 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
 284                                              0x18, &spec->cur_mux[adc_idx]);
 285         else if ((IS_VT1709_10CH_VENDORID(vendor_id) ||
 286                   IS_VT1709_6CH_VENDORID(vendor_id)) && adc_idx == 0)
 287                 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
 288                                              0x19, &spec->cur_mux[adc_idx]);
 289         else if ((IS_VT1708B_8CH_VENDORID(vendor_id) ||
 290                   IS_VT1708B_4CH_VENDORID(vendor_id)) && adc_idx == 0)
 291                 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
 292                                              0x17, &spec->cur_mux[adc_idx]);
 293         else
 294                 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
 295                                              spec->adc_nids[adc_idx],
 296                                              &spec->cur_mux[adc_idx]);
 297 }
 298
 299 /* capture mixer elements */
 300 static struct snd_kcontrol_new vt1708_capture_mixer[] = {
 301         HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_INPUT),
 302         HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_INPUT),
 303         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x27, 0x0, HDA_INPUT),
 304         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x27, 0x0, HDA_INPUT),
 305         {
 306                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 307                 /* The multiple "Capture Source" controls confuse alsamixer
 308                  * So call somewhat different..
 309                  * FIXME: the controls appear in the "playback" view!
 310                  */
 311                 /* .name = "Capture Source", */
 312                 .name = "Input Source",
 313                 .count = 1,
 314                 .info = via_mux_enum_info,
 315                 .get = via_mux_enum_get,
 316                 .put = via_mux_enum_put,
 317         },
 318         { } /* end */
 319 };
 320 /*
 321  * generic initialization of ADC, input mixers and output mixers
 322  */
 323 static struct hda_verb vt1708_volume_init_verbs[] = {
 324         /*
 325          * Unmute ADC0-1 and set the default input to mic-in
 326          */
 327         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 328         {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 329
 330
 331         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
 332          * mixer widget
 333          */
 334         /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
 335         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 336         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 337         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
 338         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
 339         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
 340
 341         /*
 342          * Set up output mixers (0x19 - 0x1b)
 343          */
 344         /* set vol=0 to output mixers */
 345         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 346         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 347         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 348
 349         /* Setup default input to PW4 */
 350         {0x20, AC_VERB_SET_CONNECT_SEL, 0x1},
 351         /* PW9 Output enable */
 352         {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
 353         { }
 354 };
 355
 356 static int via_playback_pcm_open(struct hda_pcm_stream *hinfo,
 357                                  struct hda_codec *codec,
 358                                  struct snd_pcm_substream *substream)
 359 {
 360         struct via_spec *spec = codec->spec;
 361         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
 362 }
 363
 364 static int via_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 365                                     struct hda_codec *codec,
 366                                     unsigned int stream_tag,
 367                                     unsigned int format,
 368                                     struct snd_pcm_substream *substream)
 369 {
 370         struct via_spec *spec = codec->spec;
 371         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
 372                                                 stream_tag, format, substream);
 373 }
 374
 375 static int via_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
 376                                     struct hda_codec *codec,
 377                                     struct snd_pcm_substream *substream)
 378 {
 379         struct via_spec *spec = codec->spec;
 380         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
 381 }
 382
 383 /*
 384  * Digital out
 385  */
 386 static int via_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
 387                                      struct hda_codec *codec,
 388                                      struct snd_pcm_substream *substream)
 389 {
 390         struct via_spec *spec = codec->spec;
 391         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
 392 }
 393
 394 static int via_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
 395                                       struct hda_codec *codec,
 396                                       struct snd_pcm_substream *substream)
 397 {
 398         struct via_spec *spec = codec->spec;
 399         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
 400 }
 401
 402 static int via_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 403                                         struct hda_codec *codec,
 404                                         unsigned int stream_tag,
 405                                         unsigned int format,
 406                                         struct snd_pcm_substream *substream)
 407 {
 408         struct via_spec *spec = codec->spec;
 409         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
 410                                              stream_tag, format, substream);
 411 }
 412
 413 /*
 414  * Analog capture
 415  */
 416 static int via_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
 417                                    struct hda_codec *codec,
 418                                    unsigned int stream_tag,
 419                                    unsigned int format,
 420                                    struct snd_pcm_substream *substream)
 421 {
 422         struct via_spec *spec = codec->spec;
 423
 424         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
 425                                    stream_tag, 0, format);
 426         return 0;
 427 }
 428
 429 static int via_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
 430                                    struct hda_codec *codec,
 431                                    struct snd_pcm_substream *substream)
 432 {
 433         struct via_spec *spec = codec->spec;
 434         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
 435                                    0, 0, 0);
 436         return 0;
 437 }
 438
 439 static struct hda_pcm_stream vt1708_pcm_analog_playback = {
 440         .substreams = 1,
 441         .channels_min = 2,
 442         .channels_max = 8,
 443         .nid = 0x10, /* NID to query formats and rates */
 444         .ops = {
 445                 .open = via_playback_pcm_open,
 446                 .prepare = via_playback_pcm_prepare,
 447                 .cleanup = via_playback_pcm_cleanup
 448         },
 449 };
 450
 451 static struct hda_pcm_stream vt1708_pcm_analog_capture = {
 452         .substreams = 2,
 453         .channels_min = 2,
 454         .channels_max = 2,
 455         .nid = 0x15, /* NID to query formats and rates */
 456         .ops = {
 457                 .prepare = via_capture_pcm_prepare,
 458                 .cleanup = via_capture_pcm_cleanup
 459         },
 460 };
 461
 462 static struct hda_pcm_stream vt1708_pcm_digital_playback = {
 463         .substreams = 1,
 464         .channels_min = 2,
 465         .channels_max = 2,
 466         /* NID is set in via_build_pcms */
 467         .ops = {
 468                 .open = via_dig_playback_pcm_open,
 469                 .close = via_dig_playback_pcm_close,
 470                 .prepare = via_dig_playback_pcm_prepare
 471         },
 472 };
 473
 474 static struct hda_pcm_stream vt1708_pcm_digital_capture = {
 475         .substreams = 1,
 476         .channels_min = 2,
 477         .channels_max = 2,
 478 };
 479
 480 static int via_build_controls(struct hda_codec *codec)
 481 {
 482         struct via_spec *spec = codec->spec;
 483         int err;
 484         int i;
 485
 486         for (i = 0; i < spec->num_mixers; i++) {
 487                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
 488                 if (err < 0)
 489                         return err;
 490         }
 491
 492         if (spec->multiout.dig_out_nid) {
 493                 err = snd_hda_create_spdif_out_ctls(codec,
 494                                                     spec->multiout.dig_out_nid);
 495                 if (err < 0)
 496                         return err;
 497         }
 498         if (spec->dig_in_nid) {
 499                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
 500                 if (err < 0)
 501                         return err;
 502         }
 503         return 0;
 504 }
 505
 506 static int via_build_pcms(struct hda_codec *codec)
 507 {
 508         struct via_spec *spec = codec->spec;
 509         struct hda_pcm *info = spec->pcm_rec;
 510
 511         codec->num_pcms = 1;
 512         codec->pcm_info = info;
 513
 514         info->name = spec->stream_name_analog;
 515         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
 516         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
 517         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
 518         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
 519
 520         info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
 521                 spec->multiout.max_channels;
 522
 523         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
 524                 codec->num_pcms++;
 525                 info++;
 526                 info->name = spec->stream_name_digital;
 527                 if (spec->multiout.dig_out_nid) {
 528                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
 529                                 *(spec->stream_digital_playback);
 530                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
 531                                 spec->multiout.dig_out_nid;
 532                 }
 533                 if (spec->dig_in_nid) {
 534                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
 535                                 *(spec->stream_digital_capture);
 536                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
 537                                 spec->dig_in_nid;
 538                 }
 539         }
 540
 541         return 0;
 542 }
 543
 544 static void via_free(struct hda_codec *codec)
 545 {
 546         struct via_spec *spec = codec->spec;
 547         unsigned int i;
 548
 549         if (!spec)
 550                 return;
 551
 552         if (spec->kctl_alloc) {
 553                 for (i = 0; i < spec->num_kctl_used; i++)
 554                         kfree(spec->kctl_alloc[i].name);
 555                 kfree(spec->kctl_alloc);
 556         }
 557
 558         kfree(codec->spec);
 559 }
 560
 561 static int via_init(struct hda_codec *codec)
 562 {
 563         struct via_spec *spec = codec->spec;
 564         snd_hda_sequence_write(codec, spec->init_verbs);
 565         /* Lydia Add for EAPD enable */
 566         if (!spec->dig_in_nid) { /* No Digital In connection */
 567                 if (IS_VT1708_VENDORID(codec->vendor_id)) {
 568                         snd_hda_codec_write(codec, VT1708_DIGIN_PIN, 0,
 569                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
 570                                             0x40);
 571                         snd_hda_codec_write(codec, VT1708_DIGIN_PIN, 0,
 572                                             AC_VERB_SET_EAPD_BTLENABLE, 0x02);
 573                 } else if (IS_VT1709_10CH_VENDORID(codec->vendor_id) ||
 574                            IS_VT1709_6CH_VENDORID(codec->vendor_id)) {
 575                         snd_hda_codec_write(codec, VT1709_DIGIN_PIN, 0,
 576                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
 577                                             0x40);
 578                         snd_hda_codec_write(codec, VT1709_DIGIN_PIN, 0,
 579                                             AC_VERB_SET_EAPD_BTLENABLE, 0x02);
 580                 } else if (IS_VT1708B_8CH_VENDORID(codec->vendor_id) ||
 581                            IS_VT1708B_4CH_VENDORID(codec->vendor_id)) {
 582                         snd_hda_codec_write(codec, VT1708B_DIGIN_PIN, 0,
 583                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
 584                                             0x40);
 585                         snd_hda_codec_write(codec, VT1708B_DIGIN_PIN, 0,
 586                                             AC_VERB_SET_EAPD_BTLENABLE, 0x02);
 587                 }
 588         }
 589
 590         return 0;
 591 }
 592
 593 #ifdef CONFIG_SND_HDA_POWER_SAVE
 594 static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid)
 595 {
 596         struct via_spec *spec = codec->spec;
 597         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
 598 }
 599 #endif
 600
 601 /*
 602  */
 603 static struct hda_codec_ops via_patch_ops = {
 604         .build_controls = via_build_controls,
 605         .build_pcms = via_build_pcms,
 606         .init = via_init,
 607         .free = via_free,
 608 #ifdef CONFIG_SND_HDA_POWER_SAVE
 609         .check_power_status = via_check_power_status,
 610 #endif
 611 };
 612
 613 /* fill in the dac_nids table from the parsed pin configuration */
 614 static int vt1708_auto_fill_dac_nids(struct via_spec *spec,
 615                                      const struct auto_pin_cfg *cfg)
 616 {
 617         int i;
 618         hda_nid_t nid;
 619
 620         spec->multiout.num_dacs = cfg->line_outs;
 621
 622         spec->multiout.dac_nids = spec->private_dac_nids;
 623
 624         for(i = 0; i < 4; i++) {
 625                 nid = cfg->line_out_pins[i];
 626                 if (nid) {
 627                         /* config dac list */
 628                         switch (i) {
 629                         case AUTO_SEQ_FRONT:
 630                                 spec->multiout.dac_nids[i] = 0x10;
 631                                 break;
 632                         case AUTO_SEQ_CENLFE:
 633                                 spec->multiout.dac_nids[i] = 0x12;
 634                                 break;
 635                         case AUTO_SEQ_SURROUND:
 636                                 spec->multiout.dac_nids[i] = 0x13;
 637                                 break;
 638                         case AUTO_SEQ_SIDE:
 639                                 spec->multiout.dac_nids[i] = 0x11;
 640                                 break;
 641                         }
 642                 }
 643         }
 644
 645         return 0;
 646 }
 647
 648 /* add playback controls from the parsed DAC table */
 649 static int vt1708_auto_create_multi_out_ctls(struct via_spec *spec,
 650                                              const struct auto_pin_cfg *cfg)
 651 {
 652         char name[32];
 653         static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
 654         hda_nid_t nid, nid_vol = 0;
 655         int i, err;
 656
 657         for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
 658                 nid = cfg->line_out_pins[i];
 659
 660                 if (!nid)
 661                         continue;
 662
 663                 if (i != AUTO_SEQ_FRONT)
 664                         nid_vol = 0x1b - i + 1;
 665
 666                 if (i == AUTO_SEQ_CENLFE) {
 667                         /* Center/LFE */
 668                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
 669                                         "Center Playback Volume",
 670                                         HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
 671                                                             HDA_OUTPUT));
 672                         if (err < 0)
 673                                 return err;
 674                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
 675                                               "LFE Playback Volume",
 676                                               HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
 677                                                                   HDA_OUTPUT));
 678                         if (err < 0)
 679                                 return err;
 680                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
 681                                               "Center Playback Switch",
 682                                               HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
 683                                                                   HDA_OUTPUT));
 684                         if (err < 0)
 685                                 return err;
 686                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
 687                                               "LFE Playback Switch",
 688                                               HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
 689                                                                   HDA_OUTPUT));
 690                         if (err < 0)
 691                                 return err;
 692                 } else if (i == AUTO_SEQ_FRONT){
 693                         /* add control to mixer index 0 */
 694                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
 695                                               "Master Front Playback Volume",
 696                                               HDA_COMPOSE_AMP_VAL(0x17, 3, 0,
 697                                                                   HDA_INPUT));
 698                         if (err < 0)
 699                                 return err;
 700                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
 701                                               "Master Front Playback Switch",
 702                                               HDA_COMPOSE_AMP_VAL(0x17, 3, 0,
 703                                                                   HDA_INPUT));
 704                         if (err < 0)
 705                                 return err;
 706
 707                         /* add control to PW3 */
 708                         sprintf(name, "%s Playback Volume", chname[i]);
 709                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
 710                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0,
 711                                                                   HDA_OUTPUT));
 712                         if (err < 0)
 713                                 return err;
 714                         sprintf(name, "%s Playback Switch", chname[i]);
 715                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
 716                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0,
 717                                                                   HDA_OUTPUT));
 718                         if (err < 0)
 719                                 return err;
 720                 } else {
 721                         sprintf(name, "%s Playback Volume", chname[i]);
 722                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
 723                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
 724                                                                   HDA_OUTPUT));
 725                         if (err < 0)
 726                                 return err;
 727                         sprintf(name, "%s Playback Switch", chname[i]);
 728                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
 729                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
 730                                                                   HDA_OUTPUT));
 731                         if (err < 0)
 732                                 return err;
 733                 }
 734         }
 735
 736         return 0;
 737 }
 738
 739 static int vt1708_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
 740 {
 741         int err;
 742
 743         if (!pin)
 744                 return 0;
 745
 746         spec->multiout.hp_nid = VT1708_HP_NID; /* AOW3 */
 747
 748         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
 749                               "Headphone Playback Volume",
 750                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
 751         if (err < 0)
 752                 return err;
 753         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
 754                               "Headphone Playback Switch",
 755                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
 756         if (err < 0)
 757                 return err;
 758
 759         return 0;
 760 }
 761
 762 /* create playback/capture controls for input pins */
 763 static int vt1708_auto_create_analog_input_ctls(struct via_spec *spec,
 764                                                 const struct auto_pin_cfg *cfg)
 765 {
 766         static char *labels[] = {
 767                 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
 768         };
 769         struct hda_input_mux *imux = &spec->private_imux;
 770         int i, err, idx = 0;
 771
 772         /* for internal loopback recording select */
 773         imux->items[imux->num_items].label = "Stereo Mixer";
 774         imux->items[imux->num_items].index = idx;
 775         imux->num_items++;
 776
 777         for (i = 0; i < AUTO_PIN_LAST; i++) {
 778                 if (!cfg->input_pins[i])
 779                         continue;
 780
 781                 switch (cfg->input_pins[i]) {
 782                 case 0x1d: /* Mic */
 783                         idx = 2;
 784                         break;
 785
 786                 case 0x1e: /* Line In */
 787                         idx = 3;
 788                         break;
 789
 790                 case 0x21: /* Front Mic */
 791                         idx = 4;
 792                         break;
 793
 794                 case 0x24: /* CD */
 795                         idx = 1;
 796                         break;
 797                 }
 798                 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
 799                                            idx, 0x17);
 800                 if (err < 0)
 801                         return err;
 802                 imux->items[imux->num_items].label = labels[i];
 803                 imux->items[imux->num_items].index = idx;
 804                 imux->num_items++;
 805         }
 806         return 0;
 807 }
 808
 809 #ifdef CONFIG_SND_HDA_POWER_SAVE
 810 static struct hda_amp_list vt1708_loopbacks[] = {
 811         { 0x17, HDA_INPUT, 1 },
 812         { 0x17, HDA_INPUT, 2 },
 813         { 0x17, HDA_INPUT, 3 },
 814         { 0x17, HDA_INPUT, 4 },
 815         { } /* end */
 816 };
 817 #endif
 818
 819 static int vt1708_parse_auto_config(struct hda_codec *codec)
 820 {
 821         struct via_spec *spec = codec->spec;
 822         int err;
 823
 824         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
 825         if (err < 0)
 826                 return err;
 827         err = vt1708_auto_fill_dac_nids(spec, &spec->autocfg);
 828         if (err < 0)
 829                 return err;
 830         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
 831                 return 0; /* can't find valid BIOS pin config */
 832
 833         err = vt1708_auto_create_multi_out_ctls(spec, &spec->autocfg);
 834         if (err < 0)
 835                 return err;
 836         err = vt1708_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
 837         if (err < 0)
 838                 return err;
 839         err = vt1708_auto_create_analog_input_ctls(spec, &spec->autocfg);
 840         if (err < 0)
 841                 return err;
 842
 843         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 844
 845         if (spec->autocfg.dig_out_pin)
 846                 spec->multiout.dig_out_nid = VT1708_DIGOUT_NID;
 847         if (spec->autocfg.dig_in_pin)
 848                 spec->dig_in_nid = VT1708_DIGIN_NID;
 849
 850         if (spec->kctl_alloc)
 851                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
 852
 853         spec->init_verbs = vt1708_volume_init_verbs;
 854
 855         spec->input_mux = &spec->private_imux;
 856
 857         return 1;
 858 }
 859
 860 /* init callback for auto-configuration model -- overriding the default init */
 861 static int via_auto_init(struct hda_codec *codec)
 862 {
 863         via_init(codec);
 864         via_auto_init_multi_out(codec);
 865         via_auto_init_hp_out(codec);
 866         via_auto_init_analog_input(codec);
 867         return 0;
 868 }
 869
 870 static int patch_vt1708(struct hda_codec *codec)
 871 {
 872         struct via_spec *spec;
 873         int err;
 874
 875         /* create a codec specific record */
 876         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
 877         if (spec == NULL)
 878                 return -ENOMEM;
 879
 880         codec->spec = spec;
 881
 882         /* automatic parse from the BIOS config */
 883         err = vt1708_parse_auto_config(codec);
 884         if (err < 0) {
 885                 via_free(codec);
 886                 return err;
 887         } else if (!err) {
 888                 printk(KERN_INFO "hda_codec: Cannot set up configuration "
 889                        "from BIOS.  Using genenic mode...\n");
 890         }
 891
 892
 893         spec->stream_name_analog = "VT1708 Analog";
 894         spec->stream_analog_playback = &vt1708_pcm_analog_playback;
 895         spec->stream_analog_capture = &vt1708_pcm_analog_capture;
 896
 897         spec->stream_name_digital = "VT1708 Digital";
 898         spec->stream_digital_playback = &vt1708_pcm_digital_playback;
 899         spec->stream_digital_capture = &vt1708_pcm_digital_capture;
 900
 901
 902         if (!spec->adc_nids && spec->input_mux) {
 903                 spec->adc_nids = vt1708_adc_nids;
 904                 spec->num_adc_nids = ARRAY_SIZE(vt1708_adc_nids);
 905                 spec->mixers[spec->num_mixers] = vt1708_capture_mixer;
 906                 spec->num_mixers++;
 907         }
 908
 909         codec->patch_ops = via_patch_ops;
 910
 911         codec->patch_ops.init = via_auto_init;
 912 #ifdef CONFIG_SND_HDA_POWER_SAVE
 913         spec->loopback.amplist = vt1708_loopbacks;
 914 #endif
 915
 916         return 0;
 917 }
 918
 919 /* capture mixer elements */
 920 static struct snd_kcontrol_new vt1709_capture_mixer[] = {
 921         HDA_CODEC_VOLUME("Capture Volume", 0x14, 0x0, HDA_INPUT),
 922         HDA_CODEC_MUTE("Capture Switch", 0x14, 0x0, HDA_INPUT),
 923         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x15, 0x0, HDA_INPUT),
 924         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x15, 0x0, HDA_INPUT),
 925         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x16, 0x0, HDA_INPUT),
 926         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x16, 0x0, HDA_INPUT),
 927         {
 928                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 929                 /* The multiple "Capture Source" controls confuse alsamixer
 930                  * So call somewhat different..
 931                  * FIXME: the controls appear in the "playback" view!
 932                  */
 933                 /* .name = "Capture Source", */
 934                 .name = "Input Source",
 935                 .count = 1,
 936                 .info = via_mux_enum_info,
 937                 .get = via_mux_enum_get,
 938                 .put = via_mux_enum_put,
 939         },
 940         { } /* end */
 941 };
 942
 943 /*
 944  * generic initialization of ADC, input mixers and output mixers
 945  */
 946 static struct hda_verb vt1709_10ch_volume_init_verbs[] = {
 947         /*
 948          * Unmute ADC0-2 and set the default input to mic-in
 949          */
 950         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 951         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 952         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 953
 954
 955         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
 956          * mixer widget
 957          */
 958         /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
 959         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 960         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 961         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
 962         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
 963         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
 964
 965         /*
 966          * Set up output selector (0x1a, 0x1b, 0x29)
 967          */
 968         /* set vol=0 to output mixers */
 969         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 970         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 971         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 972
 973         /*
 974          *  Unmute PW3 and PW4
 975          */
 976         {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 977         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 978
 979         /* Set input of PW4 as AOW4 */
 980         {0x20, AC_VERB_SET_CONNECT_SEL, 0x1},
 981         /* PW9 Output enable */
 982         {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
 983         { }
 984 };
 985
 986 static struct hda_pcm_stream vt1709_10ch_pcm_analog_playback = {
 987         .substreams = 1,
 988         .channels_min = 2,
 989         .channels_max = 10,
 990         .nid = 0x10, /* NID to query formats and rates */
 991         .ops = {
 992                 .open = via_playback_pcm_open,
 993                 .prepare = via_playback_pcm_prepare,
 994                 .cleanup = via_playback_pcm_cleanup
 995         },
 996 };
 997
 998 static struct hda_pcm_stream vt1709_6ch_pcm_analog_playback = {
 999         .substreams = 1,
1000         .channels_min = 2,
1001         .channels_max = 6,
1002         .nid = 0x10, /* NID to query formats and rates */
1003         .ops = {
1004                 .open = via_playback_pcm_open,
1005                 .prepare = via_playback_pcm_prepare,
1006                 .cleanup = via_playback_pcm_cleanup
1007         },
1008 };
1009
1010 static struct hda_pcm_stream vt1709_pcm_analog_capture = {
1011         .substreams = 2,
1012         .channels_min = 2,
1013         .channels_max = 2,
1014         .nid = 0x14, /* NID to query formats and rates */
1015         .ops = {
1016                 .prepare = via_capture_pcm_prepare,
1017                 .cleanup = via_capture_pcm_cleanup
1018         },
1019 };
1020
1021 static struct hda_pcm_stream vt1709_pcm_digital_playback = {
1022         .substreams = 1,
1023         .channels_min = 2,
1024         .channels_max = 2,
1025         /* NID is set in via_build_pcms */
1026         .ops = {
1027                 .open = via_dig_playback_pcm_open,
1028                 .close = via_dig_playback_pcm_close
1029         },
1030 };
1031
1032 static struct hda_pcm_stream vt1709_pcm_digital_capture = {
1033         .substreams = 1,
1034         .channels_min = 2,
1035         .channels_max = 2,
1036 };
1037
1038 static int vt1709_auto_fill_dac_nids(struct via_spec *spec,
1039                                      const struct auto_pin_cfg *cfg)
1040 {
1041         int i;
1042         hda_nid_t nid;
1043
1044         if (cfg->line_outs == 4)  /* 10 channels */
1045                 spec->multiout.num_dacs = cfg->line_outs+1; /* AOW0~AOW4 */
1046         else if (cfg->line_outs == 3) /* 6 channels */
1047                 spec->multiout.num_dacs = cfg->line_outs; /* AOW0~AOW2 */
1048
1049         spec->multiout.dac_nids = spec->private_dac_nids;
1050
1051         if (cfg->line_outs == 4) { /* 10 channels */
1052                 for (i = 0; i < cfg->line_outs; i++) {
1053                         nid = cfg->line_out_pins[i];
1054                         if (nid) {
1055                                 /* config dac list */
1056                                 switch (i) {
1057                                 case AUTO_SEQ_FRONT:
1058                                         /* AOW0 */
1059                                         spec->multiout.dac_nids[i] = 0x10;
1060                                         break;
1061                                 case AUTO_SEQ_CENLFE:
1062                                         /* AOW2 */
1063                                         spec->multiout.dac_nids[i] = 0x12;
1064                                         break;
1065                                 case AUTO_SEQ_SURROUND:
1066                                         /* AOW3 */
1067                                         spec->multiout.dac_nids[i] = 0x27;
1068                                         break;
1069                                 case AUTO_SEQ_SIDE:
1070                                         /* AOW1 */
1071                                         spec->multiout.dac_nids[i] = 0x11;
1072                                         break;
1073                                 default:
1074                                         break;
1075                                 }
1076                         }
1077                 }
1078                 spec->multiout.dac_nids[cfg->line_outs] = 0x28; /* AOW4 */
1079
1080         } else if (cfg->line_outs == 3) { /* 6 channels */
1081                 for(i = 0; i < cfg->line_outs; i++) {
1082                         nid = cfg->line_out_pins[i];
1083                         if (nid) {
1084                                 /* config dac list */
1085                                 switch(i) {
1086                                 case AUTO_SEQ_FRONT:
1087                                         /* AOW0 */
1088                                         spec->multiout.dac_nids[i] = 0x10;
1089                                         break;
1090                                 case AUTO_SEQ_CENLFE:
1091                                         /* AOW2 */
1092                                         spec->multiout.dac_nids[i] = 0x12;
1093                                         break;
1094                                 case AUTO_SEQ_SURROUND:
1095                                         /* AOW1 */
1096                                         spec->multiout.dac_nids[i] = 0x11;
1097                                         break;
1098                                 default:
1099                                         break;
1100                                 }
1101                         }
1102                 }
1103         }
1104
1105         return 0;
1106 }
1107
1108 /* add playback controls from the parsed DAC table */
1109 static int vt1709_auto_create_multi_out_ctls(struct via_spec *spec,
1110                                              const struct auto_pin_cfg *cfg)
1111 {
1112         char name[32];
1113         static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
1114         hda_nid_t nid = 0;
1115         int i, err;
1116
1117         for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
1118                 nid = cfg->line_out_pins[i];
1119
1120                 if (!nid)
1121                         continue;
1122
1123                 if (i == AUTO_SEQ_CENLFE) {
1124                         /* Center/LFE */
1125                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1126                                               "Center Playback Volume",
1127                                               HDA_COMPOSE_AMP_VAL(0x1b, 1, 0,
1128                                                                   HDA_OUTPUT));
1129                         if (err < 0)
1130                                 return err;
1131                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1132                                               "LFE Playback Volume",
1133                                               HDA_COMPOSE_AMP_VAL(0x1b, 2, 0,
1134                                                                   HDA_OUTPUT));
1135                         if (err < 0)
1136                                 return err;
1137                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1138                                               "Center Playback Switch",
1139                                               HDA_COMPOSE_AMP_VAL(0x1b, 1, 0,
1140                                                                   HDA_OUTPUT));
1141                         if (err < 0)
1142                                 return err;
1143                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1144                                               "LFE Playback Switch",
1145                                               HDA_COMPOSE_AMP_VAL(0x1b, 2, 0,
1146                                                                   HDA_OUTPUT));
1147                         if (err < 0)
1148                                 return err;
1149                 } else if (i == AUTO_SEQ_FRONT){
1150                         /* add control to mixer index 0 */
1151                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1152                                               "Master Front Playback Volume",
1153                                               HDA_COMPOSE_AMP_VAL(0x18, 3, 0,
1154                                                                   HDA_INPUT));
1155                         if (err < 0)
1156                                 return err;
1157                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1158                                               "Master Front Playback Switch",
1159                                               HDA_COMPOSE_AMP_VAL(0x18, 3, 0,
1160                                                                   HDA_INPUT));
1161                         if (err < 0)
1162                                 return err;
1163
1164                         /* add control to PW3 */
1165                         sprintf(name, "%s Playback Volume", chname[i]);
1166                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1167                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1168                                                                   HDA_OUTPUT));
1169                         if (err < 0)
1170                                 return err;
1171                         sprintf(name, "%s Playback Switch", chname[i]);
1172                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1173                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1174                                                                   HDA_OUTPUT));
1175                         if (err < 0)
1176                                 return err;
1177                 } else if (i == AUTO_SEQ_SURROUND) {
1178                         sprintf(name, "%s Playback Volume", chname[i]);
1179                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1180                                               HDA_COMPOSE_AMP_VAL(0x29, 3, 0,
1181                                                                   HDA_OUTPUT));
1182                         if (err < 0)
1183                                 return err;
1184                         sprintf(name, "%s Playback Switch", chname[i]);
1185                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1186                                               HDA_COMPOSE_AMP_VAL(0x29, 3, 0,
1187                                                                   HDA_OUTPUT));
1188                         if (err < 0)
1189                                 return err;
1190                 } else if (i == AUTO_SEQ_SIDE) {
1191                         sprintf(name, "%s Playback Volume", chname[i]);
1192                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1193                                               HDA_COMPOSE_AMP_VAL(0x1a, 3, 0,
1194                                                                   HDA_OUTPUT));
1195                         if (err < 0)
1196                                 return err;
1197                         sprintf(name, "%s Playback Switch", chname[i]);
1198                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1199                                               HDA_COMPOSE_AMP_VAL(0x1a, 3, 0,
1200                                                                   HDA_OUTPUT));
1201                         if (err < 0)
1202                                 return err;
1203                 }
1204         }
1205
1206         return 0;
1207 }
1208
1209 static int vt1709_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
1210 {
1211         int err;
1212
1213         if (!pin)
1214                 return 0;
1215
1216         if (spec->multiout.num_dacs == 5) /* 10 channels */
1217                 spec->multiout.hp_nid = VT1709_HP_DAC_NID;
1218         else if (spec->multiout.num_dacs == 3) /* 6 channels */
1219                 spec->multiout.hp_nid = 0;
1220
1221         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1222                               "Headphone Playback Volume",
1223                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1224         if (err < 0)
1225                 return err;
1226         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1227                               "Headphone Playback Switch",
1228                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1229         if (err < 0)
1230                 return err;
1231
1232         return 0;
1233 }
1234
1235 /* create playback/capture controls for input pins */
1236 static int vt1709_auto_create_analog_input_ctls(struct via_spec *spec,
1237                                                 const struct auto_pin_cfg *cfg)
1238 {
1239         static char *labels[] = {
1240                 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
1241         };
1242         struct hda_input_mux *imux = &spec->private_imux;
1243         int i, err, idx = 0;
1244
1245         /* for internal loopback recording select */
1246         imux->items[imux->num_items].label = "Stereo Mixer";
1247         imux->items[imux->num_items].index = idx;
1248         imux->num_items++;
1249
1250         for (i = 0; i < AUTO_PIN_LAST; i++) {
1251                 if (!cfg->input_pins[i])
1252                         continue;
1253
1254                 switch (cfg->input_pins[i]) {
1255                 case 0x1d: /* Mic */
1256                         idx = 2;
1257                         break;
1258
1259                 case 0x1e: /* Line In */
1260                         idx = 3;
1261                         break;
1262
1263                 case 0x21: /* Front Mic */
1264                         idx = 4;
1265                         break;
1266
1267                 case 0x23: /* CD */
1268                         idx = 1;
1269                         break;
1270                 }
1271                 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
1272                                            idx, 0x18);
1273                 if (err < 0)
1274                         return err;
1275                 imux->items[imux->num_items].label = labels[i];
1276                 imux->items[imux->num_items].index = idx;
1277                 imux->num_items++;
1278         }
1279         return 0;
1280 }
1281
1282 static int vt1709_parse_auto_config(struct hda_codec *codec)
1283 {
1284         struct via_spec *spec = codec->spec;
1285         int err;
1286
1287         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1288         if (err < 0)
1289                 return err;
1290         err = vt1709_auto_fill_dac_nids(spec, &spec->autocfg);
1291         if (err < 0)
1292                 return err;
1293         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
1294                 return 0; /* can't find valid BIOS pin config */
1295
1296         err = vt1709_auto_create_multi_out_ctls(spec, &spec->autocfg);
1297         if (err < 0)
1298                 return err;
1299         err = vt1709_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
1300         if (err < 0)
1301                 return err;
1302         err = vt1709_auto_create_analog_input_ctls(spec, &spec->autocfg);
1303         if (err < 0)
1304                 return err;
1305
1306         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
1307
1308         if (spec->autocfg.dig_out_pin)
1309                 spec->multiout.dig_out_nid = VT1709_DIGOUT_NID;
1310         if (spec->autocfg.dig_in_pin)
1311                 spec->dig_in_nid = VT1709_DIGIN_NID;
1312
1313         if (spec->kctl_alloc)
1314                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
1315
1316         spec->input_mux = &spec->private_imux;
1317
1318         return 1;
1319 }
1320
1321 #ifdef CONFIG_SND_HDA_POWER_SAVE
1322 static struct hda_amp_list vt1709_loopbacks[] = {
1323         { 0x18, HDA_INPUT, 1 },
1324         { 0x18, HDA_INPUT, 2 },
1325         { 0x18, HDA_INPUT, 3 },
1326         { 0x18, HDA_INPUT, 4 },
1327         { } /* end */
1328 };
1329 #endif
1330
1331 static int patch_vt1709_10ch(struct hda_codec *codec)
1332 {
1333         struct via_spec *spec;
1334         int err;
1335
1336         /* create a codec specific record */
1337         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
1338         if (spec == NULL)
1339                 return -ENOMEM;
1340
1341         codec->spec = spec;
1342
1343         err = vt1709_parse_auto_config(codec);
1344         if (err < 0) {
1345                 via_free(codec);
1346                 return err;
1347         } else if (!err) {
1348                 printk(KERN_INFO "hda_codec: Cannot set up configuration.  "
1349                        "Using genenic mode...\n");
1350         }
1351
1352         spec->init_verbs = vt1709_10ch_volume_init_verbs;
1353
1354         spec->stream_name_analog = "VT1709 Analog";
1355         spec->stream_analog_playback = &vt1709_10ch_pcm_analog_playback;
1356         spec->stream_analog_capture = &vt1709_pcm_analog_capture;
1357
1358         spec->stream_name_digital = "VT1709 Digital";
1359         spec->stream_digital_playback = &vt1709_pcm_digital_playback;
1360         spec->stream_digital_capture = &vt1709_pcm_digital_capture;
1361
1362
1363         if (!spec->adc_nids && spec->input_mux) {
1364                 spec->adc_nids = vt1709_adc_nids;
1365                 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids);
1366                 spec->mixers[spec->num_mixers] = vt1709_capture_mixer;
1367                 spec->num_mixers++;
1368         }
1369
1370         codec->patch_ops = via_patch_ops;
1371
1372         codec->patch_ops.init = via_auto_init;
1373 #ifdef CONFIG_SND_HDA_POWER_SAVE
1374         spec->loopback.amplist = vt1709_loopbacks;
1375 #endif
1376
1377         return 0;
1378 }
1379 /*
1380  * generic initialization of ADC, input mixers and output mixers
1381  */
1382 static struct hda_verb vt1709_6ch_volume_init_verbs[] = {
1383         /*
1384          * Unmute ADC0-2 and set the default input to mic-in
1385          */
1386         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1387         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1388         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1389
1390
1391         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1392          * mixer widget
1393          */
1394         /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
1395         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1396         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1397         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1398         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1399         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
1400
1401         /*
1402          * Set up output selector (0x1a, 0x1b, 0x29)
1403          */
1404         /* set vol=0 to output mixers */
1405         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1406         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1407         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1408
1409         /*
1410          *  Unmute PW3 and PW4
1411          */
1412         {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1413         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1414
1415         /* Set input of PW4 as MW0 */
1416         {0x20, AC_VERB_SET_CONNECT_SEL, 0},
1417         /* PW9 Output enable */
1418         {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
1419         { }
1420 };
1421
1422 static int patch_vt1709_6ch(struct hda_codec *codec)
1423 {
1424         struct via_spec *spec;
1425         int err;
1426
1427         /* create a codec specific record */
1428         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
1429         if (spec == NULL)
1430                 return -ENOMEM;
1431
1432         codec->spec = spec;
1433
1434         err = vt1709_parse_auto_config(codec);
1435         if (err < 0) {
1436                 via_free(codec);
1437                 return err;
1438         } else if (!err) {
1439                 printk(KERN_INFO "hda_codec: Cannot set up configuration.  "
1440                        "Using genenic mode...\n");
1441         }
1442
1443         spec->init_verbs = vt1709_6ch_volume_init_verbs;
1444
1445         spec->stream_name_analog = "VT1709 Analog";
1446         spec->stream_analog_playback = &vt1709_6ch_pcm_analog_playback;
1447         spec->stream_analog_capture = &vt1709_pcm_analog_capture;
1448
1449         spec->stream_name_digital = "VT1709 Digital";
1450         spec->stream_digital_playback = &vt1709_pcm_digital_playback;
1451         spec->stream_digital_capture = &vt1709_pcm_digital_capture;
1452
1453
1454         if (!spec->adc_nids && spec->input_mux) {
1455                 spec->adc_nids = vt1709_adc_nids;
1456                 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids);
1457                 spec->mixers[spec->num_mixers] = vt1709_capture_mixer;
1458                 spec->num_mixers++;
1459         }
1460
1461         codec->patch_ops = via_patch_ops;
1462
1463         codec->patch_ops.init = via_auto_init;
1464 #ifdef CONFIG_SND_HDA_POWER_SAVE
1465         spec->loopback.amplist = vt1709_loopbacks;
1466 #endif
1467         return 0;
1468 }
1469
1470 /* capture mixer elements */
1471 static struct snd_kcontrol_new vt1708B_capture_mixer[] = {
1472         HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT),
1473         HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT),
1474         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT),
1475         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT),
1476         {
1477                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1478                 /* The multiple "Capture Source" controls confuse alsamixer
1479                  * So call somewhat different..
1480                  * FIXME: the controls appear in the "playback" view!
1481                  */
1482                 /* .name = "Capture Source", */
1483                 .name = "Input Source",
1484                 .count = 1,
1485                 .info = via_mux_enum_info,
1486                 .get = via_mux_enum_get,
1487                 .put = via_mux_enum_put,
1488         },
1489         { } /* end */
1490 };
1491 /*
1492  * generic initialization of ADC, input mixers and output mixers
1493  */
1494 static struct hda_verb vt1708B_8ch_volume_init_verbs[] = {
1495         /*
1496          * Unmute ADC0-1 and set the default input to mic-in
1497          */
1498         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1499         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1500
1501
1502         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1503          * mixer widget
1504          */
1505         /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
1506         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1507         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1508         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1509         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1510         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
1511
1512         /*
1513          * Set up output mixers
1514          */
1515         /* set vol=0 to output mixers */
1516         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1517         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1518         {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1519
1520         /* Setup default input to PW4 */
1521         {0x1d, AC_VERB_SET_CONNECT_SEL, 0x1},
1522         /* PW9 Output enable */
1523         {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
1524         /* PW10 Input enable */
1525         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
1526         { }
1527 };
1528
1529 static struct hda_verb vt1708B_4ch_volume_init_verbs[] = {
1530         /*
1531          * Unmute ADC0-1 and set the default input to mic-in
1532          */
1533         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1534         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1535
1536
1537         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1538          * mixer widget
1539          */
1540         /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
1541         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1542         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1543         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1544         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1545         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
1546
1547         /*
1548          * Set up output mixers
1549          */
1550         /* set vol=0 to output mixers */
1551         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1552         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1553         {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1554
1555         /* Setup default input of PW4 to MW0 */
1556         {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0},
1557         /* PW9 Output enable */
1558         {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
1559         /* PW10 Input enable */
1560         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
1561         { }
1562 };
1563
1564 static struct hda_pcm_stream vt1708B_8ch_pcm_analog_playback = {
1565         .substreams = 1,
1566         .channels_min = 2,
1567         .channels_max = 8,
1568         .nid = 0x10, /* NID to query formats and rates */
1569         .ops = {
1570                 .open = via_playback_pcm_open,
1571                 .prepare = via_playback_pcm_prepare,
1572                 .cleanup = via_playback_pcm_cleanup
1573         },
1574 };
1575
1576 static struct hda_pcm_stream vt1708B_4ch_pcm_analog_playback = {
1577         .substreams = 1,
1578         .channels_min = 2,
1579         .channels_max = 4,
1580         .nid = 0x10, /* NID to query formats and rates */
1581         .ops = {
1582                 .open = via_playback_pcm_open,
1583                 .prepare = via_playback_pcm_prepare,
1584                 .cleanup = via_playback_pcm_cleanup
1585         },
1586 };
1587
1588 static struct hda_pcm_stream vt1708B_pcm_analog_capture = {
1589         .substreams = 2,
1590         .channels_min = 2,
1591         .channels_max = 2,
1592         .nid = 0x13, /* NID to query formats and rates */
1593         .ops = {
1594                 .prepare = via_capture_pcm_prepare,
1595                 .cleanup = via_capture_pcm_cleanup
1596         },
1597 };
1598
1599 static struct hda_pcm_stream vt1708B_pcm_digital_playback = {
1600         .substreams = 1,
1601         .channels_min = 2,
1602         .channels_max = 2,
1603         /* NID is set in via_build_pcms */
1604         .ops = {
1605                 .open = via_dig_playback_pcm_open,
1606                 .close = via_dig_playback_pcm_close,
1607                 .prepare = via_dig_playback_pcm_prepare
1608         },
1609 };
1610
1611 static struct hda_pcm_stream vt1708B_pcm_digital_capture = {
1612         .substreams = 1,
1613         .channels_min = 2,
1614         .channels_max = 2,
1615 };
1616
1617 /* fill in the dac_nids table from the parsed pin configuration */
1618 static int vt1708B_auto_fill_dac_nids(struct via_spec *spec,
1619                                      const struct auto_pin_cfg *cfg)
1620 {
1621         int i;
1622         hda_nid_t nid;
1623
1624         spec->multiout.num_dacs = cfg->line_outs;
1625
1626         spec->multiout.dac_nids = spec->private_dac_nids;
1627
1628         for (i = 0; i < 4; i++) {
1629                 nid = cfg->line_out_pins[i];
1630                 if (nid) {
1631                         /* config dac list */
1632                         switch (i) {
1633                         case AUTO_SEQ_FRONT:
1634                                 spec->multiout.dac_nids[i] = 0x10;
1635                                 break;
1636                         case AUTO_SEQ_CENLFE:
1637                                 spec->multiout.dac_nids[i] = 0x24;
1638                                 break;
1639                         case AUTO_SEQ_SURROUND:
1640                                 spec->multiout.dac_nids[i] = 0x25;
1641                                 break;
1642                         case AUTO_SEQ_SIDE:
1643                                 spec->multiout.dac_nids[i] = 0x11;
1644                                 break;
1645                         }
1646                 }
1647         }
1648
1649         return 0;
1650 }
1651
1652 /* add playback controls from the parsed DAC table */
1653 static int vt1708B_auto_create_multi_out_ctls(struct via_spec *spec,
1654                                              const struct auto_pin_cfg *cfg)
1655 {
1656         char name[32];
1657         static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
1658         hda_nid_t nid_vols[] = {0x16, 0x27, 0x26, 0x18};
1659         hda_nid_t nid, nid_vol = 0;
1660         int i, err;
1661
1662         for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
1663                 nid = cfg->line_out_pins[i];
1664
1665                 if (!nid)
1666                         continue;
1667
1668                 nid_vol = nid_vols[i];
1669
1670                 if (i == AUTO_SEQ_CENLFE) {
1671                         /* Center/LFE */
1672                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1673                                               "Center Playback Volume",
1674                                               HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
1675                                                                   HDA_OUTPUT));
1676                         if (err < 0)
1677                                 return err;
1678                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1679                                               "LFE Playback Volume",
1680                                               HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
1681                                                                   HDA_OUTPUT));
1682                         if (err < 0)
1683                                 return err;
1684                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1685                                               "Center Playback Switch",
1686                                               HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
1687                                                                   HDA_OUTPUT));
1688                         if (err < 0)
1689                                 return err;
1690                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1691                                               "LFE Playback Switch",
1692                                               HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
1693                                                                   HDA_OUTPUT));
1694                         if (err < 0)
1695                                 return err;
1696                 } else if (i == AUTO_SEQ_FRONT) {
1697                         /* add control to mixer index 0 */
1698                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1699                                               "Master Front Playback Volume",
1700                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
1701                                                                   HDA_INPUT));
1702                         if (err < 0)
1703                                 return err;
1704                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1705                                               "Master Front Playback Switch",
1706                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
1707                                                                   HDA_INPUT));
1708                         if (err < 0)
1709                                 return err;
1710
1711                         /* add control to PW3 */
1712                         sprintf(name, "%s Playback Volume", chname[i]);
1713                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1714                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1715                                                                   HDA_OUTPUT));
1716                         if (err < 0)
1717                                 return err;
1718                         sprintf(name, "%s Playback Switch", chname[i]);
1719                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1720                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1721                                                                   HDA_OUTPUT));
1722                         if (err < 0)
1723                                 return err;
1724                 } else {
1725                         sprintf(name, "%s Playback Volume", chname[i]);
1726                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1727                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
1728                                                                   HDA_OUTPUT));
1729                         if (err < 0)
1730                                 return err;
1731                         sprintf(name, "%s Playback Switch", chname[i]);
1732                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1733                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
1734                                                                   HDA_OUTPUT));
1735                         if (err < 0)
1736                                 return err;
1737                 }
1738         }
1739
1740         return 0;
1741 }
1742
1743 static int vt1708B_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
1744 {
1745         int err;
1746
1747         if (!pin)
1748                 return 0;
1749
1750         spec->multiout.hp_nid = VT1708B_HP_NID; /* AOW3 */
1751
1752         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1753                               "Headphone Playback Volume",
1754                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1755         if (err < 0)
1756                 return err;
1757         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1758                               "Headphone Playback Switch",
1759                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1760         if (err < 0)
1761                 return err;
1762
1763         return 0;
1764 }
1765
1766 /* create playback/capture controls for input pins */
1767 static int vt1708B_auto_create_analog_input_ctls(struct via_spec *spec,
1768                                                 const struct auto_pin_cfg *cfg)
1769 {
1770         static char *labels[] = {
1771                 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
1772         };
1773         struct hda_input_mux *imux = &spec->private_imux;
1774         int i, err, idx = 0;
1775
1776         /* for internal loopback recording select */
1777         imux->items[imux->num_items].label = "Stereo Mixer";
1778         imux->items[imux->num_items].index = idx;
1779         imux->num_items++;
1780
1781         for (i = 0; i < AUTO_PIN_LAST; i++) {
1782                 if (!cfg->input_pins[i])
1783                         continue;
1784
1785                 switch (cfg->input_pins[i]) {
1786                 case 0x1a: /* Mic */
1787                         idx = 2;
1788                         break;
1789
1790                 case 0x1b: /* Line In */
1791                         idx = 3;
1792                         break;
1793
1794                 case 0x1e: /* Front Mic */
1795                         idx = 4;
1796                         break;
1797
1798                 case 0x1f: /* CD */
1799                         idx = 1;
1800                         break;
1801                 }
1802                 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
1803                                            idx, 0x16);
1804                 if (err < 0)
1805                         return err;
1806                 imux->items[imux->num_items].label = labels[i];
1807                 imux->items[imux->num_items].index = idx;
1808                 imux->num_items++;
1809         }
1810         return 0;
1811 }
1812
1813 static int vt1708B_parse_auto_config(struct hda_codec *codec)
1814 {
1815         struct via_spec *spec = codec->spec;
1816         int err;
1817
1818         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1819         if (err < 0)
1820                 return err;
1821         err = vt1708B_auto_fill_dac_nids(spec, &spec->autocfg);
1822         if (err < 0)
1823                 return err;
1824         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
1825                 return 0; /* can't find valid BIOS pin config */
1826
1827         err = vt1708B_auto_create_multi_out_ctls(spec, &spec->autocfg);
1828         if (err < 0)
1829                 return err;
1830         err = vt1708B_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
1831         if (err < 0)
1832                 return err;
1833         err = vt1708B_auto_create_analog_input_ctls(spec, &spec->autocfg);
1834         if (err < 0)
1835                 return err;
1836
1837         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
1838
1839         if (spec->autocfg.dig_out_pin)
1840                 spec->multiout.dig_out_nid = VT1708B_DIGOUT_NID;
1841         if (spec->autocfg.dig_in_pin)
1842                 spec->dig_in_nid = VT1708B_DIGIN_NID;
1843
1844         if (spec->kctl_alloc)
1845                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
1846
1847         spec->input_mux = &spec->private_imux;
1848
1849         return 1;
1850 }
1851
1852 #ifdef CONFIG_SND_HDA_POWER_SAVE
1853 static struct hda_amp_list vt1708B_loopbacks[] = {
1854         { 0x16, HDA_INPUT, 1 },
1855         { 0x16, HDA_INPUT, 2 },
1856         { 0x16, HDA_INPUT, 3 },
1857         { 0x16, HDA_INPUT, 4 },
1858         { } /* end */
1859 };
1860 #endif
1861
1862 static int patch_vt1708B_8ch(struct hda_codec *codec)
1863 {
1864         struct via_spec *spec;
1865         int err;
1866
1867         /* create a codec specific record */
1868         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
1869         if (spec == NULL)
1870                 return -ENOMEM;
1871
1872         codec->spec = spec;
1873
1874         /* automatic parse from the BIOS config */
1875         err = vt1708B_parse_auto_config(codec);
1876         if (err < 0) {
1877                 via_free(codec);
1878                 return err;
1879         } else if (!err) {
1880                 printk(KERN_INFO "hda_codec: Cannot set up configuration "
1881                        "from BIOS.  Using genenic mode...\n");
1882         }
1883
1884         spec->init_verbs = vt1708B_8ch_volume_init_verbs;
1885
1886         spec->stream_name_analog = "VT1708B Analog";
1887         spec->stream_analog_playback = &vt1708B_8ch_pcm_analog_playback;
1888         spec->stream_analog_capture = &vt1708B_pcm_analog_capture;
1889
1890         spec->stream_name_digital = "VT1708B Digital";
1891         spec->stream_digital_playback = &vt1708B_pcm_digital_playback;
1892         spec->stream_digital_capture = &vt1708B_pcm_digital_capture;
1893
1894         if (!spec->adc_nids && spec->input_mux) {
1895                 spec->adc_nids = vt1708B_adc_nids;
1896                 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids);
1897                 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer;
1898                 spec->num_mixers++;
1899         }
1900
1901         codec->patch_ops = via_patch_ops;
1902
1903         codec->patch_ops.init = via_auto_init;
1904 #ifdef CONFIG_SND_HDA_POWER_SAVE
1905         spec->loopback.amplist = vt1708B_loopbacks;
1906 #endif
1907
1908         return 0;
1909 }
1910
1911 static int patch_vt1708B_4ch(struct hda_codec *codec)
1912 {
1913         struct via_spec *spec;
1914         int err;
1915
1916         /* create a codec specific record */
1917         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
1918         if (spec == NULL)
1919                 return -ENOMEM;
1920
1921         codec->spec = spec;
1922
1923         /* automatic parse from the BIOS config */
1924         err = vt1708B_parse_auto_config(codec);
1925         if (err < 0) {
1926                 via_free(codec);
1927                 return err;
1928         } else if (!err) {
1929                 printk(KERN_INFO "hda_codec: Cannot set up configuration "
1930                        "from BIOS.  Using genenic mode...\n");
1931         }
1932
1933         spec->init_verbs = vt1708B_4ch_volume_init_verbs;
1934
1935         spec->stream_name_analog = "VT1708B Analog";
1936         spec->stream_analog_playback = &vt1708B_4ch_pcm_analog_playback;
1937         spec->stream_analog_capture = &vt1708B_pcm_analog_capture;
1938
1939         spec->stream_name_digital = "VT1708B Digital";
1940         spec->stream_digital_playback = &vt1708B_pcm_digital_playback;
1941         spec->stream_digital_capture = &vt1708B_pcm_digital_capture;
1942
1943         if (!spec->adc_nids && spec->input_mux) {
1944                 spec->adc_nids = vt1708B_adc_nids;
1945                 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids);
1946                 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer;
1947                 spec->num_mixers++;
1948         }
1949
1950         codec->patch_ops = via_patch_ops;
1951
1952         codec->patch_ops.init = via_auto_init;
1953 #ifdef CONFIG_SND_HDA_POWER_SAVE
1954         spec->loopback.amplist = vt1708B_loopbacks;
1955 #endif
1956
1957         return 0;
1958 }
1959
1960 /*
1961  * patch entries
1962  */
1963 struct hda_codec_preset snd_hda_preset_via[] = {
1964         { .id = 0x11061708, .name = "VIA VT1708", .patch = patch_vt1708},
1965         { .id = 0x11061709, .name = "VIA VT1708", .patch = patch_vt1708},
1966         { .id = 0x1106170A, .name = "VIA VT1708", .patch = patch_vt1708},
1967         { .id = 0x1106170B, .name = "VIA VT1708", .patch = patch_vt1708},
1968         { .id = 0x1106E710, .name = "VIA VT1709 10-Ch",
1969           .patch = patch_vt1709_10ch},
1970         { .id = 0x1106E711, .name = "VIA VT1709 10-Ch",
1971           .patch = patch_vt1709_10ch},
1972         { .id = 0x1106E712, .name = "VIA VT1709 10-Ch",
1973           .patch = patch_vt1709_10ch},
1974         { .id = 0x1106E713, .name = "VIA VT1709 10-Ch",
1975           .patch = patch_vt1709_10ch},
1976         { .id = 0x1106E714, .name = "VIA VT1709 6-Ch",
1977           .patch = patch_vt1709_6ch},
1978         { .id = 0x1106E715, .name = "VIA VT1709 6-Ch",
1979           .patch = patch_vt1709_6ch},
1980         { .id = 0x1106E716, .name = "VIA VT1709 6-Ch",
1981           .patch = patch_vt1709_6ch},
1982         { .id = 0x1106E717, .name = "VIA VT1709 6-Ch",
1983           .patch = patch_vt1709_6ch},
1984         { .id = 0x1106E720, .name = "VIA VT1708B 8-Ch",
1985           .patch = patch_vt1708B_8ch},
1986         { .id = 0x1106E721, .name = "VIA VT1708B 8-Ch",
1987           .patch = patch_vt1708B_8ch},
1988         { .id = 0x1106E722, .name = "VIA VT1708B 8-Ch",
1989           .patch = patch_vt1708B_8ch},
1990         { .id = 0x1106E723, .name = "VIA VT1708B 8-Ch",
1991           .patch = patch_vt1708B_8ch},
1992         { .id = 0x1106E724, .name = "VIA VT1708B 4-Ch",
1993           .patch = patch_vt1708B_4ch},
1994         { .id = 0x1106E725, .name = "VIA VT1708B 4-Ch",
1995           .patch = patch_vt1708B_4ch},
1996         { .id = 0x1106E726, .name = "VIA VT1708B 4-Ch",
1997           .patch = patch_vt1708B_4ch},
1998         { .id = 0x1106E727, .name = "VIA VT1708B 4-Ch",
1999           .patch = patch_vt1708B_4ch},
2000         {} /* terminator */
2001 };