sound/pci/hda/patch_analog.c

   1 /*
   2  * HD audio interface patch for AD1882, AD1884, AD1981HD, AD1983, AD1984,
   3  *   AD1986A, AD1988
   4  *
   5  * Copyright (c) 2005-2007 Takashi Iwai <tiwai@suse.de>
   6  *
   7  *  This driver is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This driver is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20  */
  21
  22 #include <linux/init.h>
  23 #include <linux/delay.h>
  24 #include <linux/slab.h>
  25 #include <linux/pci.h>
  26
  27 #include <sound/core.h>
  28 #include "hda_codec.h"
  29 #include "hda_local.h"
  30 #include "hda_beep.h"
  31
  32 struct ad198x_spec {
  33         struct snd_kcontrol_new *mixers[5];
  34         int num_mixers;
  35         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
  36         const struct hda_verb *init_verbs[5];   /* initialization verbs
  37                                                  * don't forget NULL termination!
  38                                                  */
  39         unsigned int num_init_verbs;
  40
  41         /* playback */
  42         struct hda_multi_out multiout;  /* playback set-up
  43                                          * max_channels, dacs must be set
  44                                          * dig_out_nid and hp_nid are optional
  45                                          */
  46         unsigned int cur_eapd;
  47         unsigned int need_dac_fix;
  48
  49         /* capture */
  50         unsigned int num_adc_nids;
  51         hda_nid_t *adc_nids;
  52         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
  53
  54         /* capture source */
  55         const struct hda_input_mux *input_mux;
  56         hda_nid_t *capsrc_nids;
  57         unsigned int cur_mux[3];
  58
  59         /* channel model */
  60         const struct hda_channel_mode *channel_mode;
  61         int num_channel_mode;
  62
  63         /* PCM information */
  64         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
  65
  66         unsigned int spdif_route;
  67
  68         /* dynamic controls, init_verbs and input_mux */
  69         struct auto_pin_cfg autocfg;
  70         struct snd_array kctls;
  71         struct hda_input_mux private_imux;
  72         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
  73
  74         unsigned int jack_present :1;
  75         unsigned int inv_jack_detect:1;
  76
  77 #ifdef CONFIG_SND_HDA_POWER_SAVE
  78         struct hda_loopback_check loopback;
  79 #endif
  80         /* for virtual master */
  81         hda_nid_t vmaster_nid;
  82         const char **slave_vols;
  83         const char **slave_sws;
  84 };
  85
  86 /*
  87  * input MUX handling (common part)
  88  */
  89 static int ad198x_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
  90 {
  91         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  92         struct ad198x_spec *spec = codec->spec;
  93
  94         return snd_hda_input_mux_info(spec->input_mux, uinfo);
  95 }
  96
  97 static int ad198x_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  98 {
  99         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 100         struct ad198x_spec *spec = codec->spec;
 101         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 102
 103         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 104         return 0;
 105 }
 106
 107 static int ad198x_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 108 {
 109         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 110         struct ad198x_spec *spec = codec->spec;
 111         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 112
 113         return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
 114                                      spec->capsrc_nids[adc_idx],
 115                                      &spec->cur_mux[adc_idx]);
 116 }
 117
 118 /*
 119  * initialization (common callbacks)
 120  */
 121 static int ad198x_init(struct hda_codec *codec)
 122 {
 123         struct ad198x_spec *spec = codec->spec;
 124         int i;
 125
 126         for (i = 0; i < spec->num_init_verbs; i++)
 127                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
 128         return 0;
 129 }
 130
 131 static const char *ad_slave_vols[] = {
 132         "Front Playback Volume",
 133         "Surround Playback Volume",
 134         "Center Playback Volume",
 135         "LFE Playback Volume",
 136         "Side Playback Volume",
 137         "Headphone Playback Volume",
 138         "Mono Playback Volume",
 139         "Speaker Playback Volume",
 140         "IEC958 Playback Volume",
 141         NULL
 142 };
 143
 144 static const char *ad_slave_sws[] = {
 145         "Front Playback Switch",
 146         "Surround Playback Switch",
 147         "Center Playback Switch",
 148         "LFE Playback Switch",
 149         "Side Playback Switch",
 150         "Headphone Playback Switch",
 151         "Mono Playback Switch",
 152         "Speaker Playback Switch",
 153         "IEC958 Playback Switch",
 154         NULL
 155 };
 156
 157 static void ad198x_free_kctls(struct hda_codec *codec);
 158
 159 /* additional beep mixers; the actual parameters are overwritten at build */
 160 static struct snd_kcontrol_new ad_beep_mixer[] = {
 161         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_OUTPUT),
 162         HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_OUTPUT),
 163         { } /* end */
 164 };
 165
 166 #define set_beep_amp(spec, nid, idx, dir) \
 167         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir)) /* mono */
 168
 169 static int ad198x_build_controls(struct hda_codec *codec)
 170 {
 171         struct ad198x_spec *spec = codec->spec;
 172         unsigned int i;
 173         int err;
 174
 175         for (i = 0; i < spec->num_mixers; i++) {
 176                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
 177                 if (err < 0)
 178                         return err;
 179         }
 180         if (spec->multiout.dig_out_nid) {
 181                 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
 182                 if (err < 0)
 183                         return err;
 184                 err = snd_hda_create_spdif_share_sw(codec,
 185                                                     &spec->multiout);
 186                 if (err < 0)
 187                         return err;
 188                 spec->multiout.share_spdif = 1;
 189         }
 190         if (spec->dig_in_nid) {
 191                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
 192                 if (err < 0)
 193                         return err;
 194         }
 195
 196         /* create beep controls if needed */
 197         if (spec->beep_amp) {
 198                 struct snd_kcontrol_new *knew;
 199                 for (knew = ad_beep_mixer; knew->name; knew++) {
 200                         struct snd_kcontrol *kctl;
 201                         kctl = snd_ctl_new1(knew, codec);
 202                         if (!kctl)
 203                                 return -ENOMEM;
 204                         kctl->private_value = spec->beep_amp;
 205                         err = snd_hda_ctl_add(codec, kctl);
 206                         if (err < 0)
 207                                 return err;
 208                 }
 209         }
 210
 211         /* if we have no master control, let's create it */
 212         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
 213                 unsigned int vmaster_tlv[4];
 214                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
 215                                         HDA_OUTPUT, vmaster_tlv);
 216                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
 217                                           vmaster_tlv,
 218                                           (spec->slave_vols ?
 219                                            spec->slave_vols : ad_slave_vols));
 220                 if (err < 0)
 221                         return err;
 222         }
 223         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
 224                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
 225                                           NULL,
 226                                           (spec->slave_sws ?
 227                                            spec->slave_sws : ad_slave_sws));
 228                 if (err < 0)
 229                         return err;
 230         }
 231
 232         ad198x_free_kctls(codec); /* no longer needed */
 233         return 0;
 234 }
 235
 236 #ifdef CONFIG_SND_HDA_POWER_SAVE
 237 static int ad198x_check_power_status(struct hda_codec *codec, hda_nid_t nid)
 238 {
 239         struct ad198x_spec *spec = codec->spec;
 240         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
 241 }
 242 #endif
 243
 244 /*
 245  * Analog playback callbacks
 246  */
 247 static int ad198x_playback_pcm_open(struct hda_pcm_stream *hinfo,
 248                                     struct hda_codec *codec,
 249                                     struct snd_pcm_substream *substream)
 250 {
 251         struct ad198x_spec *spec = codec->spec;
 252         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
 253                                              hinfo);
 254 }
 255
 256 static int ad198x_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 257                                        struct hda_codec *codec,
 258                                        unsigned int stream_tag,
 259                                        unsigned int format,
 260                                        struct snd_pcm_substream *substream)
 261 {
 262         struct ad198x_spec *spec = codec->spec;
 263         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
 264                                                 format, substream);
 265 }
 266
 267 static int ad198x_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
 268                                        struct hda_codec *codec,
 269                                        struct snd_pcm_substream *substream)
 270 {
 271         struct ad198x_spec *spec = codec->spec;
 272         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
 273 }
 274
 275 /*
 276  * Digital out
 277  */
 278 static int ad198x_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
 279                                         struct hda_codec *codec,
 280                                         struct snd_pcm_substream *substream)
 281 {
 282         struct ad198x_spec *spec = codec->spec;
 283         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
 284 }
 285
 286 static int ad198x_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
 287                                          struct hda_codec *codec,
 288                                          struct snd_pcm_substream *substream)
 289 {
 290         struct ad198x_spec *spec = codec->spec;
 291         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
 292 }
 293
 294 static int ad198x_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 295                                            struct hda_codec *codec,
 296                                            unsigned int stream_tag,
 297                                            unsigned int format,
 298                                            struct snd_pcm_substream *substream)
 299 {
 300         struct ad198x_spec *spec = codec->spec;
 301         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
 302                                              format, substream);
 303 }
 304
 305 static int ad198x_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
 306                                            struct hda_codec *codec,
 307                                            struct snd_pcm_substream *substream)
 308 {
 309         struct ad198x_spec *spec = codec->spec;
 310         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
 311 }
 312
 313 /*
 314  * Analog capture
 315  */
 316 static int ad198x_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
 317                                       struct hda_codec *codec,
 318                                       unsigned int stream_tag,
 319                                       unsigned int format,
 320                                       struct snd_pcm_substream *substream)
 321 {
 322         struct ad198x_spec *spec = codec->spec;
 323         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
 324                                    stream_tag, 0, format);
 325         return 0;
 326 }
 327
 328 static int ad198x_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
 329                                       struct hda_codec *codec,
 330                                       struct snd_pcm_substream *substream)
 331 {
 332         struct ad198x_spec *spec = codec->spec;
 333         snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
 334         return 0;
 335 }
 336
 337
 338 /*
 339  */
 340 static struct hda_pcm_stream ad198x_pcm_analog_playback = {
 341         .substreams = 1,
 342         .channels_min = 2,
 343         .channels_max = 6, /* changed later */
 344         .nid = 0, /* fill later */
 345         .ops = {
 346                 .open = ad198x_playback_pcm_open,
 347                 .prepare = ad198x_playback_pcm_prepare,
 348                 .cleanup = ad198x_playback_pcm_cleanup
 349         },
 350 };
 351
 352 static struct hda_pcm_stream ad198x_pcm_analog_capture = {
 353         .substreams = 1,
 354         .channels_min = 2,
 355         .channels_max = 2,
 356         .nid = 0, /* fill later */
 357         .ops = {
 358                 .prepare = ad198x_capture_pcm_prepare,
 359                 .cleanup = ad198x_capture_pcm_cleanup
 360         },
 361 };
 362
 363 static struct hda_pcm_stream ad198x_pcm_digital_playback = {
 364         .substreams = 1,
 365         .channels_min = 2,
 366         .channels_max = 2,
 367         .nid = 0, /* fill later */
 368         .ops = {
 369                 .open = ad198x_dig_playback_pcm_open,
 370                 .close = ad198x_dig_playback_pcm_close,
 371                 .prepare = ad198x_dig_playback_pcm_prepare,
 372                 .cleanup = ad198x_dig_playback_pcm_cleanup
 373         },
 374 };
 375
 376 static struct hda_pcm_stream ad198x_pcm_digital_capture = {
 377         .substreams = 1,
 378         .channels_min = 2,
 379         .channels_max = 2,
 380         /* NID is set in alc_build_pcms */
 381 };
 382
 383 static int ad198x_build_pcms(struct hda_codec *codec)
 384 {
 385         struct ad198x_spec *spec = codec->spec;
 386         struct hda_pcm *info = spec->pcm_rec;
 387
 388         codec->num_pcms = 1;
 389         codec->pcm_info = info;
 390
 391         info->name = "AD198x Analog";
 392         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_analog_playback;
 393         info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->multiout.max_channels;
 394         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
 395         info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_analog_capture;
 396         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adc_nids;
 397         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
 398
 399         if (spec->multiout.dig_out_nid) {
 400                 info++;
 401                 codec->num_pcms++;
 402                 info->name = "AD198x Digital";
 403                 info->pcm_type = HDA_PCM_TYPE_SPDIF;
 404                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_digital_playback;
 405                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
 406                 if (spec->dig_in_nid) {
 407                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_digital_capture;
 408                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
 409                 }
 410         }
 411
 412         return 0;
 413 }
 414
 415 static void ad198x_free_kctls(struct hda_codec *codec)
 416 {
 417         struct ad198x_spec *spec = codec->spec;
 418
 419         if (spec->kctls.list) {
 420                 struct snd_kcontrol_new *kctl = spec->kctls.list;
 421                 int i;
 422                 for (i = 0; i < spec->kctls.used; i++)
 423                         kfree(kctl[i].name);
 424         }
 425         snd_array_free(&spec->kctls);
 426 }
 427
 428 static void ad198x_free(struct hda_codec *codec)
 429 {
 430         struct ad198x_spec *spec = codec->spec;
 431
 432         if (!spec)
 433                 return;
 434
 435         ad198x_free_kctls(codec);
 436         kfree(spec);
 437         snd_hda_detach_beep_device(codec);
 438 }
 439
 440 static struct hda_codec_ops ad198x_patch_ops = {
 441         .build_controls = ad198x_build_controls,
 442         .build_pcms = ad198x_build_pcms,
 443         .init = ad198x_init,
 444         .free = ad198x_free,
 445 #ifdef CONFIG_SND_HDA_POWER_SAVE
 446         .check_power_status = ad198x_check_power_status,
 447 #endif
 448 };
 449
 450
 451 /*
 452  * EAPD control
 453  * the private value = nid | (invert << 8)
 454  */
 455 #define ad198x_eapd_info        snd_ctl_boolean_mono_info
 456
 457 static int ad198x_eapd_get(struct snd_kcontrol *kcontrol,
 458                            struct snd_ctl_elem_value *ucontrol)
 459 {
 460         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 461         struct ad198x_spec *spec = codec->spec;
 462         int invert = (kcontrol->private_value >> 8) & 1;
 463         if (invert)
 464                 ucontrol->value.integer.value[0] = ! spec->cur_eapd;
 465         else
 466                 ucontrol->value.integer.value[0] = spec->cur_eapd;
 467         return 0;
 468 }
 469
 470 static int ad198x_eapd_put(struct snd_kcontrol *kcontrol,
 471                            struct snd_ctl_elem_value *ucontrol)
 472 {
 473         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 474         struct ad198x_spec *spec = codec->spec;
 475         int invert = (kcontrol->private_value >> 8) & 1;
 476         hda_nid_t nid = kcontrol->private_value & 0xff;
 477         unsigned int eapd;
 478         eapd = !!ucontrol->value.integer.value[0];
 479         if (invert)
 480                 eapd = !eapd;
 481         if (eapd == spec->cur_eapd)
 482                 return 0;
 483         spec->cur_eapd = eapd;
 484         snd_hda_codec_write_cache(codec, nid,
 485                                   0, AC_VERB_SET_EAPD_BTLENABLE,
 486                                   eapd ? 0x02 : 0x00);
 487         return 1;
 488 }
 489
 490 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
 491                                struct snd_ctl_elem_info *uinfo);
 492 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
 493                               struct snd_ctl_elem_value *ucontrol);
 494 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
 495                               struct snd_ctl_elem_value *ucontrol);
 496
 497
 498 /*
 499  * AD1986A specific
 500  */
 501
 502 #define AD1986A_SPDIF_OUT       0x02
 503 #define AD1986A_FRONT_DAC       0x03
 504 #define AD1986A_SURR_DAC        0x04
 505 #define AD1986A_CLFE_DAC        0x05
 506 #define AD1986A_ADC             0x06
 507
 508 static hda_nid_t ad1986a_dac_nids[3] = {
 509         AD1986A_FRONT_DAC, AD1986A_SURR_DAC, AD1986A_CLFE_DAC
 510 };
 511 static hda_nid_t ad1986a_adc_nids[1] = { AD1986A_ADC };
 512 static hda_nid_t ad1986a_capsrc_nids[1] = { 0x12 };
 513
 514 static struct hda_input_mux ad1986a_capture_source = {
 515         .num_items = 7,
 516         .items = {
 517                 { "Mic", 0x0 },
 518                 { "CD", 0x1 },
 519                 { "Aux", 0x3 },
 520                 { "Line", 0x4 },
 521                 { "Mix", 0x5 },
 522                 { "Mono", 0x6 },
 523                 { "Phone", 0x7 },
 524         },
 525 };
 526
 527
 528 static struct hda_bind_ctls ad1986a_bind_pcm_vol = {
 529         .ops = &snd_hda_bind_vol,
 530         .values = {
 531                 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
 532                 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
 533                 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
 534                 0
 535         },
 536 };
 537
 538 static struct hda_bind_ctls ad1986a_bind_pcm_sw = {
 539         .ops = &snd_hda_bind_sw,
 540         .values = {
 541                 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
 542                 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
 543                 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
 544                 0
 545         },
 546 };
 547
 548 /*
 549  * mixers
 550  */
 551 static struct snd_kcontrol_new ad1986a_mixers[] = {
 552         /*
 553          * bind volumes/mutes of 3 DACs as a single PCM control for simplicity
 554          */
 555         HDA_BIND_VOL("PCM Playback Volume", &ad1986a_bind_pcm_vol),
 556         HDA_BIND_SW("PCM Playback Switch", &ad1986a_bind_pcm_sw),
 557         HDA_CODEC_VOLUME("Front Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
 558         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
 559         HDA_CODEC_VOLUME("Surround Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
 560         HDA_CODEC_MUTE("Surround Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
 561         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x1d, 1, 0x0, HDA_OUTPUT),
 562         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x1d, 2, 0x0, HDA_OUTPUT),
 563         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x1d, 1, 0x0, HDA_OUTPUT),
 564         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x1d, 2, 0x0, HDA_OUTPUT),
 565         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x1a, 0x0, HDA_OUTPUT),
 566         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
 567         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
 568         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
 569         HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
 570         HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
 571         HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
 572         HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
 573         HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
 574         HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
 575         HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
 576         HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
 577         HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT),
 578         HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
 579         HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
 580         {
 581                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 582                 .name = "Capture Source",
 583                 .info = ad198x_mux_enum_info,
 584                 .get = ad198x_mux_enum_get,
 585                 .put = ad198x_mux_enum_put,
 586         },
 587         HDA_CODEC_MUTE("Stereo Downmix Switch", 0x09, 0x0, HDA_OUTPUT),
 588         { } /* end */
 589 };
 590
 591 /* additional mixers for 3stack mode */
 592 static struct snd_kcontrol_new ad1986a_3st_mixers[] = {
 593         {
 594                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 595                 .name = "Channel Mode",
 596                 .info = ad198x_ch_mode_info,
 597                 .get = ad198x_ch_mode_get,
 598                 .put = ad198x_ch_mode_put,
 599         },
 600         { } /* end */
 601 };
 602
 603 /* laptop model - 2ch only */
 604 static hda_nid_t ad1986a_laptop_dac_nids[1] = { AD1986A_FRONT_DAC };
 605
 606 /* master controls both pins 0x1a and 0x1b */
 607 static struct hda_bind_ctls ad1986a_laptop_master_vol = {
 608         .ops = &snd_hda_bind_vol,
 609         .values = {
 610                 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
 611                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
 612                 0,
 613         },
 614 };
 615
 616 static struct hda_bind_ctls ad1986a_laptop_master_sw = {
 617         .ops = &snd_hda_bind_sw,
 618         .values = {
 619                 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
 620                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
 621                 0,
 622         },
 623 };
 624
 625 static struct snd_kcontrol_new ad1986a_laptop_mixers[] = {
 626         HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
 627         HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
 628         HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
 629         HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
 630         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
 631         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
 632         HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
 633         HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
 634         HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
 635         HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
 636         HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
 637         HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
 638         HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
 639         /*
 640            HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
 641            HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), */
 642         HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
 643         HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
 644         {
 645                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 646                 .name = "Capture Source",
 647                 .info = ad198x_mux_enum_info,
 648                 .get = ad198x_mux_enum_get,
 649                 .put = ad198x_mux_enum_put,
 650         },
 651         { } /* end */
 652 };
 653
 654 /* laptop-eapd model - 2ch only */
 655
 656 static struct hda_input_mux ad1986a_laptop_eapd_capture_source = {
 657         .num_items = 3,
 658         .items = {
 659                 { "Mic", 0x0 },
 660                 { "Internal Mic", 0x4 },
 661                 { "Mix", 0x5 },
 662         },
 663 };
 664
 665 static struct hda_input_mux ad1986a_automic_capture_source = {
 666         .num_items = 2,
 667         .items = {
 668                 { "Mic", 0x0 },
 669                 { "Mix", 0x5 },
 670         },
 671 };
 672
 673 static struct snd_kcontrol_new ad1986a_laptop_master_mixers[] = {
 674         HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
 675         HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
 676         { } /* end */
 677 };
 678
 679 static struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = {
 680         HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
 681         HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
 682         HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
 683         HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
 684         HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
 685         HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
 686         HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
 687         {
 688                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 689                 .name = "Capture Source",
 690                 .info = ad198x_mux_enum_info,
 691                 .get = ad198x_mux_enum_get,
 692                 .put = ad198x_mux_enum_put,
 693         },
 694         {
 695                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 696                 .name = "External Amplifier",
 697                 .info = ad198x_eapd_info,
 698                 .get = ad198x_eapd_get,
 699                 .put = ad198x_eapd_put,
 700                 .private_value = 0x1b | (1 << 8), /* port-D, inversed */
 701         },
 702         { } /* end */
 703 };
 704
 705 static struct snd_kcontrol_new ad1986a_laptop_intmic_mixers[] = {
 706         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0, HDA_OUTPUT),
 707         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0, HDA_OUTPUT),
 708         { } /* end */
 709 };
 710
 711 /* re-connect the mic boost input according to the jack sensing */
 712 static void ad1986a_automic(struct hda_codec *codec)
 713 {
 714         unsigned int present;
 715         present = snd_hda_codec_read(codec, 0x1f, 0, AC_VERB_GET_PIN_SENSE, 0);
 716         /* 0 = 0x1f, 2 = 0x1d, 4 = mixed */
 717         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_CONNECT_SEL,
 718                             (present & AC_PINSENSE_PRESENCE) ? 0 : 2);
 719 }
 720
 721 #define AD1986A_MIC_EVENT               0x36
 722
 723 static void ad1986a_automic_unsol_event(struct hda_codec *codec,
 724                                             unsigned int res)
 725 {
 726         if ((res >> 26) != AD1986A_MIC_EVENT)
 727                 return;
 728         ad1986a_automic(codec);
 729 }
 730
 731 static int ad1986a_automic_init(struct hda_codec *codec)
 732 {
 733         ad198x_init(codec);
 734         ad1986a_automic(codec);
 735         return 0;
 736 }
 737
 738 /* laptop-automute - 2ch only */
 739
 740 static void ad1986a_update_hp(struct hda_codec *codec)
 741 {
 742         struct ad198x_spec *spec = codec->spec;
 743         unsigned int mute;
 744
 745         if (spec->jack_present)
 746                 mute = HDA_AMP_MUTE; /* mute internal speaker */
 747         else
 748                 /* unmute internal speaker if necessary */
 749                 mute = snd_hda_codec_amp_read(codec, 0x1a, 0, HDA_OUTPUT, 0);
 750         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
 751                                  HDA_AMP_MUTE, mute);
 752 }
 753
 754 static void ad1986a_hp_automute(struct hda_codec *codec)
 755 {
 756         struct ad198x_spec *spec = codec->spec;
 757         unsigned int present;
 758
 759         present = snd_hda_codec_read(codec, 0x1a, 0, AC_VERB_GET_PIN_SENSE, 0);
 760         spec->jack_present = !!(present & 0x80000000);
 761         if (spec->inv_jack_detect)
 762                 spec->jack_present = !spec->jack_present;
 763         ad1986a_update_hp(codec);
 764 }
 765
 766 #define AD1986A_HP_EVENT                0x37
 767
 768 static void ad1986a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
 769 {
 770         if ((res >> 26) != AD1986A_HP_EVENT)
 771                 return;
 772         ad1986a_hp_automute(codec);
 773 }
 774
 775 static int ad1986a_hp_init(struct hda_codec *codec)
 776 {
 777         ad198x_init(codec);
 778         ad1986a_hp_automute(codec);
 779         return 0;
 780 }
 781
 782 /* bind hp and internal speaker mute (with plug check) */
 783 static int ad1986a_hp_master_sw_put(struct snd_kcontrol *kcontrol,
 784                                     struct snd_ctl_elem_value *ucontrol)
 785 {
 786         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 787         long *valp = ucontrol->value.integer.value;
 788         int change;
 789
 790         change = snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_OUTPUT, 0,
 791                                           HDA_AMP_MUTE,
 792                                           valp[0] ? 0 : HDA_AMP_MUTE);
 793         change |= snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_OUTPUT, 0,
 794                                            HDA_AMP_MUTE,
 795                                            valp[1] ? 0 : HDA_AMP_MUTE);
 796         if (change)
 797                 ad1986a_update_hp(codec);
 798         return change;
 799 }
 800
 801 static struct snd_kcontrol_new ad1986a_automute_master_mixers[] = {
 802         HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
 803         {
 804                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 805                 .name = "Master Playback Switch",
 806                 .info = snd_hda_mixer_amp_switch_info,
 807                 .get = snd_hda_mixer_amp_switch_get,
 808                 .put = ad1986a_hp_master_sw_put,
 809                 .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
 810         },
 811         { } /* end */
 812 };
 813
 814
 815 /*
 816  * initialization verbs
 817  */
 818 static struct hda_verb ad1986a_init_verbs[] = {
 819         /* Front, Surround, CLFE DAC; mute as default */
 820         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 821         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 822         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 823         /* Downmix - off */
 824         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 825         /* HP, Line-Out, Surround, CLFE selectors */
 826         {0x0a, AC_VERB_SET_CONNECT_SEL, 0x0},
 827         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0},
 828         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
 829         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
 830         /* Mono selector */
 831         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x0},
 832         /* Mic selector: Mic 1/2 pin */
 833         {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
 834         /* Line-in selector: Line-in */
 835         {0x10, AC_VERB_SET_CONNECT_SEL, 0x0},
 836         /* Mic 1/2 swap */
 837         {0x11, AC_VERB_SET_CONNECT_SEL, 0x0},
 838         /* Record selector: mic */
 839         {0x12, AC_VERB_SET_CONNECT_SEL, 0x0},
 840         /* Mic, Phone, CD, Aux, Line-In amp; mute as default */
 841         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 842         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 843         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 844         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 845         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 846         /* PC beep */
 847         {0x18, AC_VERB_SET_CONNECT_SEL, 0x0},
 848         /* HP, Line-Out, Surround, CLFE, Mono pins; mute as default */
 849         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 850         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 851         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 852         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 853         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 854         /* HP Pin */
 855         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
 856         /* Front, Surround, CLFE Pins */
 857         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
 858         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
 859         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
 860         /* Mono Pin */
 861         {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
 862         /* Mic Pin */
 863         {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
 864         /* Line, Aux, CD, Beep-In Pin */
 865         {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
 866         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
 867         {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
 868         {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
 869         {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
 870         { } /* end */
 871 };
 872
 873 static struct hda_verb ad1986a_ch2_init[] = {
 874         /* Surround out -> Line In */
 875         { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
 876         /* Line-in selectors */
 877         { 0x10, AC_VERB_SET_CONNECT_SEL, 0x1 },
 878         /* CLFE -> Mic in */
 879         { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
 880         /* Mic selector, mix C/LFE (backmic) and Mic (frontmic) */
 881         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
 882         { } /* end */
 883 };
 884
 885 static struct hda_verb ad1986a_ch4_init[] = {
 886         /* Surround out -> Surround */
 887         { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 888         { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
 889         /* CLFE -> Mic in */
 890         { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
 891         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
 892         { } /* end */
 893 };
 894
 895 static struct hda_verb ad1986a_ch6_init[] = {
 896         /* Surround out -> Surround out */
 897         { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 898         { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
 899         /* CLFE -> CLFE */
 900         { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 901         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x0 },
 902         { } /* end */
 903 };
 904
 905 static struct hda_channel_mode ad1986a_modes[3] = {
 906         { 2, ad1986a_ch2_init },
 907         { 4, ad1986a_ch4_init },
 908         { 6, ad1986a_ch6_init },
 909 };
 910
 911 /* eapd initialization */
 912 static struct hda_verb ad1986a_eapd_init_verbs[] = {
 913         {0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
 914         {}
 915 };
 916
 917 static struct hda_verb ad1986a_automic_verbs[] = {
 918         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 919         {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 920         /*{0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},*/
 921         {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
 922         {0x1f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_MIC_EVENT},
 923         {}
 924 };
 925
 926 /* Ultra initialization */
 927 static struct hda_verb ad1986a_ultra_init[] = {
 928         /* eapd initialization */
 929         { 0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
 930         /* CLFE -> Mic in */
 931         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2 },
 932         { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
 933         { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
 934         { } /* end */
 935 };
 936
 937 /* pin sensing on HP jack */
 938 static struct hda_verb ad1986a_hp_init_verbs[] = {
 939         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_HP_EVENT},
 940         {}
 941 };
 942
 943 static void ad1986a_samsung_p50_unsol_event(struct hda_codec *codec,
 944                                             unsigned int res)
 945 {
 946         switch (res >> 26) {
 947         case AD1986A_HP_EVENT:
 948                 ad1986a_hp_automute(codec);
 949                 break;
 950         case AD1986A_MIC_EVENT:
 951                 ad1986a_automic(codec);
 952                 break;
 953         }
 954 }
 955
 956 static int ad1986a_samsung_p50_init(struct hda_codec *codec)
 957 {
 958         ad198x_init(codec);
 959         ad1986a_hp_automute(codec);
 960         ad1986a_automic(codec);
 961         return 0;
 962 }
 963
 964
 965 /* models */
 966 enum {
 967         AD1986A_6STACK,
 968         AD1986A_3STACK,
 969         AD1986A_LAPTOP,
 970         AD1986A_LAPTOP_EAPD,
 971         AD1986A_LAPTOP_AUTOMUTE,
 972         AD1986A_ULTRA,
 973         AD1986A_SAMSUNG,
 974         AD1986A_SAMSUNG_P50,
 975         AD1986A_MODELS
 976 };
 977
 978 static const char *ad1986a_models[AD1986A_MODELS] = {
 979         [AD1986A_6STACK]        = "6stack",
 980         [AD1986A_3STACK]        = "3stack",
 981         [AD1986A_LAPTOP]        = "laptop",
 982         [AD1986A_LAPTOP_EAPD]   = "laptop-eapd",
 983         [AD1986A_LAPTOP_AUTOMUTE] = "laptop-automute",
 984         [AD1986A_ULTRA]         = "ultra",
 985         [AD1986A_SAMSUNG]       = "samsung",
 986         [AD1986A_SAMSUNG_P50]   = "samsung-p50",
 987 };
 988
 989 static struct snd_pci_quirk ad1986a_cfg_tbl[] = {
 990         SND_PCI_QUIRK(0x103c, 0x30af, "HP B2800", AD1986A_LAPTOP_EAPD),
 991         SND_PCI_QUIRK(0x1043, 0x1153, "ASUS M9", AD1986A_LAPTOP_EAPD),
 992         SND_PCI_QUIRK(0x1043, 0x11f7, "ASUS U5A", AD1986A_LAPTOP_EAPD),
 993         SND_PCI_QUIRK(0x1043, 0x1213, "ASUS A6J", AD1986A_LAPTOP_EAPD),
 994         SND_PCI_QUIRK(0x1043, 0x1263, "ASUS U5F", AD1986A_LAPTOP_EAPD),
 995         SND_PCI_QUIRK(0x1043, 0x1297, "ASUS Z62F", AD1986A_LAPTOP_EAPD),
 996         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS V1j", AD1986A_LAPTOP_EAPD),
 997         SND_PCI_QUIRK(0x1043, 0x1302, "ASUS W3j", AD1986A_LAPTOP_EAPD),
 998         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS VX1", AD1986A_LAPTOP),
 999         SND_PCI_QUIRK(0x1043, 0x1447, "ASUS A8J", AD1986A_3STACK),
1000         SND_PCI_QUIRK(0x1043, 0x817f, "ASUS P5", AD1986A_3STACK),
1001         SND_PCI_QUIRK(0x1043, 0x818f, "ASUS P5", AD1986A_LAPTOP),
1002         SND_PCI_QUIRK(0x1043, 0x81b3, "ASUS P5", AD1986A_3STACK),
1003         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS M2N", AD1986A_3STACK),
1004         SND_PCI_QUIRK(0x1043, 0x8234, "ASUS M2N", AD1986A_3STACK),
1005         SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_3STACK),
1006         SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba", AD1986A_LAPTOP_EAPD),
1007         SND_PCI_QUIRK(0x144d, 0xb03c, "Samsung R55", AD1986A_3STACK),
1008         SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_LAPTOP),
1009         SND_PCI_QUIRK(0x144d, 0xc024, "Samsung P50", AD1986A_SAMSUNG_P50),
1010         SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_ULTRA),
1011         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc000, "Samsung", AD1986A_SAMSUNG),
1012         SND_PCI_QUIRK(0x144d, 0xc504, "Samsung Q35", AD1986A_3STACK),
1013         SND_PCI_QUIRK(0x17aa, 0x1011, "Lenovo M55", AD1986A_LAPTOP),
1014         SND_PCI_QUIRK(0x17aa, 0x1017, "Lenovo A60", AD1986A_3STACK),
1015         SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo N100", AD1986A_LAPTOP_AUTOMUTE),
1016         SND_PCI_QUIRK(0x17c0, 0x2017, "Samsung M50", AD1986A_LAPTOP),
1017         {}
1018 };
1019
1020 #ifdef CONFIG_SND_HDA_POWER_SAVE
1021 static struct hda_amp_list ad1986a_loopbacks[] = {
1022         { 0x13, HDA_OUTPUT, 0 }, /* Mic */
1023         { 0x14, HDA_OUTPUT, 0 }, /* Phone */
1024         { 0x15, HDA_OUTPUT, 0 }, /* CD */
1025         { 0x16, HDA_OUTPUT, 0 }, /* Aux */
1026         { 0x17, HDA_OUTPUT, 0 }, /* Line */
1027         { } /* end */
1028 };
1029 #endif
1030
1031 static int is_jack_available(struct hda_codec *codec, hda_nid_t nid)
1032 {
1033         unsigned int conf = snd_hda_codec_get_pincfg(codec, nid);
1034         return get_defcfg_connect(conf) != AC_JACK_PORT_NONE;
1035 }
1036
1037 static int patch_ad1986a(struct hda_codec *codec)
1038 {
1039         struct ad198x_spec *spec;
1040         int err, board_config;
1041
1042         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1043         if (spec == NULL)
1044                 return -ENOMEM;
1045
1046         codec->spec = spec;
1047
1048         err = snd_hda_attach_beep_device(codec, 0x19);
1049         if (err < 0) {
1050                 ad198x_free(codec);
1051                 return err;
1052         }
1053         set_beep_amp(spec, 0x18, 0, HDA_OUTPUT);
1054
1055         spec->multiout.max_channels = 6;
1056         spec->multiout.num_dacs = ARRAY_SIZE(ad1986a_dac_nids);
1057         spec->multiout.dac_nids = ad1986a_dac_nids;
1058         spec->multiout.dig_out_nid = AD1986A_SPDIF_OUT;
1059         spec->num_adc_nids = 1;
1060         spec->adc_nids = ad1986a_adc_nids;
1061         spec->capsrc_nids = ad1986a_capsrc_nids;
1062         spec->input_mux = &ad1986a_capture_source;
1063         spec->num_mixers = 1;
1064         spec->mixers[0] = ad1986a_mixers;
1065         spec->num_init_verbs = 1;
1066         spec->init_verbs[0] = ad1986a_init_verbs;
1067 #ifdef CONFIG_SND_HDA_POWER_SAVE
1068         spec->loopback.amplist = ad1986a_loopbacks;
1069 #endif
1070         spec->vmaster_nid = 0x1b;
1071
1072         codec->patch_ops = ad198x_patch_ops;
1073
1074         /* override some parameters */
1075         board_config = snd_hda_check_board_config(codec, AD1986A_MODELS,
1076                                                   ad1986a_models,
1077                                                   ad1986a_cfg_tbl);
1078         switch (board_config) {
1079         case AD1986A_3STACK:
1080                 spec->num_mixers = 2;
1081                 spec->mixers[1] = ad1986a_3st_mixers;
1082                 spec->num_init_verbs = 2;
1083                 spec->init_verbs[1] = ad1986a_ch2_init;
1084                 spec->channel_mode = ad1986a_modes;
1085                 spec->num_channel_mode = ARRAY_SIZE(ad1986a_modes);
1086                 spec->need_dac_fix = 1;
1087                 spec->multiout.max_channels = 2;
1088                 spec->multiout.num_dacs = 1;
1089                 break;
1090         case AD1986A_LAPTOP:
1091                 spec->mixers[0] = ad1986a_laptop_mixers;
1092                 spec->multiout.max_channels = 2;
1093                 spec->multiout.num_dacs = 1;
1094                 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1095                 break;
1096         case AD1986A_LAPTOP_EAPD:
1097                 spec->num_mixers = 3;
1098                 spec->mixers[0] = ad1986a_laptop_master_mixers;
1099                 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1100                 spec->mixers[2] = ad1986a_laptop_intmic_mixers;
1101                 spec->num_init_verbs = 2;
1102                 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1103                 spec->multiout.max_channels = 2;
1104                 spec->multiout.num_dacs = 1;
1105                 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1106                 if (!is_jack_available(codec, 0x25))
1107                         spec->multiout.dig_out_nid = 0;
1108                 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
1109                 break;
1110         case AD1986A_SAMSUNG:
1111                 spec->num_mixers = 2;
1112                 spec->mixers[0] = ad1986a_laptop_master_mixers;
1113                 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1114                 spec->num_init_verbs = 3;
1115                 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1116                 spec->init_verbs[2] = ad1986a_automic_verbs;
1117                 spec->multiout.max_channels = 2;
1118                 spec->multiout.num_dacs = 1;
1119                 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1120                 if (!is_jack_available(codec, 0x25))
1121                         spec->multiout.dig_out_nid = 0;
1122                 spec->input_mux = &ad1986a_automic_capture_source;
1123                 codec->patch_ops.unsol_event = ad1986a_automic_unsol_event;
1124                 codec->patch_ops.init = ad1986a_automic_init;
1125                 break;
1126         case AD1986A_SAMSUNG_P50:
1127                 spec->num_mixers = 2;
1128                 spec->mixers[0] = ad1986a_automute_master_mixers;
1129                 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1130                 spec->num_init_verbs = 4;
1131                 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1132                 spec->init_verbs[2] = ad1986a_automic_verbs;
1133                 spec->init_verbs[3] = ad1986a_hp_init_verbs;
1134                 spec->multiout.max_channels = 2;
1135                 spec->multiout.num_dacs = 1;
1136                 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1137                 if (!is_jack_available(codec, 0x25))
1138                         spec->multiout.dig_out_nid = 0;
1139                 spec->input_mux = &ad1986a_automic_capture_source;
1140                 codec->patch_ops.unsol_event = ad1986a_samsung_p50_unsol_event;
1141                 codec->patch_ops.init = ad1986a_samsung_p50_init;
1142                 break;
1143         case AD1986A_LAPTOP_AUTOMUTE:
1144                 spec->num_mixers = 3;
1145                 spec->mixers[0] = ad1986a_automute_master_mixers;
1146                 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1147                 spec->mixers[2] = ad1986a_laptop_intmic_mixers;
1148                 spec->num_init_verbs = 3;
1149                 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1150                 spec->init_verbs[2] = ad1986a_hp_init_verbs;
1151                 spec->multiout.max_channels = 2;
1152                 spec->multiout.num_dacs = 1;
1153                 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1154                 if (!is_jack_available(codec, 0x25))
1155                         spec->multiout.dig_out_nid = 0;
1156                 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
1157                 codec->patch_ops.unsol_event = ad1986a_hp_unsol_event;
1158                 codec->patch_ops.init = ad1986a_hp_init;
1159                 /* Lenovo N100 seems to report the reversed bit
1160                  * for HP jack-sensing
1161                  */
1162                 spec->inv_jack_detect = 1;
1163                 break;
1164         case AD1986A_ULTRA:
1165                 spec->mixers[0] = ad1986a_laptop_eapd_mixers;
1166                 spec->num_init_verbs = 2;
1167                 spec->init_verbs[1] = ad1986a_ultra_init;
1168                 spec->multiout.max_channels = 2;
1169                 spec->multiout.num_dacs = 1;
1170                 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1171                 spec->multiout.dig_out_nid = 0;
1172                 break;
1173         }
1174
1175         /* AD1986A has a hardware problem that it can't share a stream
1176          * with multiple output pins.  The copy of front to surrounds
1177          * causes noisy or silent outputs at a certain timing, e.g.
1178          * changing the volume.
1179          * So, let's disable the shared stream.
1180          */
1181         spec->multiout.no_share_stream = 1;
1182
1183         return 0;
1184 }
1185
1186 /*
1187  * AD1983 specific
1188  */
1189
1190 #define AD1983_SPDIF_OUT        0x02
1191 #define AD1983_DAC              0x03
1192 #define AD1983_ADC              0x04
1193
1194 static hda_nid_t ad1983_dac_nids[1] = { AD1983_DAC };
1195 static hda_nid_t ad1983_adc_nids[1] = { AD1983_ADC };
1196 static hda_nid_t ad1983_capsrc_nids[1] = { 0x15 };
1197
1198 static struct hda_input_mux ad1983_capture_source = {
1199         .num_items = 4,
1200         .items = {
1201                 { "Mic", 0x0 },
1202                 { "Line", 0x1 },
1203                 { "Mix", 0x2 },
1204                 { "Mix Mono", 0x3 },
1205         },
1206 };
1207
1208 /*
1209  * SPDIF playback route
1210  */
1211 static int ad1983_spdif_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1212 {
1213         static char *texts[] = { "PCM", "ADC" };
1214
1215         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1216         uinfo->count = 1;
1217         uinfo->value.enumerated.items = 2;
1218         if (uinfo->value.enumerated.item > 1)
1219                 uinfo->value.enumerated.item = 1;
1220         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1221         return 0;
1222 }
1223
1224 static int ad1983_spdif_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1225 {
1226         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1227         struct ad198x_spec *spec = codec->spec;
1228
1229         ucontrol->value.enumerated.item[0] = spec->spdif_route;
1230         return 0;
1231 }
1232
1233 static int ad1983_spdif_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1234 {
1235         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1236         struct ad198x_spec *spec = codec->spec;
1237
1238         if (ucontrol->value.enumerated.item[0] > 1)
1239                 return -EINVAL;
1240         if (spec->spdif_route != ucontrol->value.enumerated.item[0]) {
1241                 spec->spdif_route = ucontrol->value.enumerated.item[0];
1242                 snd_hda_codec_write_cache(codec, spec->multiout.dig_out_nid, 0,
1243                                           AC_VERB_SET_CONNECT_SEL,
1244                                           spec->spdif_route);
1245                 return 1;
1246         }
1247         return 0;
1248 }
1249
1250 static struct snd_kcontrol_new ad1983_mixers[] = {
1251         HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1252         HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1253         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1254         HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1255         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1256         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1257         HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1258         HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1259         HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1260         HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1261         HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1262         HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1263         HDA_CODEC_VOLUME("Mic Boost", 0x0c, 0x0, HDA_OUTPUT),
1264         HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1265         HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1266         {
1267                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1268                 .name = "Capture Source",
1269                 .info = ad198x_mux_enum_info,
1270                 .get = ad198x_mux_enum_get,
1271                 .put = ad198x_mux_enum_put,
1272         },
1273         {
1274                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1275                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1276                 .info = ad1983_spdif_route_info,
1277                 .get = ad1983_spdif_route_get,
1278                 .put = ad1983_spdif_route_put,
1279         },
1280         { } /* end */
1281 };
1282
1283 static struct hda_verb ad1983_init_verbs[] = {
1284         /* Front, HP, Mono; mute as default */
1285         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1286         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1287         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1288         /* Beep, PCM, Mic, Line-In: mute */
1289         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1290         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1291         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1292         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1293         /* Front, HP selectors; from Mix */
1294         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1295         {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1296         /* Mono selector; from Mix */
1297         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1298         /* Mic selector; Mic */
1299         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
1300         /* Line-in selector: Line-in */
1301         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
1302         /* Mic boost: 0dB */
1303         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1304         /* Record selector: mic */
1305         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1306         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1307         /* SPDIF route: PCM */
1308         {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1309         /* Front Pin */
1310         {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1311         /* HP Pin */
1312         {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1313         /* Mono Pin */
1314         {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1315         /* Mic Pin */
1316         {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1317         /* Line Pin */
1318         {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1319         { } /* end */
1320 };
1321
1322 #ifdef CONFIG_SND_HDA_POWER_SAVE
1323 static struct hda_amp_list ad1983_loopbacks[] = {
1324         { 0x12, HDA_OUTPUT, 0 }, /* Mic */
1325         { 0x13, HDA_OUTPUT, 0 }, /* Line */
1326         { } /* end */
1327 };
1328 #endif
1329
1330 static int patch_ad1983(struct hda_codec *codec)
1331 {
1332         struct ad198x_spec *spec;
1333         int err;
1334
1335         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1336         if (spec == NULL)
1337                 return -ENOMEM;
1338
1339         codec->spec = spec;
1340
1341         err = snd_hda_attach_beep_device(codec, 0x10);
1342         if (err < 0) {
1343                 ad198x_free(codec);
1344                 return err;
1345         }
1346         set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
1347
1348         spec->multiout.max_channels = 2;
1349         spec->multiout.num_dacs = ARRAY_SIZE(ad1983_dac_nids);
1350         spec->multiout.dac_nids = ad1983_dac_nids;
1351         spec->multiout.dig_out_nid = AD1983_SPDIF_OUT;
1352         spec->num_adc_nids = 1;
1353         spec->adc_nids = ad1983_adc_nids;
1354         spec->capsrc_nids = ad1983_capsrc_nids;
1355         spec->input_mux = &ad1983_capture_source;
1356         spec->num_mixers = 1;
1357         spec->mixers[0] = ad1983_mixers;
1358         spec->num_init_verbs = 1;
1359         spec->init_verbs[0] = ad1983_init_verbs;
1360         spec->spdif_route = 0;
1361 #ifdef CONFIG_SND_HDA_POWER_SAVE
1362         spec->loopback.amplist = ad1983_loopbacks;
1363 #endif
1364         spec->vmaster_nid = 0x05;
1365
1366         codec->patch_ops = ad198x_patch_ops;
1367
1368         return 0;
1369 }
1370
1371
1372 /*
1373  * AD1981 HD specific
1374  */
1375
1376 #define AD1981_SPDIF_OUT        0x02
1377 #define AD1981_DAC              0x03
1378 #define AD1981_ADC              0x04
1379
1380 static hda_nid_t ad1981_dac_nids[1] = { AD1981_DAC };
1381 static hda_nid_t ad1981_adc_nids[1] = { AD1981_ADC };
1382 static hda_nid_t ad1981_capsrc_nids[1] = { 0x15 };
1383
1384 /* 0x0c, 0x09, 0x0e, 0x0f, 0x19, 0x05, 0x18, 0x17 */
1385 static struct hda_input_mux ad1981_capture_source = {
1386         .num_items = 7,
1387         .items = {
1388                 { "Front Mic", 0x0 },
1389                 { "Line", 0x1 },
1390                 { "Mix", 0x2 },
1391                 { "Mix Mono", 0x3 },
1392                 { "CD", 0x4 },
1393                 { "Mic", 0x6 },
1394                 { "Aux", 0x7 },
1395         },
1396 };
1397
1398 static struct snd_kcontrol_new ad1981_mixers[] = {
1399         HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1400         HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1401         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1402         HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1403         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1404         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1405         HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1406         HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1407         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1408         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1409         HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1410         HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1411         HDA_CODEC_VOLUME("Aux Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
1412         HDA_CODEC_MUTE("Aux Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1413         HDA_CODEC_VOLUME("Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1414         HDA_CODEC_MUTE("Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1415         HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1416         HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1417         HDA_CODEC_VOLUME("Front Mic Boost", 0x08, 0x0, HDA_INPUT),
1418         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x0, HDA_INPUT),
1419         HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1420         HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1421         {
1422                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1423                 .name = "Capture Source",
1424                 .info = ad198x_mux_enum_info,
1425                 .get = ad198x_mux_enum_get,
1426                 .put = ad198x_mux_enum_put,
1427         },
1428         /* identical with AD1983 */
1429         {
1430                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1431                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1432                 .info = ad1983_spdif_route_info,
1433                 .get = ad1983_spdif_route_get,
1434                 .put = ad1983_spdif_route_put,
1435         },
1436         { } /* end */
1437 };
1438
1439 static struct hda_verb ad1981_init_verbs[] = {
1440         /* Front, HP, Mono; mute as default */
1441         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1442         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1443         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1444         /* Beep, PCM, Front Mic, Line, Rear Mic, Aux, CD-In: mute */
1445         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1446         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1447         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1448         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1449         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1450         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1451         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1452         /* Front, HP selectors; from Mix */
1453         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1454         {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1455         /* Mono selector; from Mix */
1456         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1457         /* Mic Mixer; select Front Mic */
1458         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1459         {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1460         /* Mic boost: 0dB */
1461         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1462         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1463         /* Record selector: Front mic */
1464         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1465         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1466         /* SPDIF route: PCM */
1467         {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1468         /* Front Pin */
1469         {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1470         /* HP Pin */
1471         {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1472         /* Mono Pin */
1473         {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1474         /* Front & Rear Mic Pins */
1475         {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1476         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1477         /* Line Pin */
1478         {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1479         /* Digital Beep */
1480         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
1481         /* Line-Out as Input: disabled */
1482         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1483         { } /* end */
1484 };
1485
1486 #ifdef CONFIG_SND_HDA_POWER_SAVE
1487 static struct hda_amp_list ad1981_loopbacks[] = {
1488         { 0x12, HDA_OUTPUT, 0 }, /* Front Mic */
1489         { 0x13, HDA_OUTPUT, 0 }, /* Line */
1490         { 0x1b, HDA_OUTPUT, 0 }, /* Aux */
1491         { 0x1c, HDA_OUTPUT, 0 }, /* Mic */
1492         { 0x1d, HDA_OUTPUT, 0 }, /* CD */
1493         { } /* end */
1494 };
1495 #endif
1496
1497 /*
1498  * Patch for HP nx6320
1499  *
1500  * nx6320 uses EAPD in the reverse way - EAPD-on means the internal
1501  * speaker output enabled _and_ mute-LED off.
1502  */
1503
1504 #define AD1981_HP_EVENT         0x37
1505 #define AD1981_MIC_EVENT        0x38
1506
1507 static struct hda_verb ad1981_hp_init_verbs[] = {
1508         {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, /* default off */
1509         /* pin sensing on HP and Mic jacks */
1510         {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1511         {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1512         {}
1513 };
1514
1515 /* turn on/off EAPD (+ mute HP) as a master switch */
1516 static int ad1981_hp_master_sw_put(struct snd_kcontrol *kcontrol,
1517                                    struct snd_ctl_elem_value *ucontrol)
1518 {
1519         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1520         struct ad198x_spec *spec = codec->spec;
1521
1522         if (! ad198x_eapd_put(kcontrol, ucontrol))
1523                 return 0;
1524         /* change speaker pin appropriately */
1525         snd_hda_codec_write(codec, 0x05, 0,
1526                             AC_VERB_SET_PIN_WIDGET_CONTROL,
1527                             spec->cur_eapd ? PIN_OUT : 0);
1528         /* toggle HP mute appropriately */
1529         snd_hda_codec_amp_stereo(codec, 0x06, HDA_OUTPUT, 0,
1530                                  HDA_AMP_MUTE,
1531                                  spec->cur_eapd ? 0 : HDA_AMP_MUTE);
1532         return 1;
1533 }
1534
1535 /* bind volumes of both NID 0x05 and 0x06 */
1536 static struct hda_bind_ctls ad1981_hp_bind_master_vol = {
1537         .ops = &snd_hda_bind_vol,
1538         .values = {
1539                 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
1540                 HDA_COMPOSE_AMP_VAL(0x06, 3, 0, HDA_OUTPUT),
1541                 0
1542         },
1543 };
1544
1545 /* mute internal speaker if HP is plugged */
1546 static void ad1981_hp_automute(struct hda_codec *codec)
1547 {
1548         unsigned int present;
1549
1550         present = snd_hda_codec_read(codec, 0x06, 0,
1551                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1552         snd_hda_codec_amp_stereo(codec, 0x05, HDA_OUTPUT, 0,
1553                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
1554 }
1555
1556 /* toggle input of built-in and mic jack appropriately */
1557 static void ad1981_hp_automic(struct hda_codec *codec)
1558 {
1559         static struct hda_verb mic_jack_on[] = {
1560                 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1561                 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1562                 {}
1563         };
1564         static struct hda_verb mic_jack_off[] = {
1565                 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1566                 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1567                 {}
1568         };
1569         unsigned int present;
1570
1571         present = snd_hda_codec_read(codec, 0x08, 0,
1572                                  AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1573         if (present)
1574                 snd_hda_sequence_write(codec, mic_jack_on);
1575         else
1576                 snd_hda_sequence_write(codec, mic_jack_off);
1577 }
1578
1579 /* unsolicited event for HP jack sensing */
1580 static void ad1981_hp_unsol_event(struct hda_codec *codec,
1581                                   unsigned int res)
1582 {
1583         res >>= 26;
1584         switch (res) {
1585         case AD1981_HP_EVENT:
1586                 ad1981_hp_automute(codec);
1587                 break;
1588         case AD1981_MIC_EVENT:
1589                 ad1981_hp_automic(codec);
1590                 break;
1591         }
1592 }
1593
1594 static struct hda_input_mux ad1981_hp_capture_source = {
1595         .num_items = 3,
1596         .items = {
1597                 { "Mic", 0x0 },
1598                 { "Docking-Station", 0x1 },
1599                 { "Mix", 0x2 },
1600         },
1601 };
1602
1603 static struct snd_kcontrol_new ad1981_hp_mixers[] = {
1604         HDA_BIND_VOL("Master Playback Volume", &ad1981_hp_bind_master_vol),
1605         {
1606                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1607                 .name = "Master Playback Switch",
1608                 .info = ad198x_eapd_info,
1609                 .get = ad198x_eapd_get,
1610                 .put = ad1981_hp_master_sw_put,
1611                 .private_value = 0x05,
1612         },
1613         HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1614         HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1615 #if 0
1616         /* FIXME: analog mic/line loopback doesn't work with my tests...
1617          *        (although recording is OK)
1618          */
1619         HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1620         HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1621         HDA_CODEC_VOLUME("Docking-Station Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1622         HDA_CODEC_MUTE("Docking-Station Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1623         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1624         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1625         /* FIXME: does this laptop have analog CD connection? */
1626         HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1627         HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1628 #endif
1629         HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
1630         HDA_CODEC_VOLUME("Internal Mic Boost", 0x18, 0x0, HDA_INPUT),
1631         HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1632         HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1633         {
1634                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1635                 .name = "Capture Source",
1636                 .info = ad198x_mux_enum_info,
1637                 .get = ad198x_mux_enum_get,
1638                 .put = ad198x_mux_enum_put,
1639         },
1640         { } /* end */
1641 };
1642
1643 /* initialize jack-sensing, too */
1644 static int ad1981_hp_init(struct hda_codec *codec)
1645 {
1646         ad198x_init(codec);
1647         ad1981_hp_automute(codec);
1648         ad1981_hp_automic(codec);
1649         return 0;
1650 }
1651
1652 /* configuration for Toshiba Laptops */
1653 static struct hda_verb ad1981_toshiba_init_verbs[] = {
1654         {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x01 }, /* default on */
1655         /* pin sensing on HP and Mic jacks */
1656         {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1657         {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1658         {}
1659 };
1660
1661 static struct snd_kcontrol_new ad1981_toshiba_mixers[] = {
1662         HDA_CODEC_VOLUME("Amp Volume", 0x1a, 0x0, HDA_OUTPUT),
1663         HDA_CODEC_MUTE("Amp Switch", 0x1a, 0x0, HDA_OUTPUT),
1664         { }
1665 };
1666
1667 /* configuration for Lenovo Thinkpad T60 */
1668 static struct snd_kcontrol_new ad1981_thinkpad_mixers[] = {
1669         HDA_CODEC_VOLUME("Master Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1670         HDA_CODEC_MUTE("Master Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1671         HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1672         HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1673         HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1674         HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1675         HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1676         HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1677         HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
1678         HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1679         HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1680         {
1681                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1682                 .name = "Capture Source",
1683                 .info = ad198x_mux_enum_info,
1684                 .get = ad198x_mux_enum_get,
1685                 .put = ad198x_mux_enum_put,
1686         },
1687         /* identical with AD1983 */
1688         {
1689                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1690                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1691                 .info = ad1983_spdif_route_info,
1692                 .get = ad1983_spdif_route_get,
1693                 .put = ad1983_spdif_route_put,
1694         },
1695         { } /* end */
1696 };
1697
1698 static struct hda_input_mux ad1981_thinkpad_capture_source = {
1699         .num_items = 3,
1700         .items = {
1701                 { "Mic", 0x0 },
1702                 { "Mix", 0x2 },
1703                 { "CD", 0x4 },
1704         },
1705 };
1706
1707 /* models */
1708 enum {
1709         AD1981_BASIC,
1710         AD1981_HP,
1711         AD1981_THINKPAD,
1712         AD1981_TOSHIBA,
1713         AD1981_MODELS
1714 };
1715
1716 static const char *ad1981_models[AD1981_MODELS] = {
1717         [AD1981_HP]             = "hp",
1718         [AD1981_THINKPAD]       = "thinkpad",
1719         [AD1981_BASIC]          = "basic",
1720         [AD1981_TOSHIBA]        = "toshiba"
1721 };
1722
1723 static struct snd_pci_quirk ad1981_cfg_tbl[] = {
1724         SND_PCI_QUIRK(0x1014, 0x0597, "Lenovo Z60", AD1981_THINKPAD),
1725         SND_PCI_QUIRK(0x1014, 0x05b7, "Lenovo Z60m", AD1981_THINKPAD),
1726         /* All HP models */
1727         SND_PCI_QUIRK_VENDOR(0x103c, "HP nx", AD1981_HP),
1728         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba U205", AD1981_TOSHIBA),
1729         /* Lenovo Thinkpad T60/X60/Z6xx */
1730         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1981_THINKPAD),
1731         /* HP nx6320 (reversed SSID, H/W bug) */
1732         SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_HP),
1733         {}
1734 };
1735
1736 static int patch_ad1981(struct hda_codec *codec)
1737 {
1738         struct ad198x_spec *spec;
1739         int err, board_config;
1740
1741         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1742         if (spec == NULL)
1743                 return -ENOMEM;
1744
1745         codec->spec = spec;
1746
1747         err = snd_hda_attach_beep_device(codec, 0x10);
1748         if (err < 0) {
1749                 ad198x_free(codec);
1750                 return err;
1751         }
1752         set_beep_amp(spec, 0x0d, 0, HDA_OUTPUT);
1753
1754         spec->multiout.max_channels = 2;
1755         spec->multiout.num_dacs = ARRAY_SIZE(ad1981_dac_nids);
1756         spec->multiout.dac_nids = ad1981_dac_nids;
1757         spec->multiout.dig_out_nid = AD1981_SPDIF_OUT;
1758         spec->num_adc_nids = 1;
1759         spec->adc_nids = ad1981_adc_nids;
1760         spec->capsrc_nids = ad1981_capsrc_nids;
1761         spec->input_mux = &ad1981_capture_source;
1762         spec->num_mixers = 1;
1763         spec->mixers[0] = ad1981_mixers;
1764         spec->num_init_verbs = 1;
1765         spec->init_verbs[0] = ad1981_init_verbs;
1766         spec->spdif_route = 0;
1767 #ifdef CONFIG_SND_HDA_POWER_SAVE
1768         spec->loopback.amplist = ad1981_loopbacks;
1769 #endif
1770         spec->vmaster_nid = 0x05;
1771
1772         codec->patch_ops = ad198x_patch_ops;
1773
1774         /* override some parameters */
1775         board_config = snd_hda_check_board_config(codec, AD1981_MODELS,
1776                                                   ad1981_models,
1777                                                   ad1981_cfg_tbl);
1778         switch (board_config) {
1779         case AD1981_HP:
1780                 spec->mixers[0] = ad1981_hp_mixers;
1781                 spec->num_init_verbs = 2;
1782                 spec->init_verbs[1] = ad1981_hp_init_verbs;
1783                 spec->multiout.dig_out_nid = 0;
1784                 spec->input_mux = &ad1981_hp_capture_source;
1785
1786                 codec->patch_ops.init = ad1981_hp_init;
1787                 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1788                 break;
1789         case AD1981_THINKPAD:
1790                 spec->mixers[0] = ad1981_thinkpad_mixers;
1791                 spec->input_mux = &ad1981_thinkpad_capture_source;
1792                 break;
1793         case AD1981_TOSHIBA:
1794                 spec->mixers[0] = ad1981_hp_mixers;
1795                 spec->mixers[1] = ad1981_toshiba_mixers;
1796                 spec->num_init_verbs = 2;
1797                 spec->init_verbs[1] = ad1981_toshiba_init_verbs;
1798                 spec->multiout.dig_out_nid = 0;
1799                 spec->input_mux = &ad1981_hp_capture_source;
1800                 codec->patch_ops.init = ad1981_hp_init;
1801                 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1802                 break;
1803         }
1804         return 0;
1805 }
1806
1807
1808 /*
1809  * AD1988
1810  *
1811  * Output pins and routes
1812  *
1813  *        Pin               Mix     Sel     DAC (*)
1814  * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06
1815  * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06
1816  * port-C 0x15 (mute)    <- 0x2c <- 0x31 <- 05/0a
1817  * port-D 0x12 (mute/hp) <- 0x29         <- 04
1818  * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a
1819  * port-F 0x16 (mute)    <- 0x2a         <- 06
1820  * port-G 0x24 (mute)    <- 0x27         <- 05
1821  * port-H 0x25 (mute)    <- 0x28         <- 0a
1822  * mono   0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06
1823  *
1824  * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah
1825  * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug.
1826  *
1827  * Input pins and routes
1828  *
1829  *        pin     boost   mix input # / adc input #
1830  * port-A 0x11 -> 0x38 -> mix 2, ADC 0
1831  * port-B 0x14 -> 0x39 -> mix 0, ADC 1
1832  * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2
1833  * port-D 0x12 -> 0x3d -> mix 3, ADC 8
1834  * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4
1835  * port-F 0x16 -> 0x3b -> mix 5, ADC 3
1836  * port-G 0x24 -> N/A  -> 33:1 - mix 1, 34:1 - mix 4, ADC 6
1837  * port-H 0x25 -> N/A  -> 33:2 - mix 1, 34:2 - mix 4, ADC 7
1838  *
1839  *
1840  * DAC assignment
1841  *   6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03
1842  *   3stack - front/surr/CLFE/opt DACs - 04/05/0a/03
1843  *
1844  * Inputs of Analog Mix (0x20)
1845  *   0:Port-B (front mic)
1846  *   1:Port-C/G/H (line-in)
1847  *   2:Port-A
1848  *   3:Port-D (line-in/2)
1849  *   4:Port-E/G/H (mic-in)
1850  *   5:Port-F (mic2-in)
1851  *   6:CD
1852  *   7:Beep
1853  *
1854  * ADC selection
1855  *   0:Port-A
1856  *   1:Port-B (front mic-in)
1857  *   2:Port-C (line-in)
1858  *   3:Port-F (mic2-in)
1859  *   4:Port-E (mic-in)
1860  *   5:CD
1861  *   6:Port-G
1862  *   7:Port-H
1863  *   8:Port-D (line-in/2)
1864  *   9:Mix
1865  *
1866  * Proposed pin assignments by the datasheet
1867  *
1868  * 6-stack
1869  * Port-A front headphone
1870  *      B front mic-in
1871  *      C rear line-in
1872  *      D rear front-out
1873  *      E rear mic-in
1874  *      F rear surround
1875  *      G rear CLFE
1876  *      H rear side
1877  *
1878  * 3-stack
1879  * Port-A front headphone
1880  *      B front mic
1881  *      C rear line-in/surround
1882  *      D rear front-out
1883  *      E rear mic-in/CLFE
1884  *
1885  * laptop
1886  * Port-A headphone
1887  *      B mic-in
1888  *      C docking station
1889  *      D internal speaker (with EAPD)
1890  *      E/F quad mic array
1891  */
1892
1893
1894 /* models */
1895 enum {
1896         AD1988_6STACK,
1897         AD1988_6STACK_DIG,
1898         AD1988_3STACK,
1899         AD1988_3STACK_DIG,
1900         AD1988_LAPTOP,
1901         AD1988_LAPTOP_DIG,
1902         AD1988_AUTO,
1903         AD1988_MODEL_LAST,
1904 };
1905
1906 /* reivision id to check workarounds */
1907 #define AD1988A_REV2            0x100200
1908
1909 #define is_rev2(codec) \
1910         ((codec)->vendor_id == 0x11d41988 && \
1911          (codec)->revision_id == AD1988A_REV2)
1912
1913 /*
1914  * mixers
1915  */
1916
1917 static hda_nid_t ad1988_6stack_dac_nids[4] = {
1918         0x04, 0x06, 0x05, 0x0a
1919 };
1920
1921 static hda_nid_t ad1988_3stack_dac_nids[3] = {
1922         0x04, 0x05, 0x0a
1923 };
1924
1925 /* for AD1988A revision-2, DAC2-4 are swapped */
1926 static hda_nid_t ad1988_6stack_dac_nids_rev2[4] = {
1927         0x04, 0x05, 0x0a, 0x06
1928 };
1929
1930 static hda_nid_t ad1988_3stack_dac_nids_rev2[3] = {
1931         0x04, 0x0a, 0x06
1932 };
1933
1934 static hda_nid_t ad1988_adc_nids[3] = {
1935         0x08, 0x09, 0x0f
1936 };
1937
1938 static hda_nid_t ad1988_capsrc_nids[3] = {
1939         0x0c, 0x0d, 0x0e
1940 };
1941
1942 #define AD1988_SPDIF_OUT                0x02
1943 #define AD1988_SPDIF_OUT_HDMI   0x0b
1944 #define AD1988_SPDIF_IN         0x07
1945
1946 static hda_nid_t ad1989b_slave_dig_outs[] = {
1947         AD1988_SPDIF_OUT, AD1988_SPDIF_OUT_HDMI, 0
1948 };
1949
1950 static struct hda_input_mux ad1988_6stack_capture_source = {
1951         .num_items = 5,
1952         .items = {
1953                 { "Front Mic", 0x1 },   /* port-B */
1954                 { "Line", 0x2 },        /* port-C */
1955                 { "Mic", 0x4 },         /* port-E */
1956                 { "CD", 0x5 },
1957                 { "Mix", 0x9 },
1958         },
1959 };
1960
1961 static struct hda_input_mux ad1988_laptop_capture_source = {
1962         .num_items = 3,
1963         .items = {
1964                 { "Mic/Line", 0x1 },    /* port-B */
1965                 { "CD", 0x5 },
1966                 { "Mix", 0x9 },
1967         },
1968 };
1969
1970 /*
1971  */
1972 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
1973                                struct snd_ctl_elem_info *uinfo)
1974 {
1975         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1976         struct ad198x_spec *spec = codec->spec;
1977         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
1978                                     spec->num_channel_mode);
1979 }
1980
1981 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
1982                               struct snd_ctl_elem_value *ucontrol)
1983 {
1984         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1985         struct ad198x_spec *spec = codec->spec;
1986         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
1987                                    spec->num_channel_mode, spec->multiout.max_channels);
1988 }
1989
1990 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
1991                               struct snd_ctl_elem_value *ucontrol)
1992 {
1993         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1994         struct ad198x_spec *spec = codec->spec;
1995         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
1996                                       spec->num_channel_mode,
1997                                       &spec->multiout.max_channels);
1998         if (err >= 0 && spec->need_dac_fix)
1999                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
2000         return err;
2001 }
2002
2003 /* 6-stack mode */
2004 static struct snd_kcontrol_new ad1988_6stack_mixers1[] = {
2005         HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2006         HDA_CODEC_VOLUME("Surround Playback Volume", 0x06, 0x0, HDA_OUTPUT),
2007         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
2008         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
2009         HDA_CODEC_VOLUME("Side Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
2010         { } /* end */
2011 };
2012
2013 static struct snd_kcontrol_new ad1988_6stack_mixers1_rev2[] = {
2014         HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2015         HDA_CODEC_VOLUME("Surround Playback Volume", 0x05, 0x0, HDA_OUTPUT),
2016         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
2017         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0a, 2, 0x0, HDA_OUTPUT),
2018         HDA_CODEC_VOLUME("Side Playback Volume", 0x06, 0x0, HDA_OUTPUT),
2019         { } /* end */
2020 };
2021
2022 static struct snd_kcontrol_new ad1988_6stack_mixers2[] = {
2023         HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
2024         HDA_BIND_MUTE("Surround Playback Switch", 0x2a, 2, HDA_INPUT),
2025         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x27, 1, 2, HDA_INPUT),
2026         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x27, 2, 2, HDA_INPUT),
2027         HDA_BIND_MUTE("Side Playback Switch", 0x28, 2, HDA_INPUT),
2028         HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
2029         HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2030
2031         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2032         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2033         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2034         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2035         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2036         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2037         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
2038         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
2039
2040         HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2041         HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2042
2043         HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2044         HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
2045
2046         { } /* end */
2047 };
2048
2049 /* 3-stack mode */
2050 static struct snd_kcontrol_new ad1988_3stack_mixers1[] = {
2051         HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2052         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
2053         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
2054         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
2055         { } /* end */
2056 };
2057
2058 static struct snd_kcontrol_new ad1988_3stack_mixers1_rev2[] = {
2059         HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2060         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
2061         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x06, 1, 0x0, HDA_OUTPUT),
2062         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x06, 2, 0x0, HDA_OUTPUT),
2063         { } /* end */
2064 };
2065
2066 static struct snd_kcontrol_new ad1988_3stack_mixers2[] = {
2067         HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
2068         HDA_BIND_MUTE("Surround Playback Switch", 0x2c, 2, HDA_INPUT),
2069         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x26, 1, 2, HDA_INPUT),
2070         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x26, 2, 2, HDA_INPUT),
2071         HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
2072         HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2073
2074         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2075         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2076         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2077         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2078         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2079         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2080         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
2081         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
2082
2083         HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2084         HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2085
2086         HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2087         HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
2088         {
2089                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2090                 .name = "Channel Mode",
2091                 .info = ad198x_ch_mode_info,
2092                 .get = ad198x_ch_mode_get,
2093                 .put = ad198x_ch_mode_put,
2094         },
2095
2096         { } /* end */
2097 };
2098
2099 /* laptop mode */
2100 static struct snd_kcontrol_new ad1988_laptop_mixers[] = {
2101         HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2102         HDA_CODEC_MUTE("PCM Playback Switch", 0x29, 0x0, HDA_INPUT),
2103         HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2104
2105         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2106         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2107         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2108         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2109         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2110         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2111
2112         HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2113         HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2114
2115         HDA_CODEC_VOLUME("Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2116
2117         {
2118                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2119                 .name = "External Amplifier",
2120                 .info = ad198x_eapd_info,
2121                 .get = ad198x_eapd_get,
2122                 .put = ad198x_eapd_put,
2123                 .private_value = 0x12 | (1 << 8), /* port-D, inversed */
2124         },
2125
2126         { } /* end */
2127 };
2128
2129 /* capture */
2130 static struct snd_kcontrol_new ad1988_capture_mixers[] = {
2131         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
2132         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
2133         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
2134         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
2135         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x0e, 0x0, HDA_OUTPUT),
2136         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x0e, 0x0, HDA_OUTPUT),
2137         {
2138                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2139                 /* The multiple "Capture Source" controls confuse alsamixer
2140                  * So call somewhat different..
2141                  */
2142                 /* .name = "Capture Source", */
2143                 .name = "Input Source",
2144                 .count = 3,
2145                 .info = ad198x_mux_enum_info,
2146                 .get = ad198x_mux_enum_get,
2147                 .put = ad198x_mux_enum_put,
2148         },
2149         { } /* end */
2150 };
2151
2152 static int ad1988_spdif_playback_source_info(struct snd_kcontrol *kcontrol,
2153                                              struct snd_ctl_elem_info *uinfo)
2154 {
2155         static char *texts[] = {
2156                 "PCM", "ADC1", "ADC2", "ADC3"
2157         };
2158         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2159         uinfo->count = 1;
2160         uinfo->value.enumerated.items = 4;
2161         if (uinfo->value.enumerated.item >= 4)
2162                 uinfo->value.enumerated.item = 3;
2163         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2164         return 0;
2165 }
2166
2167 static int ad1988_spdif_playback_source_get(struct snd_kcontrol *kcontrol,
2168                                             struct snd_ctl_elem_value *ucontrol)
2169 {
2170         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2171         unsigned int sel;
2172
2173         sel = snd_hda_codec_read(codec, 0x1d, 0, AC_VERB_GET_AMP_GAIN_MUTE,
2174                                  AC_AMP_GET_INPUT);
2175         if (!(sel & 0x80))
2176                 ucontrol->value.enumerated.item[0] = 0;
2177         else {
2178                 sel = snd_hda_codec_read(codec, 0x0b, 0,
2179                                          AC_VERB_GET_CONNECT_SEL, 0);
2180                 if (sel < 3)
2181                         sel++;
2182                 else
2183                         sel = 0;
2184                 ucontrol->value.enumerated.item[0] = sel;
2185         }
2186         return 0;
2187 }
2188
2189 static int ad1988_spdif_playback_source_put(struct snd_kcontrol *kcontrol,
2190                                             struct snd_ctl_elem_value *ucontrol)
2191 {
2192         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2193         unsigned int val, sel;
2194         int change;
2195
2196         val = ucontrol->value.enumerated.item[0];
2197         if (val > 3)
2198                 return -EINVAL;
2199         if (!val) {
2200                 sel = snd_hda_codec_read(codec, 0x1d, 0,
2201                                          AC_VERB_GET_AMP_GAIN_MUTE,
2202                                          AC_AMP_GET_INPUT);
2203                 change = sel & 0x80;
2204                 if (change) {
2205                         snd_hda_codec_write_cache(codec, 0x1d, 0,
2206                                                   AC_VERB_SET_AMP_GAIN_MUTE,
2207                                                   AMP_IN_UNMUTE(0));
2208                         snd_hda_codec_write_cache(codec, 0x1d, 0,
2209                                                   AC_VERB_SET_AMP_GAIN_MUTE,
2210                                                   AMP_IN_MUTE(1));
2211                 }
2212         } else {
2213                 sel = snd_hda_codec_read(codec, 0x1d, 0,
2214                                          AC_VERB_GET_AMP_GAIN_MUTE,
2215                                          AC_AMP_GET_INPUT | 0x01);
2216                 change = sel & 0x80;
2217                 if (change) {
2218                         snd_hda_codec_write_cache(codec, 0x1d, 0,
2219                                                   AC_VERB_SET_AMP_GAIN_MUTE,
2220                                                   AMP_IN_MUTE(0));
2221                         snd_hda_codec_write_cache(codec, 0x1d, 0,
2222                                                   AC_VERB_SET_AMP_GAIN_MUTE,
2223                                                   AMP_IN_UNMUTE(1));
2224                 }
2225                 sel = snd_hda_codec_read(codec, 0x0b, 0,
2226                                          AC_VERB_GET_CONNECT_SEL, 0) + 1;
2227                 change |= sel != val;
2228                 if (change)
2229                         snd_hda_codec_write_cache(codec, 0x0b, 0,
2230                                                   AC_VERB_SET_CONNECT_SEL,
2231                                                   val - 1);
2232         }
2233         return change;
2234 }
2235
2236 static struct snd_kcontrol_new ad1988_spdif_out_mixers[] = {
2237         HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2238         {
2239                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2240                 .name = "IEC958 Playback Source",
2241                 .info = ad1988_spdif_playback_source_info,
2242                 .get = ad1988_spdif_playback_source_get,
2243                 .put = ad1988_spdif_playback_source_put,
2244         },
2245         { } /* end */
2246 };
2247
2248 static struct snd_kcontrol_new ad1988_spdif_in_mixers[] = {
2249         HDA_CODEC_VOLUME("IEC958 Capture Volume", 0x1c, 0x0, HDA_INPUT),
2250         { } /* end */
2251 };
2252
2253 static struct snd_kcontrol_new ad1989_spdif_out_mixers[] = {
2254         HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2255         HDA_CODEC_VOLUME("HDMI Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
2256         { } /* end */
2257 };
2258
2259 /*
2260  * initialization verbs
2261  */
2262
2263 /*
2264  * for 6-stack (+dig)
2265  */
2266 static struct hda_verb ad1988_6stack_init_verbs[] = {
2267         /* Front, Surround, CLFE, side DAC; unmute as default */
2268         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2269         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2270         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2271         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2272         /* Port-A front headphon path */
2273         {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2274         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2275         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2276         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2277         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2278         /* Port-D line-out path */
2279         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2280         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2281         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2282         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2283         /* Port-F surround path */
2284         {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2285         {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2286         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2287         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2288         /* Port-G CLFE path */
2289         {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2290         {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2291         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2292         {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2293         /* Port-H side path */
2294         {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2295         {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2296         {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2297         {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2298         /* Mono out path */
2299         {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2300         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2301         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2302         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2303         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2304         /* Port-B front mic-in path */
2305         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2306         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2307         {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2308         /* Port-C line-in path */
2309         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2310         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2311         {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2312         {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2313         /* Port-E mic-in path */
2314         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2315         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2316         {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2317         {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2318         /* Analog CD Input */
2319         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2320         /* Analog Mix output amp */
2321         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2322
2323         { }
2324 };
2325
2326 static struct hda_verb ad1988_capture_init_verbs[] = {
2327         /* mute analog mix */
2328         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2329         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2330         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2331         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2332         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2333         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2334         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2335         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2336         /* select ADCs - front-mic */
2337         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2338         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2339         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2340
2341         { }
2342 };
2343
2344 static struct hda_verb ad1988_spdif_init_verbs[] = {
2345         /* SPDIF out sel */
2346         {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
2347         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0}, /* ADC1 */
2348         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2349         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2350         /* SPDIF out pin */
2351         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2352
2353         { }
2354 };
2355
2356 /* AD1989 has no ADC -> SPDIF route */
2357 static struct hda_verb ad1989_spdif_init_verbs[] = {
2358         /* SPDIF-1 out pin */
2359         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2360         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2361         /* SPDIF-2/HDMI out pin */
2362         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2363         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2364         { }
2365 };
2366
2367 /*
2368  * verbs for 3stack (+dig)
2369  */
2370 static struct hda_verb ad1988_3stack_ch2_init[] = {
2371         /* set port-C to line-in */
2372         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2373         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2374         /* set port-E to mic-in */
2375         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2376         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2377         { } /* end */
2378 };
2379
2380 static struct hda_verb ad1988_3stack_ch6_init[] = {
2381         /* set port-C to surround out */
2382         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2383         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2384         /* set port-E to CLFE out */
2385         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2386         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2387         { } /* end */
2388 };
2389
2390 static struct hda_channel_mode ad1988_3stack_modes[2] = {
2391         { 2, ad1988_3stack_ch2_init },
2392         { 6, ad1988_3stack_ch6_init },
2393 };
2394
2395 static struct hda_verb ad1988_3stack_init_verbs[] = {
2396         /* Front, Surround, CLFE, side DAC; unmute as default */
2397         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2398         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2399         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2400         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2401         /* Port-A front headphon path */
2402         {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2403         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2404         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2405         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2406         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2407         /* Port-D line-out path */
2408         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2409         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2410         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2411         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2412         /* Mono out path */
2413         {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2414         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2415         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2416         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2417         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2418         /* Port-B front mic-in path */
2419         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2420         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2421         {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2422         /* Port-C line-in/surround path - 6ch mode as default */
2423         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2424         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2425         {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2426         {0x31, AC_VERB_SET_CONNECT_SEL, 0x0}, /* output sel: DAC 0x05 */
2427         {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2428         /* Port-E mic-in/CLFE path - 6ch mode as default */
2429         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2430         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2431         {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2432         {0x32, AC_VERB_SET_CONNECT_SEL, 0x1}, /* output sel: DAC 0x0a */
2433         {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2434         /* mute analog mix */
2435         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2436         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2437         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2438         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2439         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2440         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2441         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2442         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2443         /* select ADCs - front-mic */
2444         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2445         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2446         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2447         /* Analog Mix output amp */
2448         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2449         { }
2450 };
2451
2452 /*
2453  * verbs for laptop mode (+dig)
2454  */
2455 static struct hda_verb ad1988_laptop_hp_on[] = {
2456         /* unmute port-A and mute port-D */
2457         { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2458         { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2459         { } /* end */
2460 };
2461 static struct hda_verb ad1988_laptop_hp_off[] = {
2462         /* mute port-A and unmute port-D */
2463         { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2464         { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2465         { } /* end */
2466 };
2467
2468 #define AD1988_HP_EVENT 0x01
2469
2470 static struct hda_verb ad1988_laptop_init_verbs[] = {
2471         /* Front, Surround, CLFE, side DAC; unmute as default */
2472         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2473         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2474         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2475         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2476         /* Port-A front headphon path */
2477         {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2478         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2479         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2480         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2481         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2482         /* unsolicited event for pin-sense */
2483         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1988_HP_EVENT },
2484         /* Port-D line-out path + EAPD */
2485         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2486         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2487         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2488         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2489         {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x00}, /* EAPD-off */
2490         /* Mono out path */
2491         {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2492         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2493         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2494         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2495         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2496         /* Port-B mic-in path */
2497         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2498         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2499         {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2500         /* Port-C docking station - try to output */
2501         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2502         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2503         {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2504         {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2505         /* mute analog mix */
2506         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2507         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2508         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2509         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2510         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2511         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2512         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2513         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2514         /* select ADCs - mic */
2515         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2516         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2517         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2518         /* Analog Mix output amp */
2519         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2520         { }
2521 };
2522
2523 static void ad1988_laptop_unsol_event(struct hda_codec *codec, unsigned int res)
2524 {
2525         if ((res >> 26) != AD1988_HP_EVENT)
2526                 return;
2527         if (snd_hda_codec_read(codec, 0x11, 0, AC_VERB_GET_PIN_SENSE, 0) & (1 << 31))
2528                 snd_hda_sequence_write(codec, ad1988_laptop_hp_on);
2529         else
2530                 snd_hda_sequence_write(codec, ad1988_laptop_hp_off);
2531 }
2532
2533 #ifdef CONFIG_SND_HDA_POWER_SAVE
2534 static struct hda_amp_list ad1988_loopbacks[] = {
2535         { 0x20, HDA_INPUT, 0 }, /* Front Mic */
2536         { 0x20, HDA_INPUT, 1 }, /* Line */
2537         { 0x20, HDA_INPUT, 4 }, /* Mic */
2538         { 0x20, HDA_INPUT, 6 }, /* CD */
2539         { } /* end */
2540 };
2541 #endif
2542
2543 /*
2544  * Automatic parse of I/O pins from the BIOS configuration
2545  */
2546
2547 enum {
2548         AD_CTL_WIDGET_VOL,
2549         AD_CTL_WIDGET_MUTE,
2550         AD_CTL_BIND_MUTE,
2551 };
2552 static struct snd_kcontrol_new ad1988_control_templates[] = {
2553         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2554         HDA_CODEC_MUTE(NULL, 0, 0, 0),
2555         HDA_BIND_MUTE(NULL, 0, 0, 0),
2556 };
2557
2558 /* add dynamic controls */
2559 static int add_control(struct ad198x_spec *spec, int type, const char *name,
2560                        unsigned long val)
2561 {
2562         struct snd_kcontrol_new *knew;
2563
2564         snd_array_init(&spec->kctls, sizeof(*knew), 32);
2565         knew = snd_array_new(&spec->kctls);
2566         if (!knew)
2567                 return -ENOMEM;
2568         *knew = ad1988_control_templates[type];
2569         knew->name = kstrdup(name, GFP_KERNEL);
2570         if (! knew->name)
2571                 return -ENOMEM;
2572         knew->private_value = val;
2573         return 0;
2574 }
2575
2576 #define AD1988_PIN_CD_NID               0x18
2577 #define AD1988_PIN_BEEP_NID             0x10
2578
2579 static hda_nid_t ad1988_mixer_nids[8] = {
2580         /* A     B     C     D     E     F     G     H */
2581         0x22, 0x2b, 0x2c, 0x29, 0x26, 0x2a, 0x27, 0x28
2582 };
2583
2584 static inline hda_nid_t ad1988_idx_to_dac(struct hda_codec *codec, int idx)
2585 {
2586         static hda_nid_t idx_to_dac[8] = {
2587                 /* A     B     C     D     E     F     G     H */
2588                 0x04, 0x06, 0x05, 0x04, 0x0a, 0x06, 0x05, 0x0a
2589         };
2590         static hda_nid_t idx_to_dac_rev2[8] = {
2591                 /* A     B     C     D     E     F     G     H */
2592                 0x04, 0x05, 0x0a, 0x04, 0x06, 0x05, 0x0a, 0x06
2593         };
2594         if (is_rev2(codec))
2595                 return idx_to_dac_rev2[idx];
2596         else
2597                 return idx_to_dac[idx];
2598 }
2599
2600 static hda_nid_t ad1988_boost_nids[8] = {
2601         0x38, 0x39, 0x3a, 0x3d, 0x3c, 0x3b, 0, 0
2602 };
2603
2604 static int ad1988_pin_idx(hda_nid_t nid)
2605 {
2606         static hda_nid_t ad1988_io_pins[8] = {
2607                 0x11, 0x14, 0x15, 0x12, 0x17, 0x16, 0x24, 0x25
2608         };
2609         int i;
2610         for (i = 0; i < ARRAY_SIZE(ad1988_io_pins); i++)
2611                 if (ad1988_io_pins[i] == nid)
2612                         return i;
2613         return 0; /* should be -1 */
2614 }
2615
2616 static int ad1988_pin_to_loopback_idx(hda_nid_t nid)
2617 {
2618         static int loopback_idx[8] = {
2619                 2, 0, 1, 3, 4, 5, 1, 4
2620         };
2621         switch (nid) {
2622         case AD1988_PIN_CD_NID:
2623                 return 6;
2624         default:
2625                 return loopback_idx[ad1988_pin_idx(nid)];
2626         }
2627 }
2628
2629 static int ad1988_pin_to_adc_idx(hda_nid_t nid)
2630 {
2631         static int adc_idx[8] = {
2632                 0, 1, 2, 8, 4, 3, 6, 7
2633         };
2634         switch (nid) {
2635         case AD1988_PIN_CD_NID:
2636                 return 5;
2637         default:
2638                 return adc_idx[ad1988_pin_idx(nid)];
2639         }
2640 }
2641
2642 /* fill in the dac_nids table from the parsed pin configuration */
2643 static int ad1988_auto_fill_dac_nids(struct hda_codec *codec,
2644                                      const struct auto_pin_cfg *cfg)
2645 {
2646         struct ad198x_spec *spec = codec->spec;
2647         int i, idx;
2648
2649         spec->multiout.dac_nids = spec->private_dac_nids;
2650
2651         /* check the pins hardwired to audio widget */
2652         for (i = 0; i < cfg->line_outs; i++) {
2653                 idx = ad1988_pin_idx(cfg->line_out_pins[i]);
2654                 spec->multiout.dac_nids[i] = ad1988_idx_to_dac(codec, idx);
2655         }
2656         spec->multiout.num_dacs = cfg->line_outs;
2657         return 0;
2658 }
2659
2660 /* add playback controls from the parsed DAC table */
2661 static int ad1988_auto_create_multi_out_ctls(struct ad198x_spec *spec,
2662                                              const struct auto_pin_cfg *cfg)
2663 {
2664         char name[32];
2665         static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
2666         hda_nid_t nid;
2667         int i, err;
2668
2669         for (i = 0; i < cfg->line_outs; i++) {
2670                 hda_nid_t dac = spec->multiout.dac_nids[i];
2671                 if (! dac)
2672                         continue;
2673                 nid = ad1988_mixer_nids[ad1988_pin_idx(cfg->line_out_pins[i])];
2674                 if (i == 2) {
2675                         /* Center/LFE */
2676                         err = add_control(spec, AD_CTL_WIDGET_VOL,
2677                                           "Center Playback Volume",
2678                                           HDA_COMPOSE_AMP_VAL(dac, 1, 0, HDA_OUTPUT));
2679                         if (err < 0)
2680                                 return err;
2681                         err = add_control(spec, AD_CTL_WIDGET_VOL,
2682                                           "LFE Playback Volume",
2683                                           HDA_COMPOSE_AMP_VAL(dac, 2, 0, HDA_OUTPUT));
2684                         if (err < 0)
2685                                 return err;
2686                         err = add_control(spec, AD_CTL_BIND_MUTE,
2687                                           "Center Playback Switch",
2688                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT));
2689                         if (err < 0)
2690                                 return err;
2691                         err = add_control(spec, AD_CTL_BIND_MUTE,
2692                                           "LFE Playback Switch",
2693                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT));
2694                         if (err < 0)
2695                                 return err;
2696                 } else {
2697                         sprintf(name, "%s Playback Volume", chname[i]);
2698                         err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2699                                           HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT));
2700                         if (err < 0)
2701                                 return err;
2702                         sprintf(name, "%s Playback Switch", chname[i]);
2703                         err = add_control(spec, AD_CTL_BIND_MUTE, name,
2704                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
2705                         if (err < 0)
2706                                 return err;
2707                 }
2708         }
2709         return 0;
2710 }
2711
2712 /* add playback controls for speaker and HP outputs */
2713 static int ad1988_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
2714                                         const char *pfx)
2715 {
2716         struct ad198x_spec *spec = codec->spec;
2717         hda_nid_t nid;
2718         int i, idx, err;
2719         char name[32];
2720
2721         if (! pin)
2722                 return 0;
2723
2724         idx = ad1988_pin_idx(pin);
2725         nid = ad1988_idx_to_dac(codec, idx);
2726         /* check whether the corresponding DAC was already taken */
2727         for (i = 0; i < spec->autocfg.line_outs; i++) {
2728                 hda_nid_t pin = spec->autocfg.line_out_pins[i];
2729                 hda_nid_t dac = ad1988_idx_to_dac(codec, ad1988_pin_idx(pin));
2730                 if (dac == nid)
2731                         break;
2732         }
2733         if (i >= spec->autocfg.line_outs) {
2734                 /* specify the DAC as the extra output */
2735                 if (!spec->multiout.hp_nid)
2736                         spec->multiout.hp_nid = nid;
2737                 else
2738                         spec->multiout.extra_out_nid[0] = nid;
2739                 /* control HP volume/switch on the output mixer amp */
2740                 sprintf(name, "%s Playback Volume", pfx);
2741                 err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2742                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
2743                 if (err < 0)
2744                         return err;
2745         }
2746         nid = ad1988_mixer_nids[idx];
2747         sprintf(name, "%s Playback Switch", pfx);
2748         if ((err = add_control(spec, AD_CTL_BIND_MUTE, name,
2749                                HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
2750                 return err;
2751         return 0;
2752 }
2753
2754 /* create input playback/capture controls for the given pin */
2755 static int new_analog_input(struct ad198x_spec *spec, hda_nid_t pin,
2756                             const char *ctlname, int boost)
2757 {
2758         char name[32];
2759         int err, idx;
2760
2761         sprintf(name, "%s Playback Volume", ctlname);
2762         idx = ad1988_pin_to_loopback_idx(pin);
2763         if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2764                                HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2765                 return err;
2766         sprintf(name, "%s Playback Switch", ctlname);
2767         if ((err = add_control(spec, AD_CTL_WIDGET_MUTE, name,
2768                                HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2769                 return err;
2770         if (boost) {
2771                 hda_nid_t bnid;
2772                 idx = ad1988_pin_idx(pin);
2773                 bnid = ad1988_boost_nids[idx];
2774                 if (bnid) {
2775                         sprintf(name, "%s Boost", ctlname);
2776                         return add_control(spec, AD_CTL_WIDGET_VOL, name,
2777                                            HDA_COMPOSE_AMP_VAL(bnid, 3, idx, HDA_OUTPUT));
2778
2779                 }
2780         }
2781         return 0;
2782 }
2783
2784 /* create playback/capture controls for input pins */
2785 static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec,
2786                                                 const struct auto_pin_cfg *cfg)
2787 {
2788         struct hda_input_mux *imux = &spec->private_imux;
2789         int i, err;
2790
2791         for (i = 0; i < AUTO_PIN_LAST; i++) {
2792                 err = new_analog_input(spec, cfg->input_pins[i],
2793                                        auto_pin_cfg_labels[i],
2794                                        i <= AUTO_PIN_FRONT_MIC);
2795                 if (err < 0)
2796                         return err;
2797                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2798                 imux->items[imux->num_items].index = ad1988_pin_to_adc_idx(cfg->input_pins[i]);
2799                 imux->num_items++;
2800         }
2801         imux->items[imux->num_items].label = "Mix";
2802         imux->items[imux->num_items].index = 9;
2803         imux->num_items++;
2804
2805         if ((err = add_control(spec, AD_CTL_WIDGET_VOL,
2806                                "Analog Mix Playback Volume",
2807                                HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2808                 return err;
2809         if ((err = add_control(spec, AD_CTL_WIDGET_MUTE,
2810                                "Analog Mix Playback Switch",
2811                                HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2812                 return err;
2813
2814         return 0;
2815 }
2816
2817 static void ad1988_auto_set_output_and_unmute(struct hda_codec *codec,
2818                                               hda_nid_t nid, int pin_type,
2819                                               int dac_idx)
2820 {
2821         /* set as output */
2822         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2823         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
2824         switch (nid) {
2825         case 0x11: /* port-A - DAC 04 */
2826                 snd_hda_codec_write(codec, 0x37, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2827                 break;
2828         case 0x14: /* port-B - DAC 06 */
2829                 snd_hda_codec_write(codec, 0x30, 0, AC_VERB_SET_CONNECT_SEL, 0x02);
2830                 break;
2831         case 0x15: /* port-C - DAC 05 */
2832                 snd_hda_codec_write(codec, 0x31, 0, AC_VERB_SET_CONNECT_SEL, 0x00);
2833                 break;
2834         case 0x17: /* port-E - DAC 0a */
2835                 snd_hda_codec_write(codec, 0x32, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2836                 break;
2837         case 0x13: /* mono - DAC 04 */
2838                 snd_hda_codec_write(codec, 0x36, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2839                 break;
2840         }
2841 }
2842
2843 static void ad1988_auto_init_multi_out(struct hda_codec *codec)
2844 {
2845         struct ad198x_spec *spec = codec->spec;
2846         int i;
2847
2848         for (i = 0; i < spec->autocfg.line_outs; i++) {
2849                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2850                 ad1988_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
2851         }
2852 }
2853
2854 static void ad1988_auto_init_extra_out(struct hda_codec *codec)
2855 {
2856         struct ad198x_spec *spec = codec->spec;
2857         hda_nid_t pin;
2858
2859         pin = spec->autocfg.speaker_pins[0];
2860         if (pin) /* connect to front */
2861                 ad1988_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
2862         pin = spec->autocfg.hp_pins[0];
2863         if (pin) /* connect to front */
2864                 ad1988_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
2865 }
2866
2867 static void ad1988_auto_init_analog_input(struct hda_codec *codec)
2868 {
2869         struct ad198x_spec *spec = codec->spec;
2870         int i, idx;
2871
2872         for (i = 0; i < AUTO_PIN_LAST; i++) {
2873                 hda_nid_t nid = spec->autocfg.input_pins[i];
2874                 if (! nid)
2875                         continue;
2876                 switch (nid) {
2877                 case 0x15: /* port-C */
2878                         snd_hda_codec_write(codec, 0x33, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
2879                         break;
2880                 case 0x17: /* port-E */
2881                         snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
2882                         break;
2883                 }
2884                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2885                                     i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
2886                 if (nid != AD1988_PIN_CD_NID)
2887                         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2888                                             AMP_OUT_MUTE);
2889                 idx = ad1988_pin_idx(nid);
2890                 if (ad1988_boost_nids[idx])
2891                         snd_hda_codec_write(codec, ad1988_boost_nids[idx], 0,
2892                                             AC_VERB_SET_AMP_GAIN_MUTE,
2893                                             AMP_OUT_ZERO);
2894         }
2895 }
2896
2897 /* parse the BIOS configuration and set up the alc_spec */
2898 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
2899 static int ad1988_parse_auto_config(struct hda_codec *codec)
2900 {
2901         struct ad198x_spec *spec = codec->spec;
2902         int err;
2903
2904         if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2905                 return err;
2906         if ((err = ad1988_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2907                 return err;
2908         if (! spec->autocfg.line_outs)
2909                 return 0; /* can't find valid BIOS pin config */
2910         if ((err = ad1988_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
2911             (err = ad1988_auto_create_extra_out(codec,
2912                                                 spec->autocfg.speaker_pins[0],
2913                                                 "Speaker")) < 0 ||
2914             (err = ad1988_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
2915                                                 "Headphone")) < 0 ||
2916             (err = ad1988_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
2917                 return err;
2918
2919         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2920
2921         if (spec->autocfg.dig_outs)
2922                 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2923         if (spec->autocfg.dig_in_pin)
2924                 spec->dig_in_nid = AD1988_SPDIF_IN;
2925
2926         if (spec->kctls.list)
2927                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
2928
2929         spec->init_verbs[spec->num_init_verbs++] = ad1988_6stack_init_verbs;
2930
2931         spec->input_mux = &spec->private_imux;
2932
2933         return 1;
2934 }
2935
2936 /* init callback for auto-configuration model -- overriding the default init */
2937 static int ad1988_auto_init(struct hda_codec *codec)
2938 {
2939         ad198x_init(codec);
2940         ad1988_auto_init_multi_out(codec);
2941         ad1988_auto_init_extra_out(codec);
2942         ad1988_auto_init_analog_input(codec);
2943         return 0;
2944 }
2945
2946
2947 /*
2948  */
2949
2950 static const char *ad1988_models[AD1988_MODEL_LAST] = {
2951         [AD1988_6STACK]         = "6stack",
2952         [AD1988_6STACK_DIG]     = "6stack-dig",
2953         [AD1988_3STACK]         = "3stack",
2954         [AD1988_3STACK_DIG]     = "3stack-dig",
2955         [AD1988_LAPTOP]         = "laptop",
2956         [AD1988_LAPTOP_DIG]     = "laptop-dig",
2957         [AD1988_AUTO]           = "auto",
2958 };
2959
2960 static struct snd_pci_quirk ad1988_cfg_tbl[] = {
2961         SND_PCI_QUIRK(0x1043, 0x81ec, "Asus P5B-DLX", AD1988_6STACK_DIG),
2962         SND_PCI_QUIRK(0x1043, 0x81f6, "Asus M2N-SLI", AD1988_6STACK_DIG),
2963         SND_PCI_QUIRK(0x1043, 0x8277, "Asus P5K-E/WIFI-AP", AD1988_6STACK_DIG),
2964         SND_PCI_QUIRK(0x1043, 0x8311, "Asus P5Q-Premium/Pro", AD1988_6STACK_DIG),
2965         {}
2966 };
2967
2968 static int patch_ad1988(struct hda_codec *codec)
2969 {
2970         struct ad198x_spec *spec;
2971         int err, board_config;
2972
2973         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2974         if (spec == NULL)
2975                 return -ENOMEM;
2976
2977         codec->spec = spec;
2978
2979         if (is_rev2(codec))
2980                 snd_printk(KERN_INFO "patch_analog: AD1988A rev.2 is detected, enable workarounds\n");
2981
2982         board_config = snd_hda_check_board_config(codec, AD1988_MODEL_LAST,
2983                                                   ad1988_models, ad1988_cfg_tbl);
2984         if (board_config < 0) {
2985                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
2986                        codec->chip_name);
2987                 board_config = AD1988_AUTO;
2988         }
2989
2990         if (board_config == AD1988_AUTO) {
2991                 /* automatic parse from the BIOS config */
2992                 err = ad1988_parse_auto_config(codec);
2993                 if (err < 0) {
2994                         ad198x_free(codec);
2995                         return err;
2996                 } else if (! err) {
2997                         printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using 6-stack mode...\n");
2998                         board_config = AD1988_6STACK;
2999                 }
3000         }
3001
3002         err = snd_hda_attach_beep_device(codec, 0x10);
3003         if (err < 0) {
3004                 ad198x_free(codec);
3005                 return err;
3006         }
3007         set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
3008
3009         switch (board_config) {
3010         case AD1988_6STACK:
3011         case AD1988_6STACK_DIG:
3012                 spec->multiout.max_channels = 8;
3013                 spec->multiout.num_dacs = 4;
3014                 if (is_rev2(codec))
3015                         spec->multiout.dac_nids = ad1988_6stack_dac_nids_rev2;
3016                 else
3017                         spec->multiout.dac_nids = ad1988_6stack_dac_nids;
3018                 spec->input_mux = &ad1988_6stack_capture_source;
3019                 spec->num_mixers = 2;
3020                 if (is_rev2(codec))
3021                         spec->mixers[0] = ad1988_6stack_mixers1_rev2;
3022                 else
3023                         spec->mixers[0] = ad1988_6stack_mixers1;
3024                 spec->mixers[1] = ad1988_6stack_mixers2;
3025                 spec->num_init_verbs = 1;
3026                 spec->init_verbs[0] = ad1988_6stack_init_verbs;
3027                 if (board_config == AD1988_6STACK_DIG) {
3028                         spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3029                         spec->dig_in_nid = AD1988_SPDIF_IN;
3030                 }
3031                 break;
3032         case AD1988_3STACK:
3033         case AD1988_3STACK_DIG:
3034                 spec->multiout.max_channels = 6;
3035                 spec->multiout.num_dacs = 3;
3036                 if (is_rev2(codec))
3037                         spec->multiout.dac_nids = ad1988_3stack_dac_nids_rev2;
3038                 else
3039                         spec->multiout.dac_nids = ad1988_3stack_dac_nids;
3040                 spec->input_mux = &ad1988_6stack_capture_source;
3041                 spec->channel_mode = ad1988_3stack_modes;
3042                 spec->num_channel_mode = ARRAY_SIZE(ad1988_3stack_modes);
3043                 spec->num_mixers = 2;
3044                 if (is_rev2(codec))
3045                         spec->mixers[0] = ad1988_3stack_mixers1_rev2;
3046                 else
3047                         spec->mixers[0] = ad1988_3stack_mixers1;
3048                 spec->mixers[1] = ad1988_3stack_mixers2;
3049                 spec->num_init_verbs = 1;
3050                 spec->init_verbs[0] = ad1988_3stack_init_verbs;
3051                 if (board_config == AD1988_3STACK_DIG)
3052                         spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3053                 break;
3054         case AD1988_LAPTOP:
3055         case AD1988_LAPTOP_DIG:
3056                 spec->multiout.max_channels = 2;
3057                 spec->multiout.num_dacs = 1;
3058                 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
3059                 spec->input_mux = &ad1988_laptop_capture_source;
3060                 spec->num_mixers = 1;
3061                 spec->mixers[0] = ad1988_laptop_mixers;
3062                 spec->num_init_verbs = 1;
3063                 spec->init_verbs[0] = ad1988_laptop_init_verbs;
3064                 if (board_config == AD1988_LAPTOP_DIG)
3065                         spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3066                 break;
3067         }
3068
3069         spec->num_adc_nids = ARRAY_SIZE(ad1988_adc_nids);
3070         spec->adc_nids = ad1988_adc_nids;
3071         spec->capsrc_nids = ad1988_capsrc_nids;
3072         spec->mixers[spec->num_mixers++] = ad1988_capture_mixers;
3073         spec->init_verbs[spec->num_init_verbs++] = ad1988_capture_init_verbs;
3074         if (spec->multiout.dig_out_nid) {
3075                 if (codec->vendor_id >= 0x11d4989a) {
3076                         spec->mixers[spec->num_mixers++] =
3077                                 ad1989_spdif_out_mixers;
3078                         spec->init_verbs[spec->num_init_verbs++] =
3079                                 ad1989_spdif_init_verbs;
3080                         codec->slave_dig_outs = ad1989b_slave_dig_outs;
3081                 } else {
3082                         spec->mixers[spec->num_mixers++] =
3083                                 ad1988_spdif_out_mixers;
3084                         spec->init_verbs[spec->num_init_verbs++] =
3085                                 ad1988_spdif_init_verbs;
3086                 }
3087         }
3088         if (spec->dig_in_nid && codec->vendor_id < 0x11d4989a)
3089                 spec->mixers[spec->num_mixers++] = ad1988_spdif_in_mixers;
3090
3091         codec->patch_ops = ad198x_patch_ops;
3092         switch (board_config) {
3093         case AD1988_AUTO:
3094                 codec->patch_ops.init = ad1988_auto_init;
3095                 break;