git.oblomov.eu Git - linux-2.6/blob - 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_patch.h"
  31
  32 struct ad198x_spec {
  33         struct snd_kcontrol_new *mixers[5];
  34         int num_mixers;
  35
  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         unsigned int num_kctl_alloc, num_kctl_used;
  71         struct snd_kcontrol_new *kctl_alloc;
  72         struct hda_input_mux private_imux;
  73         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
  74
  75         unsigned int jack_present :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 int ad198x_build_controls(struct hda_codec *codec)
 158 {
 159         struct ad198x_spec *spec = codec->spec;
 160         unsigned int i;
 161         int err;
 162
 163         for (i = 0; i < spec->num_mixers; i++) {
 164                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
 165                 if (err < 0)
 166                         return err;
 167         }
 168         if (spec->multiout.dig_out_nid) {
 169                 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
 170                 if (err < 0)
 171                         return err;
 172                 err = snd_hda_create_spdif_share_sw(codec,
 173                                                     &spec->multiout);
 174                 if (err < 0)
 175                         return err;
 176                 spec->multiout.share_spdif = 1;
 177         }
 178         if (spec->dig_in_nid) {
 179                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
 180                 if (err < 0)
 181                         return err;
 182         }
 183
 184         /* if we have no master control, let's create it */
 185         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
 186                 unsigned int vmaster_tlv[4];
 187                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
 188                                         HDA_OUTPUT, vmaster_tlv);
 189                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
 190                                           vmaster_tlv,
 191                                           (spec->slave_vols ?
 192                                            spec->slave_vols : ad_slave_vols));
 193                 if (err < 0)
 194                         return err;
 195         }
 196         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
 197                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
 198                                           NULL,
 199                                           (spec->slave_sws ?
 200                                            spec->slave_sws : ad_slave_sws));
 201                 if (err < 0)
 202                         return err;
 203         }
 204
 205         return 0;
 206 }
 207
 208 #ifdef CONFIG_SND_HDA_POWER_SAVE
 209 static int ad198x_check_power_status(struct hda_codec *codec, hda_nid_t nid)
 210 {
 211         struct ad198x_spec *spec = codec->spec;
 212         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
 213 }
 214 #endif
 215
 216 /*
 217  * Analog playback callbacks
 218  */
 219 static int ad198x_playback_pcm_open(struct hda_pcm_stream *hinfo,
 220                                     struct hda_codec *codec,
 221                                     struct snd_pcm_substream *substream)
 222 {
 223         struct ad198x_spec *spec = codec->spec;
 224         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
 225                                              hinfo);
 226 }
 227
 228 static int ad198x_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 229                                        struct hda_codec *codec,
 230                                        unsigned int stream_tag,
 231                                        unsigned int format,
 232                                        struct snd_pcm_substream *substream)
 233 {
 234         struct ad198x_spec *spec = codec->spec;
 235         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
 236                                                 format, substream);
 237 }
 238
 239 static int ad198x_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
 240                                        struct hda_codec *codec,
 241                                        struct snd_pcm_substream *substream)
 242 {
 243         struct ad198x_spec *spec = codec->spec;
 244         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
 245 }
 246
 247 /*
 248  * Digital out
 249  */
 250 static int ad198x_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
 251                                         struct hda_codec *codec,
 252                                         struct snd_pcm_substream *substream)
 253 {
 254         struct ad198x_spec *spec = codec->spec;
 255         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
 256 }
 257
 258 static int ad198x_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
 259                                          struct hda_codec *codec,
 260                                          struct snd_pcm_substream *substream)
 261 {
 262         struct ad198x_spec *spec = codec->spec;
 263         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
 264 }
 265
 266 static int ad198x_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 267                                            struct hda_codec *codec,
 268                                            unsigned int stream_tag,
 269                                            unsigned int format,
 270                                            struct snd_pcm_substream *substream)
 271 {
 272         struct ad198x_spec *spec = codec->spec;
 273         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
 274                                              format, substream);
 275 }
 276
 277 /*
 278  * Analog capture
 279  */
 280 static int ad198x_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
 281                                       struct hda_codec *codec,
 282                                       unsigned int stream_tag,
 283                                       unsigned int format,
 284                                       struct snd_pcm_substream *substream)
 285 {
 286         struct ad198x_spec *spec = codec->spec;
 287         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
 288                                    stream_tag, 0, format);
 289         return 0;
 290 }
 291
 292 static int ad198x_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
 293                                       struct hda_codec *codec,
 294                                       struct snd_pcm_substream *substream)
 295 {
 296         struct ad198x_spec *spec = codec->spec;
 297         snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
 298         return 0;
 299 }
 300
 301
 302 /*
 303  */
 304 static struct hda_pcm_stream ad198x_pcm_analog_playback = {
 305         .substreams = 1,
 306         .channels_min = 2,
 307         .channels_max = 6, /* changed later */
 308         .nid = 0, /* fill later */
 309         .ops = {
 310                 .open = ad198x_playback_pcm_open,
 311                 .prepare = ad198x_playback_pcm_prepare,
 312                 .cleanup = ad198x_playback_pcm_cleanup
 313         },
 314 };
 315
 316 static struct hda_pcm_stream ad198x_pcm_analog_capture = {
 317         .substreams = 1,
 318         .channels_min = 2,
 319         .channels_max = 2,
 320         .nid = 0, /* fill later */
 321         .ops = {
 322                 .prepare = ad198x_capture_pcm_prepare,
 323                 .cleanup = ad198x_capture_pcm_cleanup
 324         },
 325 };
 326
 327 static struct hda_pcm_stream ad198x_pcm_digital_playback = {
 328         .substreams = 1,
 329         .channels_min = 2,
 330         .channels_max = 2,
 331         .nid = 0, /* fill later */
 332         .ops = {
 333                 .open = ad198x_dig_playback_pcm_open,
 334                 .close = ad198x_dig_playback_pcm_close,
 335                 .prepare = ad198x_dig_playback_pcm_prepare
 336         },
 337 };
 338
 339 static struct hda_pcm_stream ad198x_pcm_digital_capture = {
 340         .substreams = 1,
 341         .channels_min = 2,
 342         .channels_max = 2,
 343         /* NID is set in alc_build_pcms */
 344 };
 345
 346 static int ad198x_build_pcms(struct hda_codec *codec)
 347 {
 348         struct ad198x_spec *spec = codec->spec;
 349         struct hda_pcm *info = spec->pcm_rec;
 350
 351         codec->num_pcms = 1;
 352         codec->pcm_info = info;
 353
 354         info->name = "AD198x Analog";
 355         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_analog_playback;
 356         info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->multiout.max_channels;
 357         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
 358         info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_analog_capture;
 359         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adc_nids;
 360         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
 361
 362         if (spec->multiout.dig_out_nid) {
 363                 info++;
 364                 codec->num_pcms++;
 365                 info->name = "AD198x Digital";
 366                 info->pcm_type = HDA_PCM_TYPE_SPDIF;
 367                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_digital_playback;
 368                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
 369                 if (spec->dig_in_nid) {
 370                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_digital_capture;
 371                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
 372                 }
 373         }
 374
 375         return 0;
 376 }
 377
 378 static void ad198x_free(struct hda_codec *codec)
 379 {
 380         struct ad198x_spec *spec = codec->spec;
 381         unsigned int i;
 382
 383         if (spec->kctl_alloc) {
 384                 for (i = 0; i < spec->num_kctl_used; i++)
 385                         kfree(spec->kctl_alloc[i].name);
 386                 kfree(spec->kctl_alloc);
 387         }
 388         kfree(codec->spec);
 389 }
 390
 391 static struct hda_codec_ops ad198x_patch_ops = {
 392         .build_controls = ad198x_build_controls,
 393         .build_pcms = ad198x_build_pcms,
 394         .init = ad198x_init,
 395         .free = ad198x_free,
 396 #ifdef CONFIG_SND_HDA_POWER_SAVE
 397         .check_power_status = ad198x_check_power_status,
 398 #endif
 399 };
 400
 401
 402 /*
 403  * EAPD control
 404  * the private value = nid | (invert << 8)
 405  */
 406 #define ad198x_eapd_info        snd_ctl_boolean_mono_info
 407
 408 static int ad198x_eapd_get(struct snd_kcontrol *kcontrol,
 409                            struct snd_ctl_elem_value *ucontrol)
 410 {
 411         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 412         struct ad198x_spec *spec = codec->spec;
 413         int invert = (kcontrol->private_value >> 8) & 1;
 414         if (invert)
 415                 ucontrol->value.integer.value[0] = ! spec->cur_eapd;
 416         else
 417                 ucontrol->value.integer.value[0] = spec->cur_eapd;
 418         return 0;
 419 }
 420
 421 static int ad198x_eapd_put(struct snd_kcontrol *kcontrol,
 422                            struct snd_ctl_elem_value *ucontrol)
 423 {
 424         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 425         struct ad198x_spec *spec = codec->spec;
 426         int invert = (kcontrol->private_value >> 8) & 1;
 427         hda_nid_t nid = kcontrol->private_value & 0xff;
 428         unsigned int eapd;
 429         eapd = !!ucontrol->value.integer.value[0];
 430         if (invert)
 431                 eapd = !eapd;
 432         if (eapd == spec->cur_eapd)
 433                 return 0;
 434         spec->cur_eapd = eapd;
 435         snd_hda_codec_write_cache(codec, nid,
 436                                   0, AC_VERB_SET_EAPD_BTLENABLE,
 437                                   eapd ? 0x02 : 0x00);
 438         return 1;
 439 }
 440
 441 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
 442                                struct snd_ctl_elem_info *uinfo);
 443 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
 444                               struct snd_ctl_elem_value *ucontrol);
 445 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
 446                               struct snd_ctl_elem_value *ucontrol);
 447
 448
 449 /*
 450  * AD1986A specific
 451  */
 452
 453 #define AD1986A_SPDIF_OUT       0x02
 454 #define AD1986A_FRONT_DAC       0x03
 455 #define AD1986A_SURR_DAC        0x04
 456 #define AD1986A_CLFE_DAC        0x05
 457 #define AD1986A_ADC             0x06
 458
 459 static hda_nid_t ad1986a_dac_nids[3] = {
 460         AD1986A_FRONT_DAC, AD1986A_SURR_DAC, AD1986A_CLFE_DAC
 461 };
 462 static hda_nid_t ad1986a_adc_nids[1] = { AD1986A_ADC };
 463 static hda_nid_t ad1986a_capsrc_nids[1] = { 0x12 };
 464
 465 static struct hda_input_mux ad1986a_capture_source = {
 466         .num_items = 7,
 467         .items = {
 468                 { "Mic", 0x0 },
 469                 { "CD", 0x1 },
 470                 { "Aux", 0x3 },
 471                 { "Line", 0x4 },
 472                 { "Mix", 0x5 },
 473                 { "Mono", 0x6 },
 474                 { "Phone", 0x7 },
 475         },
 476 };
 477
 478
 479 static struct hda_bind_ctls ad1986a_bind_pcm_vol = {
 480         .ops = &snd_hda_bind_vol,
 481         .values = {
 482                 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
 483                 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
 484                 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
 485                 0
 486         },
 487 };
 488
 489 static struct hda_bind_ctls ad1986a_bind_pcm_sw = {
 490         .ops = &snd_hda_bind_sw,
 491         .values = {
 492                 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
 493                 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
 494                 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
 495                 0
 496         },
 497 };
 498
 499 /*
 500  * mixers
 501  */
 502 static struct snd_kcontrol_new ad1986a_mixers[] = {
 503         /*
 504          * bind volumes/mutes of 3 DACs as a single PCM control for simplicity
 505          */
 506         HDA_BIND_VOL("PCM Playback Volume", &ad1986a_bind_pcm_vol),
 507         HDA_BIND_SW("PCM Playback Switch", &ad1986a_bind_pcm_sw),
 508         HDA_CODEC_VOLUME("Front Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
 509         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
 510         HDA_CODEC_VOLUME("Surround Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
 511         HDA_CODEC_MUTE("Surround Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
 512         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x1d, 1, 0x0, HDA_OUTPUT),
 513         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x1d, 2, 0x0, HDA_OUTPUT),
 514         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x1d, 1, 0x0, HDA_OUTPUT),
 515         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x1d, 2, 0x0, HDA_OUTPUT),
 516         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x1a, 0x0, HDA_OUTPUT),
 517         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
 518         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
 519         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
 520         HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
 521         HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
 522         HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
 523         HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
 524         HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
 525         HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
 526         HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
 527         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x18, 0x0, HDA_OUTPUT),
 528         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x18, 0x0, HDA_OUTPUT),
 529         HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
 530         HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT),
 531         HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
 532         HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
 533         {
 534                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 535                 .name = "Capture Source",
 536                 .info = ad198x_mux_enum_info,
 537                 .get = ad198x_mux_enum_get,
 538                 .put = ad198x_mux_enum_put,
 539         },
 540         HDA_CODEC_MUTE("Stereo Downmix Switch", 0x09, 0x0, HDA_OUTPUT),
 541         { } /* end */
 542 };
 543
 544 /* additional mixers for 3stack mode */
 545 static struct snd_kcontrol_new ad1986a_3st_mixers[] = {
 546         {
 547                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 548                 .name = "Channel Mode",
 549                 .info = ad198x_ch_mode_info,
 550                 .get = ad198x_ch_mode_get,
 551                 .put = ad198x_ch_mode_put,
 552         },
 553         { } /* end */
 554 };
 555
 556 /* laptop model - 2ch only */
 557 static hda_nid_t ad1986a_laptop_dac_nids[1] = { AD1986A_FRONT_DAC };
 558
 559 /* master controls both pins 0x1a and 0x1b */
 560 static struct hda_bind_ctls ad1986a_laptop_master_vol = {
 561         .ops = &snd_hda_bind_vol,
 562         .values = {
 563                 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
 564                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
 565                 0,
 566         },
 567 };
 568
 569 static struct hda_bind_ctls ad1986a_laptop_master_sw = {
 570         .ops = &snd_hda_bind_sw,
 571         .values = {
 572                 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
 573                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
 574                 0,
 575         },
 576 };
 577
 578 static struct snd_kcontrol_new ad1986a_laptop_mixers[] = {
 579         HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
 580         HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
 581         HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
 582         HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
 583         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
 584         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
 585         HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
 586         HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
 587         HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
 588         HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
 589         HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
 590         HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
 591         HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
 592         /* HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x18, 0x0, HDA_OUTPUT),
 593            HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x18, 0x0, HDA_OUTPUT),
 594            HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
 595            HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), */
 596         HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
 597         HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
 598         {
 599                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 600                 .name = "Capture Source",
 601                 .info = ad198x_mux_enum_info,
 602                 .get = ad198x_mux_enum_get,
 603                 .put = ad198x_mux_enum_put,
 604         },
 605         { } /* end */
 606 };
 607
 608 /* laptop-eapd model - 2ch only */
 609
 610 static struct hda_input_mux ad1986a_laptop_eapd_capture_source = {
 611         .num_items = 3,
 612         .items = {
 613                 { "Mic", 0x0 },
 614                 { "Internal Mic", 0x4 },
 615                 { "Mix", 0x5 },
 616         },
 617 };
 618
 619 static struct hda_input_mux ad1986a_automic_capture_source = {
 620         .num_items = 2,
 621         .items = {
 622                 { "Mic", 0x0 },
 623                 { "Mix", 0x5 },
 624         },
 625 };
 626
 627 static struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = {
 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("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
 631         HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
 632         HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
 633         HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
 634         HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
 635         HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
 636         HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
 637         {
 638                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 639                 .name = "Capture Source",
 640                 .info = ad198x_mux_enum_info,
 641                 .get = ad198x_mux_enum_get,
 642                 .put = ad198x_mux_enum_put,
 643         },
 644         {
 645                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 646                 .name = "External Amplifier",
 647                 .info = ad198x_eapd_info,
 648                 .get = ad198x_eapd_get,
 649                 .put = ad198x_eapd_put,
 650                 .private_value = 0x1b | (1 << 8), /* port-D, inversed */
 651         },
 652         { } /* end */
 653 };
 654
 655 /* re-connect the mic boost input according to the jack sensing */
 656 static void ad1986a_automic(struct hda_codec *codec)
 657 {
 658         unsigned int present;
 659         present = snd_hda_codec_read(codec, 0x1f, 0, AC_VERB_GET_PIN_SENSE, 0);
 660         /* 0 = 0x1f, 2 = 0x1d, 4 = mixed */
 661         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_CONNECT_SEL,
 662                             (present & AC_PINSENSE_PRESENCE) ? 0 : 2);
 663 }
 664
 665 #define AD1986A_MIC_EVENT               0x36
 666
 667 static void ad1986a_automic_unsol_event(struct hda_codec *codec,
 668                                             unsigned int res)
 669 {
 670         if ((res >> 26) != AD1986A_MIC_EVENT)
 671                 return;
 672         ad1986a_automic(codec);
 673 }
 674
 675 static int ad1986a_automic_init(struct hda_codec *codec)
 676 {
 677         ad198x_init(codec);
 678         ad1986a_automic(codec);
 679         return 0;
 680 }
 681
 682 /* laptop-automute - 2ch only */
 683
 684 static void ad1986a_update_hp(struct hda_codec *codec)
 685 {
 686         struct ad198x_spec *spec = codec->spec;
 687         unsigned int mute;
 688
 689         if (spec->jack_present)
 690                 mute = HDA_AMP_MUTE; /* mute internal speaker */
 691         else
 692                 /* unmute internal speaker if necessary */
 693                 mute = snd_hda_codec_amp_read(codec, 0x1a, 0, HDA_OUTPUT, 0);
 694         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
 695                                  HDA_AMP_MUTE, mute);
 696 }
 697
 698 static void ad1986a_hp_automute(struct hda_codec *codec)
 699 {
 700         struct ad198x_spec *spec = codec->spec;
 701         unsigned int present;
 702
 703         present = snd_hda_codec_read(codec, 0x1a, 0, AC_VERB_GET_PIN_SENSE, 0);
 704         /* Lenovo N100 seems to report the reversed bit for HP jack-sensing */
 705         spec->jack_present = !(present & 0x80000000);
 706         ad1986a_update_hp(codec);
 707 }
 708
 709 #define AD1986A_HP_EVENT                0x37
 710
 711 static void ad1986a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
 712 {
 713         if ((res >> 26) != AD1986A_HP_EVENT)
 714                 return;
 715         ad1986a_hp_automute(codec);
 716 }
 717
 718 static int ad1986a_hp_init(struct hda_codec *codec)
 719 {
 720         ad198x_init(codec);
 721         ad1986a_hp_automute(codec);
 722         return 0;
 723 }
 724
 725 /* bind hp and internal speaker mute (with plug check) */
 726 static int ad1986a_hp_master_sw_put(struct snd_kcontrol *kcontrol,
 727                                     struct snd_ctl_elem_value *ucontrol)
 728 {
 729         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 730         long *valp = ucontrol->value.integer.value;
 731         int change;
 732
 733         change = snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_OUTPUT, 0,
 734                                           HDA_AMP_MUTE,
 735                                           valp[0] ? 0 : HDA_AMP_MUTE);
 736         change |= snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_OUTPUT, 0,
 737                                            HDA_AMP_MUTE,
 738                                            valp[1] ? 0 : HDA_AMP_MUTE);
 739         if (change)
 740                 ad1986a_update_hp(codec);
 741         return change;
 742 }
 743
 744 static struct snd_kcontrol_new ad1986a_laptop_automute_mixers[] = {
 745         HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
 746         {
 747                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 748                 .name = "Master Playback Switch",
 749                 .info = snd_hda_mixer_amp_switch_info,
 750                 .get = snd_hda_mixer_amp_switch_get,
 751                 .put = ad1986a_hp_master_sw_put,
 752                 .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
 753         },
 754         HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
 755         HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
 756         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0x0, HDA_OUTPUT),
 757         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0x0, HDA_OUTPUT),
 758         HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
 759         HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
 760         HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
 761         HDA_CODEC_VOLUME("Beep Playback Volume", 0x18, 0x0, HDA_OUTPUT),
 762         HDA_CODEC_MUTE("Beep Playback Switch", 0x18, 0x0, HDA_OUTPUT),
 763         HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
 764         HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
 765         {
 766                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 767                 .name = "Capture Source",
 768                 .info = ad198x_mux_enum_info,
 769                 .get = ad198x_mux_enum_get,
 770                 .put = ad198x_mux_enum_put,
 771         },
 772         {
 773                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 774                 .name = "External Amplifier",
 775                 .info = ad198x_eapd_info,
 776                 .get = ad198x_eapd_get,
 777                 .put = ad198x_eapd_put,
 778                 .private_value = 0x1b | (1 << 8), /* port-D, inversed */
 779         },
 780         { } /* end */
 781 };
 782
 783 /*
 784  * initialization verbs
 785  */
 786 static struct hda_verb ad1986a_init_verbs[] = {
 787         /* Front, Surround, CLFE DAC; mute as default */
 788         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 789         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 790         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 791         /* Downmix - off */
 792         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 793         /* HP, Line-Out, Surround, CLFE selectors */
 794         {0x0a, AC_VERB_SET_CONNECT_SEL, 0x0},
 795         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0},
 796         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
 797         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
 798         /* Mono selector */
 799         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x0},
 800         /* Mic selector: Mic 1/2 pin */
 801         {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
 802         /* Line-in selector: Line-in */
 803         {0x10, AC_VERB_SET_CONNECT_SEL, 0x0},
 804         /* Mic 1/2 swap */
 805         {0x11, AC_VERB_SET_CONNECT_SEL, 0x0},
 806         /* Record selector: mic */
 807         {0x12, AC_VERB_SET_CONNECT_SEL, 0x0},
 808         /* Mic, Phone, CD, Aux, Line-In amp; mute as default */
 809         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 810         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 811         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 812         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 813         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 814         /* PC beep */
 815         {0x18, AC_VERB_SET_CONNECT_SEL, 0x0},
 816         /* HP, Line-Out, Surround, CLFE, Mono pins; mute as default */
 817         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 818         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 819         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 820         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 821         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
 822         /* HP Pin */
 823         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
 824         /* Front, Surround, CLFE Pins */
 825         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
 826         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
 827         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
 828         /* Mono Pin */
 829         {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
 830         /* Mic Pin */
 831         {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
 832         /* Line, Aux, CD, Beep-In Pin */
 833         {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
 834         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
 835         {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
 836         {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
 837         {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
 838         { } /* end */
 839 };
 840
 841 static struct hda_verb ad1986a_ch2_init[] = {
 842         /* Surround out -> Line In */
 843         { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
 844         /* Line-in selectors */
 845         { 0x10, AC_VERB_SET_CONNECT_SEL, 0x1 },
 846         /* CLFE -> Mic in */
 847         { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
 848         /* Mic selector, mix C/LFE (backmic) and Mic (frontmic) */
 849         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
 850         { } /* end */
 851 };
 852
 853 static struct hda_verb ad1986a_ch4_init[] = {
 854         /* Surround out -> Surround */
 855         { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 856         { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
 857         /* CLFE -> Mic in */
 858         { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
 859         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
 860         { } /* end */
 861 };
 862
 863 static struct hda_verb ad1986a_ch6_init[] = {
 864         /* Surround out -> Surround out */
 865         { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 866         { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
 867         /* CLFE -> CLFE */
 868         { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 869         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x0 },
 870         { } /* end */
 871 };
 872
 873 static struct hda_channel_mode ad1986a_modes[3] = {
 874         { 2, ad1986a_ch2_init },
 875         { 4, ad1986a_ch4_init },
 876         { 6, ad1986a_ch6_init },
 877 };
 878
 879 /* eapd initialization */
 880 static struct hda_verb ad1986a_eapd_init_verbs[] = {
 881         {0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
 882         {}
 883 };
 884
 885 static struct hda_verb ad1986a_automic_verbs[] = {
 886         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 887         {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 888         /*{0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},*/
 889         {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
 890         {0x1f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_MIC_EVENT},
 891         {}
 892 };
 893
 894 /* Ultra initialization */
 895 static struct hda_verb ad1986a_ultra_init[] = {
 896         /* eapd initialization */
 897         { 0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
 898         /* CLFE -> Mic in */
 899         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2 },
 900         { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
 901         { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
 902         { } /* end */
 903 };
 904
 905 /* pin sensing on HP jack */
 906 static struct hda_verb ad1986a_hp_init_verbs[] = {
 907         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_HP_EVENT},
 908         {}
 909 };
 910
 911
 912 /* models */
 913 enum {
 914         AD1986A_6STACK,
 915         AD1986A_3STACK,
 916         AD1986A_LAPTOP,
 917         AD1986A_LAPTOP_EAPD,
 918         AD1986A_LAPTOP_AUTOMUTE,
 919         AD1986A_ULTRA,
 920         AD1986A_MODELS
 921 };
 922
 923 static const char *ad1986a_models[AD1986A_MODELS] = {
 924         [AD1986A_6STACK]        = "6stack",
 925         [AD1986A_3STACK]        = "3stack",
 926         [AD1986A_LAPTOP]        = "laptop",
 927         [AD1986A_LAPTOP_EAPD]   = "laptop-eapd",
 928         [AD1986A_LAPTOP_AUTOMUTE] = "laptop-automute",
 929         [AD1986A_ULTRA]         = "ultra",
 930 };
 931
 932 static struct snd_pci_quirk ad1986a_cfg_tbl[] = {
 933         SND_PCI_QUIRK(0x103c, 0x30af, "HP B2800", AD1986A_LAPTOP_EAPD),
 934         SND_PCI_QUIRK(0x1043, 0x1153, "ASUS M9", AD1986A_LAPTOP_EAPD),
 935         SND_PCI_QUIRK(0x1043, 0x11f7, "ASUS U5A", AD1986A_LAPTOP_EAPD),
 936         SND_PCI_QUIRK(0x1043, 0x1213, "ASUS A6J", AD1986A_LAPTOP_EAPD),
 937         SND_PCI_QUIRK(0x1043, 0x1263, "ASUS U5F", AD1986A_LAPTOP_EAPD),
 938         SND_PCI_QUIRK(0x1043, 0x1297, "ASUS Z62F", AD1986A_LAPTOP_EAPD),
 939         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS V1j", AD1986A_LAPTOP_EAPD),
 940         SND_PCI_QUIRK(0x1043, 0x1302, "ASUS W3j", AD1986A_LAPTOP_EAPD),
 941         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS VX1", AD1986A_LAPTOP),
 942         SND_PCI_QUIRK(0x1043, 0x1447, "ASUS A8J", AD1986A_3STACK),
 943         SND_PCI_QUIRK(0x1043, 0x817f, "ASUS P5", AD1986A_3STACK),
 944         SND_PCI_QUIRK(0x1043, 0x818f, "ASUS P5", AD1986A_LAPTOP),
 945         SND_PCI_QUIRK(0x1043, 0x81b3, "ASUS P5", AD1986A_3STACK),
 946         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS M2N", AD1986A_3STACK),
 947         SND_PCI_QUIRK(0x1043, 0x8234, "ASUS M2N", AD1986A_3STACK),
 948         SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_3STACK),
 949         SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba", AD1986A_LAPTOP_EAPD),
 950         SND_PCI_QUIRK(0x144d, 0xb03c, "Samsung R55", AD1986A_3STACK),
 951         SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_LAPTOP),
 952         SND_PCI_QUIRK(0x144d, 0xc023, "Samsung X60", AD1986A_LAPTOP_EAPD),
 953         SND_PCI_QUIRK(0x144d, 0xc024, "Samsung R65", AD1986A_LAPTOP_EAPD),
 954         SND_PCI_QUIRK(0x144d, 0xc026, "Samsung X11", AD1986A_LAPTOP_EAPD),
 955         SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_ULTRA),
 956         SND_PCI_QUIRK(0x144d, 0xc504, "Samsung Q35", AD1986A_3STACK),
 957         SND_PCI_QUIRK(0x17aa, 0x1011, "Lenovo M55", AD1986A_LAPTOP),
 958         SND_PCI_QUIRK(0x17aa, 0x1017, "Lenovo A60", AD1986A_3STACK),
 959         SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo N100", AD1986A_LAPTOP_AUTOMUTE),
 960         SND_PCI_QUIRK(0x17c0, 0x2017, "Samsung M50", AD1986A_LAPTOP),
 961         {}
 962 };
 963
 964 #ifdef CONFIG_SND_HDA_POWER_SAVE
 965 static struct hda_amp_list ad1986a_loopbacks[] = {
 966         { 0x13, HDA_OUTPUT, 0 }, /* Mic */
 967         { 0x14, HDA_OUTPUT, 0 }, /* Phone */
 968         { 0x15, HDA_OUTPUT, 0 }, /* CD */
 969         { 0x16, HDA_OUTPUT, 0 }, /* Aux */
 970         { 0x17, HDA_OUTPUT, 0 }, /* Line */
 971         { } /* end */
 972 };
 973 #endif
 974
 975 static int is_jack_available(struct hda_codec *codec, hda_nid_t nid)
 976 {
 977         unsigned int conf = snd_hda_codec_read(codec, nid, 0,
 978                                                AC_VERB_GET_CONFIG_DEFAULT, 0);
 979         return get_defcfg_connect(conf) != AC_JACK_PORT_NONE;
 980 }
 981
 982 static int patch_ad1986a(struct hda_codec *codec)
 983 {
 984         struct ad198x_spec *spec;
 985         int board_config;
 986
 987         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
 988         if (spec == NULL)
 989                 return -ENOMEM;
 990
 991         codec->spec = spec;
 992
 993         spec->multiout.max_channels = 6;
 994         spec->multiout.num_dacs = ARRAY_SIZE(ad1986a_dac_nids);
 995         spec->multiout.dac_nids = ad1986a_dac_nids;
 996         spec->multiout.dig_out_nid = AD1986A_SPDIF_OUT;
 997         spec->num_adc_nids = 1;
 998         spec->adc_nids = ad1986a_adc_nids;
 999         spec->capsrc_nids = ad1986a_capsrc_nids;
1000         spec->input_mux = &ad1986a_capture_source;
1001         spec->num_mixers = 1;
1002         spec->mixers[0] = ad1986a_mixers;
1003         spec->num_init_verbs = 1;
1004         spec->init_verbs[0] = ad1986a_init_verbs;
1005 #ifdef CONFIG_SND_HDA_POWER_SAVE
1006         spec->loopback.amplist = ad1986a_loopbacks;
1007 #endif
1008         spec->vmaster_nid = 0x1b;
1009
1010         codec->patch_ops = ad198x_patch_ops;
1011
1012         /* override some parameters */
1013         board_config = snd_hda_check_board_config(codec, AD1986A_MODELS,
1014                                                   ad1986a_models,
1015                                                   ad1986a_cfg_tbl);
1016         switch (board_config) {
1017         case AD1986A_3STACK:
1018                 spec->num_mixers = 2;
1019                 spec->mixers[1] = ad1986a_3st_mixers;
1020                 spec->num_init_verbs = 2;
1021                 spec->init_verbs[1] = ad1986a_ch2_init;
1022                 spec->channel_mode = ad1986a_modes;
1023                 spec->num_channel_mode = ARRAY_SIZE(ad1986a_modes);
1024                 spec->need_dac_fix = 1;
1025                 spec->multiout.max_channels = 2;
1026                 spec->multiout.num_dacs = 1;
1027                 break;
1028         case AD1986A_LAPTOP:
1029                 spec->mixers[0] = ad1986a_laptop_mixers;
1030                 spec->multiout.max_channels = 2;
1031                 spec->multiout.num_dacs = 1;
1032                 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1033                 break;
1034         case AD1986A_LAPTOP_EAPD:
1035                 spec->mixers[0] = ad1986a_laptop_eapd_mixers;
1036                 spec->num_init_verbs = 3;
1037                 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1038                 spec->init_verbs[2] = ad1986a_automic_verbs;
1039                 spec->multiout.max_channels = 2;
1040                 spec->multiout.num_dacs = 1;
1041                 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1042                 if (!is_jack_available(codec, 0x25))
1043                         spec->multiout.dig_out_nid = 0;
1044                 spec->input_mux = &ad1986a_automic_capture_source;
1045                 codec->patch_ops.unsol_event = ad1986a_automic_unsol_event;
1046                 codec->patch_ops.init = ad1986a_automic_init;
1047                 break;
1048         case AD1986A_LAPTOP_AUTOMUTE:
1049                 spec->mixers[0] = ad1986a_laptop_automute_mixers;
1050                 spec->num_init_verbs = 3;
1051                 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1052                 spec->init_verbs[2] = ad1986a_hp_init_verbs;
1053                 spec->multiout.max_channels = 2;
1054                 spec->multiout.num_dacs = 1;
1055                 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1056                 if (!is_jack_available(codec, 0x25))
1057                         spec->multiout.dig_out_nid = 0;
1058                 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
1059                 codec->patch_ops.unsol_event = ad1986a_hp_unsol_event;
1060                 codec->patch_ops.init = ad1986a_hp_init;
1061                 break;
1062         case AD1986A_ULTRA:
1063                 spec->mixers[0] = ad1986a_laptop_eapd_mixers;
1064                 spec->num_init_verbs = 2;
1065                 spec->init_verbs[1] = ad1986a_ultra_init;
1066                 spec->multiout.max_channels = 2;
1067                 spec->multiout.num_dacs = 1;
1068                 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1069                 spec->multiout.dig_out_nid = 0;
1070                 break;
1071         }
1072
1073         /* AD1986A has a hardware problem that it can't share a stream
1074          * with multiple output pins.  The copy of front to surrounds
1075          * causes noisy or silent outputs at a certain timing, e.g.
1076          * changing the volume.
1077          * So, let's disable the shared stream.
1078          */
1079         spec->multiout.no_share_stream = 1;
1080
1081         return 0;
1082 }
1083
1084 /*
1085  * AD1983 specific
1086  */
1087
1088 #define AD1983_SPDIF_OUT        0x02
1089 #define AD1983_DAC              0x03
1090 #define AD1983_ADC              0x04
1091
1092 static hda_nid_t ad1983_dac_nids[1] = { AD1983_DAC };
1093 static hda_nid_t ad1983_adc_nids[1] = { AD1983_ADC };
1094 static hda_nid_t ad1983_capsrc_nids[1] = { 0x15 };
1095
1096 static struct hda_input_mux ad1983_capture_source = {
1097         .num_items = 4,
1098         .items = {
1099                 { "Mic", 0x0 },
1100                 { "Line", 0x1 },
1101                 { "Mix", 0x2 },
1102                 { "Mix Mono", 0x3 },
1103         },
1104 };
1105
1106 /*
1107  * SPDIF playback route
1108  */
1109 static int ad1983_spdif_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1110 {
1111         static char *texts[] = { "PCM", "ADC" };
1112
1113         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1114         uinfo->count = 1;
1115         uinfo->value.enumerated.items = 2;
1116         if (uinfo->value.enumerated.item > 1)
1117                 uinfo->value.enumerated.item = 1;
1118         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1119         return 0;
1120 }
1121
1122 static int ad1983_spdif_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1123 {
1124         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1125         struct ad198x_spec *spec = codec->spec;
1126
1127         ucontrol->value.enumerated.item[0] = spec->spdif_route;
1128         return 0;
1129 }
1130
1131 static int ad1983_spdif_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1132 {
1133         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1134         struct ad198x_spec *spec = codec->spec;
1135
1136         if (ucontrol->value.enumerated.item[0] > 1)
1137                 return -EINVAL;
1138         if (spec->spdif_route != ucontrol->value.enumerated.item[0]) {
1139                 spec->spdif_route = ucontrol->value.enumerated.item[0];
1140                 snd_hda_codec_write_cache(codec, spec->multiout.dig_out_nid, 0,
1141                                           AC_VERB_SET_CONNECT_SEL,
1142                                           spec->spdif_route);
1143                 return 1;
1144         }
1145         return 0;
1146 }
1147
1148 static struct snd_kcontrol_new ad1983_mixers[] = {
1149         HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1150         HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1151         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1152         HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1153         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1154         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1155         HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1156         HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1157         HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1158         HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1159         HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1160         HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1161         HDA_CODEC_VOLUME_MONO("PC Speaker Playback Volume", 0x10, 1, 0x0, HDA_OUTPUT),
1162         HDA_CODEC_MUTE_MONO("PC Speaker Playback Switch", 0x10, 1, 0x0, HDA_OUTPUT),
1163         HDA_CODEC_VOLUME("Mic Boost", 0x0c, 0x0, HDA_OUTPUT),
1164         HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1165         HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1166         {
1167                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1168                 .name = "Capture Source",
1169                 .info = ad198x_mux_enum_info,
1170                 .get = ad198x_mux_enum_get,
1171                 .put = ad198x_mux_enum_put,
1172         },
1173         {
1174                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1175                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1176                 .info = ad1983_spdif_route_info,
1177                 .get = ad1983_spdif_route_get,
1178                 .put = ad1983_spdif_route_put,
1179         },
1180         { } /* end */
1181 };
1182
1183 static struct hda_verb ad1983_init_verbs[] = {
1184         /* Front, HP, Mono; mute as default */
1185         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1186         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1187         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1188         /* Beep, PCM, Mic, Line-In: mute */
1189         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1190         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1191         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1192         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1193         /* Front, HP selectors; from Mix */
1194         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1195         {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1196         /* Mono selector; from Mix */
1197         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1198         /* Mic selector; Mic */
1199         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
1200         /* Line-in selector: Line-in */
1201         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
1202         /* Mic boost: 0dB */
1203         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1204         /* Record selector: mic */
1205         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1206         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1207         /* SPDIF route: PCM */
1208         {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1209         /* Front Pin */
1210         {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1211         /* HP Pin */
1212         {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1213         /* Mono Pin */
1214         {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1215         /* Mic Pin */
1216         {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1217         /* Line Pin */
1218         {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1219         { } /* end */
1220 };
1221
1222 #ifdef CONFIG_SND_HDA_POWER_SAVE
1223 static struct hda_amp_list ad1983_loopbacks[] = {
1224         { 0x12, HDA_OUTPUT, 0 }, /* Mic */
1225         { 0x13, HDA_OUTPUT, 0 }, /* Line */
1226         { } /* end */
1227 };
1228 #endif
1229
1230 static int patch_ad1983(struct hda_codec *codec)
1231 {
1232         struct ad198x_spec *spec;
1233
1234         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1235         if (spec == NULL)
1236                 return -ENOMEM;
1237
1238         codec->spec = spec;
1239
1240         spec->multiout.max_channels = 2;
1241         spec->multiout.num_dacs = ARRAY_SIZE(ad1983_dac_nids);
1242         spec->multiout.dac_nids = ad1983_dac_nids;
1243         spec->multiout.dig_out_nid = AD1983_SPDIF_OUT;
1244         spec->num_adc_nids = 1;
1245         spec->adc_nids = ad1983_adc_nids;
1246         spec->capsrc_nids = ad1983_capsrc_nids;
1247         spec->input_mux = &ad1983_capture_source;
1248         spec->num_mixers = 1;
1249         spec->mixers[0] = ad1983_mixers;
1250         spec->num_init_verbs = 1;
1251         spec->init_verbs[0] = ad1983_init_verbs;
1252         spec->spdif_route = 0;
1253 #ifdef CONFIG_SND_HDA_POWER_SAVE
1254         spec->loopback.amplist = ad1983_loopbacks;
1255 #endif
1256         spec->vmaster_nid = 0x05;
1257
1258         codec->patch_ops = ad198x_patch_ops;
1259
1260         return 0;
1261 }
1262
1263
1264 /*
1265  * AD1981 HD specific
1266  */
1267
1268 #define AD1981_SPDIF_OUT        0x02
1269 #define AD1981_DAC              0x03
1270 #define AD1981_ADC              0x04
1271
1272 static hda_nid_t ad1981_dac_nids[1] = { AD1981_DAC };
1273 static hda_nid_t ad1981_adc_nids[1] = { AD1981_ADC };
1274 static hda_nid_t ad1981_capsrc_nids[1] = { 0x15 };
1275
1276 /* 0x0c, 0x09, 0x0e, 0x0f, 0x19, 0x05, 0x18, 0x17 */
1277 static struct hda_input_mux ad1981_capture_source = {
1278         .num_items = 7,
1279         .items = {
1280                 { "Front Mic", 0x0 },
1281                 { "Line", 0x1 },
1282                 { "Mix", 0x2 },
1283                 { "Mix Mono", 0x3 },
1284                 { "CD", 0x4 },
1285                 { "Mic", 0x6 },
1286                 { "Aux", 0x7 },
1287         },
1288 };
1289
1290 static struct snd_kcontrol_new ad1981_mixers[] = {
1291         HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1292         HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1293         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1294         HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1295         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1296         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1297         HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1298         HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1299         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1300         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1301         HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1302         HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1303         HDA_CODEC_VOLUME("Aux Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
1304         HDA_CODEC_MUTE("Aux Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1305         HDA_CODEC_VOLUME("Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1306         HDA_CODEC_MUTE("Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1307         HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1308         HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1309         HDA_CODEC_VOLUME_MONO("PC Speaker Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
1310         HDA_CODEC_MUTE_MONO("PC Speaker Playback Switch", 0x0d, 1, 0x0, HDA_OUTPUT),
1311         HDA_CODEC_VOLUME("Front Mic Boost", 0x08, 0x0, HDA_INPUT),
1312         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x0, HDA_INPUT),
1313         HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1314         HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1315         {
1316                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1317                 .name = "Capture Source",
1318                 .info = ad198x_mux_enum_info,
1319                 .get = ad198x_mux_enum_get,
1320                 .put = ad198x_mux_enum_put,
1321         },
1322         /* identical with AD1983 */
1323         {
1324                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1325                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1326                 .info = ad1983_spdif_route_info,
1327                 .get = ad1983_spdif_route_get,
1328                 .put = ad1983_spdif_route_put,
1329         },
1330         { } /* end */
1331 };
1332
1333 static struct hda_verb ad1981_init_verbs[] = {
1334         /* Front, HP, Mono; mute as default */
1335         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1336         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1337         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1338         /* Beep, PCM, Front Mic, Line, Rear Mic, Aux, CD-In: mute */
1339         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1340         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1341         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1342         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1343         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1344         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1345         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1346         /* Front, HP selectors; from Mix */
1347         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1348         {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1349         /* Mono selector; from Mix */
1350         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1351         /* Mic Mixer; select Front Mic */
1352         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1353         {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1354         /* Mic boost: 0dB */
1355         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1356         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1357         /* Record selector: Front mic */
1358         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1359         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1360         /* SPDIF route: PCM */
1361         {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1362         /* Front Pin */
1363         {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1364         /* HP Pin */
1365         {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1366         /* Mono Pin */
1367         {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1368         /* Front & Rear Mic Pins */
1369         {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1370         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1371         /* Line Pin */
1372         {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1373         /* Digital Beep */
1374         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
1375         /* Line-Out as Input: disabled */
1376         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1377         { } /* end */
1378 };
1379
1380 #ifdef CONFIG_SND_HDA_POWER_SAVE
1381 static struct hda_amp_list ad1981_loopbacks[] = {
1382         { 0x12, HDA_OUTPUT, 0 }, /* Front Mic */
1383         { 0x13, HDA_OUTPUT, 0 }, /* Line */
1384         { 0x1b, HDA_OUTPUT, 0 }, /* Aux */
1385         { 0x1c, HDA_OUTPUT, 0 }, /* Mic */
1386         { 0x1d, HDA_OUTPUT, 0 }, /* CD */
1387         { } /* end */
1388 };
1389 #endif
1390
1391 /*
1392  * Patch for HP nx6320
1393  *
1394  * nx6320 uses EAPD in the reverse way - EAPD-on means the internal
1395  * speaker output enabled _and_ mute-LED off.
1396  */
1397
1398 #define AD1981_HP_EVENT         0x37
1399 #define AD1981_MIC_EVENT        0x38
1400
1401 static struct hda_verb ad1981_hp_init_verbs[] = {
1402         {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, /* default off */
1403         /* pin sensing on HP and Mic jacks */
1404         {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1405         {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1406         {}
1407 };
1408
1409 /* turn on/off EAPD (+ mute HP) as a master switch */
1410 static int ad1981_hp_master_sw_put(struct snd_kcontrol *kcontrol,
1411                                    struct snd_ctl_elem_value *ucontrol)
1412 {
1413         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1414         struct ad198x_spec *spec = codec->spec;
1415
1416         if (! ad198x_eapd_put(kcontrol, ucontrol))
1417                 return 0;
1418         /* change speaker pin appropriately */
1419         snd_hda_codec_write(codec, 0x05, 0,
1420                             AC_VERB_SET_PIN_WIDGET_CONTROL,
1421                             spec->cur_eapd ? PIN_OUT : 0);
1422         /* toggle HP mute appropriately */
1423         snd_hda_codec_amp_stereo(codec, 0x06, HDA_OUTPUT, 0,
1424                                  HDA_AMP_MUTE,
1425                                  spec->cur_eapd ? 0 : HDA_AMP_MUTE);
1426         return 1;
1427 }
1428
1429 /* bind volumes of both NID 0x05 and 0x06 */
1430 static struct hda_bind_ctls ad1981_hp_bind_master_vol = {
1431         .ops = &snd_hda_bind_vol,
1432         .values = {
1433                 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
1434                 HDA_COMPOSE_AMP_VAL(0x06, 3, 0, HDA_OUTPUT),
1435                 0
1436         },
1437 };
1438
1439 /* mute internal speaker if HP is plugged */
1440 static void ad1981_hp_automute(struct hda_codec *codec)
1441 {
1442         unsigned int present;
1443
1444         present = snd_hda_codec_read(codec, 0x06, 0,
1445                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1446         snd_hda_codec_amp_stereo(codec, 0x05, HDA_OUTPUT, 0,
1447                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
1448 }
1449
1450 /* toggle input of built-in and mic jack appropriately */
1451 static void ad1981_hp_automic(struct hda_codec *codec)
1452 {
1453         static struct hda_verb mic_jack_on[] = {
1454                 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1455                 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1456                 {}
1457         };
1458         static struct hda_verb mic_jack_off[] = {
1459                 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1460                 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1461                 {}
1462         };
1463         unsigned int present;
1464
1465         present = snd_hda_codec_read(codec, 0x08, 0,
1466                                  AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1467         if (present)
1468                 snd_hda_sequence_write(codec, mic_jack_on);
1469         else
1470                 snd_hda_sequence_write(codec, mic_jack_off);
1471 }
1472
1473 /* unsolicited event for HP jack sensing */
1474 static void ad1981_hp_unsol_event(struct hda_codec *codec,
1475                                   unsigned int res)
1476 {
1477         res >>= 26;
1478         switch (res) {
1479         case AD1981_HP_EVENT:
1480                 ad1981_hp_automute(codec);
1481                 break;
1482         case AD1981_MIC_EVENT:
1483                 ad1981_hp_automic(codec);
1484                 break;
1485         }
1486 }
1487
1488 static struct hda_input_mux ad1981_hp_capture_source = {
1489         .num_items = 3,
1490         .items = {
1491                 { "Mic", 0x0 },
1492                 { "Docking-Station", 0x1 },
1493                 { "Mix", 0x2 },
1494         },
1495 };
1496
1497 static struct snd_kcontrol_new ad1981_hp_mixers[] = {
1498         HDA_BIND_VOL("Master Playback Volume", &ad1981_hp_bind_master_vol),
1499         {
1500                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1501                 .name = "Master Playback Switch",
1502                 .info = ad198x_eapd_info,
1503                 .get = ad198x_eapd_get,
1504                 .put = ad1981_hp_master_sw_put,
1505                 .private_value = 0x05,
1506         },
1507         HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1508         HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1509 #if 0
1510         /* FIXME: analog mic/line loopback doesn't work with my tests...
1511          *        (although recording is OK)
1512          */
1513         HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1514         HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1515         HDA_CODEC_VOLUME("Docking-Station Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1516         HDA_CODEC_MUTE("Docking-Station Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1517         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1518         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1519         /* FIXME: does this laptop have analog CD connection? */
1520         HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1521         HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1522 #endif
1523         HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
1524         HDA_CODEC_VOLUME("Internal Mic Boost", 0x18, 0x0, HDA_INPUT),
1525         HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1526         HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1527         {
1528                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1529                 .name = "Capture Source",
1530                 .info = ad198x_mux_enum_info,
1531                 .get = ad198x_mux_enum_get,
1532                 .put = ad198x_mux_enum_put,
1533         },
1534         { } /* end */
1535 };
1536
1537 /* initialize jack-sensing, too */
1538 static int ad1981_hp_init(struct hda_codec *codec)
1539 {
1540         ad198x_init(codec);
1541         ad1981_hp_automute(codec);
1542         ad1981_hp_automic(codec);
1543         return 0;
1544 }
1545
1546 /* configuration for Toshiba Laptops */
1547 static struct hda_verb ad1981_toshiba_init_verbs[] = {
1548         {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x01 }, /* default on */
1549         /* pin sensing on HP and Mic jacks */
1550         {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1551         {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1552         {}
1553 };
1554
1555 static struct snd_kcontrol_new ad1981_toshiba_mixers[] = {
1556         HDA_CODEC_VOLUME("Amp Volume", 0x1a, 0x0, HDA_OUTPUT),
1557         HDA_CODEC_MUTE("Amp Switch", 0x1a, 0x0, HDA_OUTPUT),
1558         { }
1559 };
1560
1561 /* configuration for Lenovo Thinkpad T60 */
1562 static struct snd_kcontrol_new ad1981_thinkpad_mixers[] = {
1563         HDA_CODEC_VOLUME("Master Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1564         HDA_CODEC_MUTE("Master Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1565         HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1566         HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1567         HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1568         HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1569         HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1570         HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1571         HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
1572         HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1573         HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1574         {
1575                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1576                 .name = "Capture Source",
1577                 .info = ad198x_mux_enum_info,
1578                 .get = ad198x_mux_enum_get,
1579                 .put = ad198x_mux_enum_put,
1580         },
1581         /* identical with AD1983 */
1582         {
1583                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1584                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1585                 .info = ad1983_spdif_route_info,
1586                 .get = ad1983_spdif_route_get,
1587                 .put = ad1983_spdif_route_put,
1588         },
1589         { } /* end */
1590 };
1591
1592 static struct hda_input_mux ad1981_thinkpad_capture_source = {
1593         .num_items = 3,
1594         .items = {
1595                 { "Mic", 0x0 },
1596                 { "Mix", 0x2 },
1597                 { "CD", 0x4 },
1598         },
1599 };
1600
1601 /* models */
1602 enum {
1603         AD1981_BASIC,
1604         AD1981_HP,
1605         AD1981_THINKPAD,
1606         AD1981_TOSHIBA,
1607         AD1981_MODELS
1608 };
1609
1610 static const char *ad1981_models[AD1981_MODELS] = {
1611         [AD1981_HP]             = "hp",
1612         [AD1981_THINKPAD]       = "thinkpad",
1613         [AD1981_BASIC]          = "basic",
1614         [AD1981_TOSHIBA]        = "toshiba"
1615 };
1616
1617 static struct snd_pci_quirk ad1981_cfg_tbl[] = {
1618         SND_PCI_QUIRK(0x1014, 0x0597, "Lenovo Z60", AD1981_THINKPAD),
1619         SND_PCI_QUIRK(0x1014, 0x05b7, "Lenovo Z60m", AD1981_THINKPAD),
1620         /* All HP models */
1621         SND_PCI_QUIRK(0x103c, 0, "HP nx", AD1981_HP),
1622         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba U205", AD1981_TOSHIBA),
1623         /* Lenovo Thinkpad T60/X60/Z6xx */
1624         SND_PCI_QUIRK(0x17aa, 0, "Lenovo Thinkpad", AD1981_THINKPAD),
1625         /* HP nx6320 (reversed SSID, H/W bug) */
1626         SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_HP),
1627         {}
1628 };
1629
1630 static int patch_ad1981(struct hda_codec *codec)
1631 {
1632         struct ad198x_spec *spec;
1633         int board_config;
1634
1635         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1636         if (spec == NULL)
1637                 return -ENOMEM;
1638
1639         codec->spec = spec;
1640
1641         spec->multiout.max_channels = 2;
1642         spec->multiout.num_dacs = ARRAY_SIZE(ad1981_dac_nids);
1643         spec->multiout.dac_nids = ad1981_dac_nids;
1644         spec->multiout.dig_out_nid = AD1981_SPDIF_OUT;
1645         spec->num_adc_nids = 1;
1646         spec->adc_nids = ad1981_adc_nids;
1647         spec->capsrc_nids = ad1981_capsrc_nids;
1648         spec->input_mux = &ad1981_capture_source;
1649         spec->num_mixers = 1;
1650         spec->mixers[0] = ad1981_mixers;
1651         spec->num_init_verbs = 1;
1652         spec->init_verbs[0] = ad1981_init_verbs;
1653         spec->spdif_route = 0;
1654 #ifdef CONFIG_SND_HDA_POWER_SAVE
1655         spec->loopback.amplist = ad1981_loopbacks;
1656 #endif
1657         spec->vmaster_nid = 0x05;
1658
1659         codec->patch_ops = ad198x_patch_ops;
1660
1661         /* override some parameters */
1662         board_config = snd_hda_check_board_config(codec, AD1981_MODELS,
1663                                                   ad1981_models,
1664                                                   ad1981_cfg_tbl);
1665         switch (board_config) {
1666         case AD1981_HP:
1667                 spec->mixers[0] = ad1981_hp_mixers;
1668                 spec->num_init_verbs = 2;
1669                 spec->init_verbs[1] = ad1981_hp_init_verbs;
1670                 spec->multiout.dig_out_nid = 0;
1671                 spec->input_mux = &ad1981_hp_capture_source;
1672
1673                 codec->patch_ops.init = ad1981_hp_init;
1674                 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1675                 break;
1676         case AD1981_THINKPAD:
1677                 spec->mixers[0] = ad1981_thinkpad_mixers;
1678                 spec->input_mux = &ad1981_thinkpad_capture_source;
1679                 break;
1680         case AD1981_TOSHIBA:
1681                 spec->mixers[0] = ad1981_hp_mixers;
1682                 spec->mixers[1] = ad1981_toshiba_mixers;
1683                 spec->num_init_verbs = 2;
1684                 spec->init_verbs[1] = ad1981_toshiba_init_verbs;
1685                 spec->multiout.dig_out_nid = 0;
1686                 spec->input_mux = &ad1981_hp_capture_source;
1687                 codec->patch_ops.init = ad1981_hp_init;
1688                 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1689                 break;
1690         }
1691         return 0;
1692 }
1693
1694
1695 /*
1696  * AD1988
1697  *
1698  * Output pins and routes
1699  *
1700  *        Pin               Mix     Sel     DAC (*)
1701  * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06
1702  * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06
1703  * port-C 0x15 (mute)    <- 0x2c <- 0x31 <- 05/0a
1704  * port-D 0x12 (mute/hp) <- 0x29         <- 04
1705  * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a
1706  * port-F 0x16 (mute)    <- 0x2a         <- 06
1707  * port-G 0x24 (mute)    <- 0x27         <- 05
1708  * port-H 0x25 (mute)    <- 0x28         <- 0a
1709  * mono   0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06
1710  *
1711  * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah
1712  * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug.
1713  *
1714  * Input pins and routes
1715  *
1716  *        pin     boost   mix input # / adc input #
1717  * port-A 0x11 -> 0x38 -> mix 2, ADC 0
1718  * port-B 0x14 -> 0x39 -> mix 0, ADC 1
1719  * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2
1720  * port-D 0x12 -> 0x3d -> mix 3, ADC 8
1721  * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4
1722  * port-F 0x16 -> 0x3b -> mix 5, ADC 3
1723  * port-G 0x24 -> N/A  -> 33:1 - mix 1, 34:1 - mix 4, ADC 6
1724  * port-H 0x25 -> N/A  -> 33:2 - mix 1, 34:2 - mix 4, ADC 7
1725  *
1726  *
1727  * DAC assignment
1728  *   6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03
1729  *   3stack - front/surr/CLFE/opt DACs - 04/05/0a/03
1730  *
1731  * Inputs of Analog Mix (0x20)
1732  *   0:Port-B (front mic)
1733  *   1:Port-C/G/H (line-in)
1734  *   2:Port-A
1735  *   3:Port-D (line-in/2)
1736  *   4:Port-E/G/H (mic-in)
1737  *   5:Port-F (mic2-in)
1738  *   6:CD
1739  *   7:Beep
1740  *
1741  * ADC selection
1742  *   0:Port-A
1743  *   1:Port-B (front mic-in)
1744  *   2:Port-C (line-in)
1745  *   3:Port-F (mic2-in)
1746  *   4:Port-E (mic-in)
1747  *   5:CD
1748  *   6:Port-G
1749  *   7:Port-H
1750  *   8:Port-D (line-in/2)
1751  *   9:Mix
1752  *
1753  * Proposed pin assignments by the datasheet
1754  *
1755  * 6-stack
1756  * Port-A front headphone
1757  *      B front mic-in
1758  *      C rear line-in
1759  *      D rear front-out
1760  *      E rear mic-in
1761  *      F rear surround
1762  *      G rear CLFE
1763  *      H rear side
1764  *
1765  * 3-stack
1766  * Port-A front headphone
1767  *      B front mic
1768  *      C rear line-in/surround
1769  *      D rear front-out
1770  *      E rear mic-in/CLFE
1771  *
1772  * laptop
1773  * Port-A headphone
1774  *      B mic-in
1775  *      C docking station
1776  *      D internal speaker (with EAPD)
1777  *      E/F quad mic array
1778  */
1779
1780
1781 /* models */
1782 enum {
1783         AD1988_6STACK,
1784         AD1988_6STACK_DIG,
1785         AD1988_3STACK,
1786         AD1988_3STACK_DIG,
1787         AD1988_LAPTOP,
1788         AD1988_LAPTOP_DIG,
1789         AD1988_AUTO,
1790         AD1988_MODEL_LAST,
1791 };
1792
1793 /* reivision id to check workarounds */
1794 #define AD1988A_REV2            0x100200
1795
1796 #define is_rev2(codec) \
1797         ((codec)->vendor_id == 0x11d41988 && \
1798          (codec)->revision_id == AD1988A_REV2)
1799
1800 /*
1801  * mixers
1802  */
1803
1804 static hda_nid_t ad1988_6stack_dac_nids[4] = {
1805         0x04, 0x06, 0x05, 0x0a
1806 };
1807
1808 static hda_nid_t ad1988_3stack_dac_nids[3] = {
1809         0x04, 0x05, 0x0a
1810 };
1811
1812 /* for AD1988A revision-2, DAC2-4 are swapped */
1813 static hda_nid_t ad1988_6stack_dac_nids_rev2[4] = {
1814         0x04, 0x05, 0x0a, 0x06
1815 };
1816
1817 static hda_nid_t ad1988_3stack_dac_nids_rev2[3] = {
1818         0x04, 0x0a, 0x06
1819 };
1820
1821 static hda_nid_t ad1988_adc_nids[3] = {
1822         0x08, 0x09, 0x0f
1823 };
1824
1825 static hda_nid_t ad1988_capsrc_nids[3] = {
1826         0x0c, 0x0d, 0x0e
1827 };
1828
1829 #define AD1988_SPDIF_OUT                0x02
1830 #define AD1988_SPDIF_OUT_HDMI   0x0b
1831 #define AD1988_SPDIF_IN         0x07
1832
1833 static hda_nid_t ad1989b_slave_dig_outs[2] = {
1834         AD1988_SPDIF_OUT, AD1988_SPDIF_OUT_HDMI
1835 };
1836
1837 static struct hda_input_mux ad1988_6stack_capture_source = {
1838         .num_items = 5,
1839         .items = {
1840                 { "Front Mic", 0x1 },   /* port-B */
1841                 { "Line", 0x2 },        /* port-C */
1842                 { "Mic", 0x4 },         /* port-E */
1843                 { "CD", 0x5 },
1844                 { "Mix", 0x9 },
1845         },
1846 };
1847
1848 static struct hda_input_mux ad1988_laptop_capture_source = {
1849         .num_items = 3,
1850         .items = {
1851                 { "Mic/Line", 0x1 },    /* port-B */
1852                 { "CD", 0x5 },
1853                 { "Mix", 0x9 },
1854         },
1855 };
1856
1857 /*
1858  */
1859 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
1860                                struct snd_ctl_elem_info *uinfo)
1861 {
1862         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1863         struct ad198x_spec *spec = codec->spec;
1864         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
1865                                     spec->num_channel_mode);
1866 }
1867
1868 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
1869                               struct snd_ctl_elem_value *ucontrol)
1870 {
1871         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1872         struct ad198x_spec *spec = codec->spec;
1873         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
1874                                    spec->num_channel_mode, spec->multiout.max_channels);
1875 }
1876
1877 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
1878                               struct snd_ctl_elem_value *ucontrol)
1879 {
1880         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1881         struct ad198x_spec *spec = codec->spec;
1882         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
1883                                       spec->num_channel_mode,
1884                                       &spec->multiout.max_channels);
1885         if (err >= 0 && spec->need_dac_fix)
1886                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
1887         return err;
1888 }
1889
1890 /* 6-stack mode */
1891 static struct snd_kcontrol_new ad1988_6stack_mixers1[] = {
1892         HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1893         HDA_CODEC_VOLUME("Surround Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1894         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
1895         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
1896         HDA_CODEC_VOLUME("Side Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
1897         { } /* end */
1898 };
1899
1900 static struct snd_kcontrol_new ad1988_6stack_mixers1_rev2[] = {
1901         HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1902         HDA_CODEC_VOLUME("Surround Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1903         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
1904         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0a, 2, 0x0, HDA_OUTPUT),
1905         HDA_CODEC_VOLUME("Side Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1906         { } /* end */
1907 };
1908
1909 static struct snd_kcontrol_new ad1988_6stack_mixers2[] = {
1910         HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
1911         HDA_BIND_MUTE("Surround Playback Switch", 0x2a, 2, HDA_INPUT),
1912         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x27, 1, 2, HDA_INPUT),
1913         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x27, 2, 2, HDA_INPUT),
1914         HDA_BIND_MUTE("Side Playback Switch", 0x28, 2, HDA_INPUT),
1915         HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
1916         HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
1917
1918         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
1919         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
1920         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
1921         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
1922         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
1923         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
1924         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
1925         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
1926
1927         HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
1928         HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
1929
1930         HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
1931         HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
1932
1933         HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
1934         HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
1935
1936         { } /* end */
1937 };
1938
1939 /* 3-stack mode */
1940 static struct snd_kcontrol_new ad1988_3stack_mixers1[] = {
1941         HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1942         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
1943         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
1944         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
1945         { } /* end */
1946 };
1947
1948 static struct snd_kcontrol_new ad1988_3stack_mixers1_rev2[] = {
1949         HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1950         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
1951         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x06, 1, 0x0, HDA_OUTPUT),
1952         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x06, 2, 0x0, HDA_OUTPUT),
1953         { } /* end */
1954 };
1955
1956 static struct snd_kcontrol_new ad1988_3stack_mixers2[] = {
1957         HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
1958         HDA_BIND_MUTE("Surround Playback Switch", 0x2c, 2, HDA_INPUT),
1959         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x26, 1, 2, HDA_INPUT),
1960         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x26, 2, 2, HDA_INPUT),
1961         HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
1962         HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
1963
1964         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
1965         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
1966         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
1967         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
1968         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
1969         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
1970         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
1971         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
1972
1973         HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
1974         HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
1975
1976         HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
1977         HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
1978
1979         HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
1980         HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
1981         {
1982                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1983                 .name = "Channel Mode",
1984                 .info = ad198x_ch_mode_info,
1985                 .get = ad198x_ch_mode_get,
1986                 .put = ad198x_ch_mode_put,
1987         },
1988
1989         { } /* end */
1990 };
1991
1992 /* laptop mode */
1993 static struct snd_kcontrol_new ad1988_laptop_mixers[] = {
1994         HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1995         HDA_CODEC_MUTE("PCM Playback Switch", 0x29, 0x0, HDA_INPUT),
1996         HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
1997
1998         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
1999         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2000         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2001         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2002         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2003         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2004
2005         HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
2006         HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
2007
2008         HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2009         HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2010
2011         HDA_CODEC_VOLUME("Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2012
2013         {
2014                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2015                 .name = "External Amplifier",
2016                 .info = ad198x_eapd_info,
2017                 .get = ad198x_eapd_get,
2018                 .put = ad198x_eapd_put,
2019                 .private_value = 0x12 | (1 << 8), /* port-D, inversed */
2020         },
2021
2022         { } /* end */
2023 };
2024
2025 /* capture */
2026 static struct snd_kcontrol_new ad1988_capture_mixers[] = {
2027         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
2028         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
2029         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
2030         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
2031         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x0e, 0x0, HDA_OUTPUT),
2032         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x0e, 0x0, HDA_OUTPUT),
2033         {
2034                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2035                 /* The multiple "Capture Source" controls confuse alsamixer
2036                  * So call somewhat different..
2037                  */
2038                 /* .name = "Capture Source", */
2039                 .name = "Input Source",
2040                 .count = 3,
2041                 .info = ad198x_mux_enum_info,
2042                 .get = ad198x_mux_enum_get,
2043                 .put = ad198x_mux_enum_put,
2044         },
2045         { } /* end */
2046 };
2047
2048 static int ad1988_spdif_playback_source_info(struct snd_kcontrol *kcontrol,
2049                                              struct snd_ctl_elem_info *uinfo)
2050 {
2051         static char *texts[] = {
2052                 "PCM", "ADC1", "ADC2", "ADC3"
2053         };
2054         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2055         uinfo->count = 1;
2056         uinfo->value.enumerated.items = 4;
2057         if (uinfo->value.enumerated.item >= 4)
2058                 uinfo->value.enumerated.item = 3;
2059         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2060         return 0;
2061 }
2062
2063 static int ad1988_spdif_playback_source_get(struct snd_kcontrol *kcontrol,
2064                                             struct snd_ctl_elem_value *ucontrol)
2065 {
2066         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2067         unsigned int sel;
2068
2069         sel = snd_hda_codec_read(codec, 0x1d, 0, AC_VERB_GET_AMP_GAIN_MUTE,
2070                                  AC_AMP_GET_INPUT);
2071         if (!(sel & 0x80))
2072                 ucontrol->value.enumerated.item[0] = 0;
2073         else {
2074                 sel = snd_hda_codec_read(codec, 0x0b, 0,
2075                                          AC_VERB_GET_CONNECT_SEL, 0);
2076                 if (sel < 3)
2077                         sel++;
2078                 else
2079                         sel = 0;
2080                 ucontrol->value.enumerated.item[0] = sel;
2081         }
2082         return 0;
2083 }
2084
2085 static int ad1988_spdif_playback_source_put(struct snd_kcontrol *kcontrol,
2086                                             struct snd_ctl_elem_value *ucontrol)
2087 {
2088         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2089         unsigned int val, sel;
2090         int change;
2091
2092         val = ucontrol->value.enumerated.item[0];
2093         if (val > 3)
2094                 return -EINVAL;
2095         if (!val) {
2096                 sel = snd_hda_codec_read(codec, 0x1d, 0,
2097                                          AC_VERB_GET_AMP_GAIN_MUTE,
2098                                          AC_AMP_GET_INPUT);
2099                 change = sel & 0x80;
2100                 if (change) {
2101                         snd_hda_codec_write_cache(codec, 0x1d, 0,
2102                                                   AC_VERB_SET_AMP_GAIN_MUTE,
2103                                                   AMP_IN_UNMUTE(0));
2104                         snd_hda_codec_write_cache(codec, 0x1d, 0,
2105                                                   AC_VERB_SET_AMP_GAIN_MUTE,
2106                                                   AMP_IN_MUTE(1));
2107                 }
2108         } else {
2109                 sel = snd_hda_codec_read(codec, 0x1d, 0,
2110                                          AC_VERB_GET_AMP_GAIN_MUTE,
2111                                          AC_AMP_GET_INPUT | 0x01);
2112                 change = sel & 0x80;
2113                 if (change) {
2114                         snd_hda_codec_write_cache(codec, 0x1d, 0,
2115                                                   AC_VERB_SET_AMP_GAIN_MUTE,
2116                                                   AMP_IN_MUTE(0));
2117                         snd_hda_codec_write_cache(codec, 0x1d, 0,
2118                                                   AC_VERB_SET_AMP_GAIN_MUTE,
2119                                                   AMP_IN_UNMUTE(1));
2120                 }
2121                 sel = snd_hda_codec_read(codec, 0x0b, 0,
2122                                          AC_VERB_GET_CONNECT_SEL, 0) + 1;
2123                 change |= sel != val;
2124                 if (change)
2125                         snd_hda_codec_write_cache(codec, 0x0b, 0,
2126                                                   AC_VERB_SET_CONNECT_SEL,
2127                                                   val - 1);
2128         }
2129         return change;
2130 }
2131
2132 static struct snd_kcontrol_new ad1988_spdif_out_mixers[] = {
2133         HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2134         {
2135                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2136                 .name = "IEC958 Playback Source",
2137                 .info = ad1988_spdif_playback_source_info,
2138                 .get = ad1988_spdif_playback_source_get,
2139                 .put = ad1988_spdif_playback_source_put,
2140         },
2141         { } /* end */
2142 };
2143
2144 static struct snd_kcontrol_new ad1988_spdif_in_mixers[] = {
2145         HDA_CODEC_VOLUME("IEC958 Capture Volume", 0x1c, 0x0, HDA_INPUT),
2146         { } /* end */
2147 };
2148
2149 static struct snd_kcontrol_new ad1989_spdif_out_mixers[] = {
2150         HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2151         HDA_CODEC_VOLUME("HDMI Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
2152         { } /* end */
2153 };
2154
2155 /*
2156  * initialization verbs
2157  */
2158
2159 /*
2160  * for 6-stack (+dig)
2161  */
2162 static struct hda_verb ad1988_6stack_init_verbs[] = {
2163         /* Front, Surround, CLFE, side DAC; unmute as default */
2164         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2165         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2166         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2167         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2168         /* Port-A front headphon path */
2169         {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2170         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2171         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2172         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2173         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2174         /* Port-D line-out path */
2175         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2176         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2177         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2178         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2179         /* Port-F surround path */
2180         {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2181         {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2182         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2183         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2184         /* Port-G CLFE path */
2185         {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2186         {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2187         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2188         {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2189         /* Port-H side path */
2190         {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2191         {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2192         {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2193         {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2194         /* Mono out path */
2195         {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2196         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2197         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2198         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2199         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2200         /* Port-B front mic-in path */
2201         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2202         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2203         {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2204         /* Port-C line-in path */
2205         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2206         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2207         {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2208         {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2209         /* Port-E mic-in path */
2210         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2211         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2212         {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2213         {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2214         /* Analog CD Input */
2215         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2216         /* Analog Mix output amp */
2217         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2218
2219         { }
2220 };
2221
2222 static struct hda_verb ad1988_capture_init_verbs[] = {
2223         /* mute analog mix */
2224         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2225         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2226         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2227         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2228         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2229         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2230         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2231         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2232         /* select ADCs - front-mic */
2233         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2234         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2235         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2236         /* ADCs; muted */
2237         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2238         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2239         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2240
2241         { }
2242 };
2243
2244 static struct hda_verb ad1988_spdif_init_verbs[] = {
2245         /* SPDIF out sel */
2246         {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
2247         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0}, /* ADC1 */
2248         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2249         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2250         /* SPDIF out pin */
2251         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2252
2253         { }
2254 };
2255
2256 /* AD1989 has no ADC -> SPDIF route */
2257 static struct hda_verb ad1989_spdif_init_verbs[] = {
2258         /* SPDIF-1 out pin */
2259         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2260         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2261         /* SPDIF-2/HDMI out pin */
2262         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2263         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2264         { }
2265 };
2266
2267 /*
2268  * verbs for 3stack (+dig)
2269  */
2270 static struct hda_verb ad1988_3stack_ch2_init[] = {
2271         /* set port-C to line-in */
2272         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2273         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2274         /* set port-E to mic-in */
2275         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2276         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2277         { } /* end */
2278 };
2279
2280 static struct hda_verb ad1988_3stack_ch6_init[] = {
2281         /* set port-C to surround out */
2282         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2283         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2284         /* set port-E to CLFE out */
2285         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2286         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2287         { } /* end */
2288 };
2289
2290 static struct hda_channel_mode ad1988_3stack_modes[2] = {
2291         { 2, ad1988_3stack_ch2_init },
2292         { 6, ad1988_3stack_ch6_init },
2293 };
2294
2295 static struct hda_verb ad1988_3stack_init_verbs[] = {
2296         /* Front, Surround, CLFE, side DAC; unmute as default */
2297         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2298         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2299         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2300         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2301         /* Port-A front headphon path */
2302         {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2303         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2304         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2305         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2306         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2307         /* Port-D line-out path */
2308         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2309         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2310         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2311         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2312         /* Mono out path */
2313         {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2314         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2315         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2316         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2317         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2318         /* Port-B front mic-in path */
2319         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2320         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2321         {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2322         /* Port-C line-in/surround path - 6ch mode as default */
2323         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2324         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2325         {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2326         {0x31, AC_VERB_SET_CONNECT_SEL, 0x0}, /* output sel: DAC 0x05 */
2327         {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2328         /* Port-E mic-in/CLFE path - 6ch mode as default */
2329         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2330         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2331         {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2332         {0x32, AC_VERB_SET_CONNECT_SEL, 0x1}, /* output sel: DAC 0x0a */
2333         {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2334         /* mute analog mix */
2335         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2336         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2337         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2338         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2339         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2340         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2341         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2342         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2343         /* select ADCs - front-mic */
2344         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2345         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2346         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2347         /* ADCs; muted */
2348         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2349         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2350         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2351         /* Analog Mix output amp */
2352         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2353         { }
2354 };
2355
2356 /*
2357  * verbs for laptop mode (+dig)
2358  */
2359 static struct hda_verb ad1988_laptop_hp_on[] = {
2360         /* unmute port-A and mute port-D */
2361         { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2362         { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2363         { } /* end */
2364 };
2365 static struct hda_verb ad1988_laptop_hp_off[] = {
2366         /* mute port-A and unmute port-D */
2367         { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2368         { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2369         { } /* end */
2370 };
2371
2372 #define AD1988_HP_EVENT 0x01
2373
2374 static struct hda_verb ad1988_laptop_init_verbs[] = {
2375         /* Front, Surround, CLFE, side DAC; unmute as default */
2376         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2377         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2378         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2379         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2380         /* Port-A front headphon path */
2381         {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2382         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2383         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2384         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2385         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2386         /* unsolicited event for pin-sense */
2387         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1988_HP_EVENT },
2388         /* Port-D line-out path + EAPD */
2389         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2390         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2391         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2392         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2393         {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x00}, /* EAPD-off */
2394         /* Mono out path */
2395         {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2396         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2397         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2398         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2399         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2400         /* Port-B mic-in path */
2401         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2402         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2403         {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2404         /* Port-C docking station - try to output */
2405         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2406         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2407         {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2408         {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2409         /* mute analog mix */
2410         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2411         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2412         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2413         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2414         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2415         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2416         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2417         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2418         /* select ADCs - mic */
2419         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2420         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2421         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2422         /* ADCs; muted */
2423         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2424         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2425         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2426         /* Analog Mix output amp */
2427         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2428         { }
2429 };
2430
2431 static void ad1988_laptop_unsol_event(struct hda_codec *codec, unsigned int res)
2432 {
2433         if ((res >> 26) != AD1988_HP_EVENT)
2434                 return;
2435         if (snd_hda_codec_read(codec, 0x11, 0, AC_VERB_GET_PIN_SENSE, 0) & (1 << 31))
2436                 snd_hda_sequence_write(codec, ad1988_laptop_hp_on);
2437         else
2438                 snd_hda_sequence_write(codec, ad1988_laptop_hp_off);
2439 }
2440
2441 #ifdef CONFIG_SND_HDA_POWER_SAVE
2442 static struct hda_amp_list ad1988_loopbacks[] = {
2443         { 0x20, HDA_INPUT, 0 }, /* Front Mic */
2444         { 0x20, HDA_INPUT, 1 }, /* Line */
2445         { 0x20, HDA_INPUT, 4 }, /* Mic */
2446         { 0x20, HDA_INPUT, 6 }, /* CD */
2447         { } /* end */
2448 };
2449 #endif
2450
2451 /*
2452  * Automatic parse of I/O pins from the BIOS configuration
2453  */
2454
2455 #define NUM_CONTROL_ALLOC       32
2456 #define NUM_VERB_ALLOC          32
2457
2458 enum {
2459         AD_CTL_WIDGET_VOL,
2460         AD_CTL_WIDGET_MUTE,
2461         AD_CTL_BIND_MUTE,
2462 };
2463 static struct snd_kcontrol_new ad1988_control_templates[] = {
2464         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2465         HDA_CODEC_MUTE(NULL, 0, 0, 0),
2466         HDA_BIND_MUTE(NULL, 0, 0, 0),
2467 };
2468
2469 /* add dynamic controls */
2470 static int add_control(struct ad198x_spec *spec, int type, const char *name,
2471                        unsigned long val)
2472 {
2473         struct snd_kcontrol_new *knew;
2474
2475         if (spec->num_kctl_used >= spec->num_kctl_alloc) {
2476                 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
2477
2478                 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
2479                 if (! knew)
2480                         return -ENOMEM;
2481                 if (spec->kctl_alloc) {
2482                         memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
2483                         kfree(spec->kctl_alloc);
2484                 }
2485                 spec->kctl_alloc = knew;
2486                 spec->num_kctl_alloc = num;
2487         }
2488
2489         knew = &spec->kctl_alloc[spec->num_kctl_used];
2490         *knew = ad1988_control_templates[type];
2491         knew->name = kstrdup(name, GFP_KERNEL);
2492         if (! knew->name)
2493                 return -ENOMEM;
2494         knew->private_value = val;
2495         spec->num_kctl_used++;
2496         return 0;
2497 }
2498
2499 #define AD1988_PIN_CD_NID               0x18
2500 #define AD1988_PIN_BEEP_NID             0x10
2501
2502 static hda_nid_t ad1988_mixer_nids[8] = {
2503         /* A     B     C     D     E     F     G     H */
2504         0x22, 0x2b, 0x2c, 0x29, 0x26, 0x2a, 0x27, 0x28
2505 };
2506
2507 static inline hda_nid_t ad1988_idx_to_dac(struct hda_codec *codec, int idx)
2508 {
2509         static hda_nid_t idx_to_dac[8] = {
2510                 /* A     B     C     D     E     F     G     H */
2511                 0x04, 0x06, 0x05, 0x04, 0x0a, 0x06, 0x05, 0x0a
2512         };
2513         static hda_nid_t idx_to_dac_rev2[8] = {
2514                 /* A     B     C     D     E     F     G     H */
2515                 0x04, 0x05, 0x0a, 0x04, 0x06, 0x05, 0x0a, 0x06
2516         };
2517         if (is_rev2(codec))
2518                 return idx_to_dac_rev2[idx];
2519         else
2520                 return idx_to_dac[idx];
2521 }
2522
2523 static hda_nid_t ad1988_boost_nids[8] = {
2524         0x38, 0x39, 0x3a, 0x3d, 0x3c, 0x3b, 0, 0
2525 };
2526
2527 static int ad1988_pin_idx(hda_nid_t nid)
2528 {
2529         static hda_nid_t ad1988_io_pins[8] = {
2530                 0x11, 0x14, 0x15, 0x12, 0x17, 0x16, 0x24, 0x25
2531         };
2532         int i;
2533         for (i = 0; i < ARRAY_SIZE(ad1988_io_pins); i++)
2534                 if (ad1988_io_pins[i] == nid)
2535                         return i;
2536         return 0; /* should be -1 */
2537 }
2538
2539 static int ad1988_pin_to_loopback_idx(hda_nid_t nid)
2540 {
2541         static int loopback_idx[8] = {
2542                 2, 0, 1, 3, 4, 5, 1, 4
2543         };
2544         switch (nid) {
2545         case AD1988_PIN_CD_NID:
2546                 return 6;
2547         default:
2548                 return loopback_idx[ad1988_pin_idx(nid)];
2549         }
2550 }
2551
2552 static int ad1988_pin_to_adc_idx(hda_nid_t nid)
2553 {
2554         static int adc_idx[8] = {
2555                 0, 1, 2, 8, 4, 3, 6, 7
2556         };
2557         switch (nid) {
2558         case AD1988_PIN_CD_NID:
2559                 return 5;
2560         default:
2561                 return adc_idx[ad1988_pin_idx(nid)];
2562         }
2563 }
2564
2565 /* fill in the dac_nids table from the parsed pin configuration */
2566 static int ad1988_auto_fill_dac_nids(struct hda_codec *codec,
2567                                      const struct auto_pin_cfg *cfg)
2568 {
2569         struct ad198x_spec *spec = codec->spec;
2570         int i, idx;
2571
2572         spec->multiout.dac_nids = spec->private_dac_nids;
2573
2574         /* check the pins hardwired to audio widget */
2575         for (i = 0; i < cfg->line_outs; i++) {
2576                 idx = ad1988_pin_idx(cfg->line_out_pins[i]);
2577                 spec->multiout.dac_nids[i] = ad1988_idx_to_dac(codec, idx);
2578         }
2579         spec->multiout.num_dacs = cfg->line_outs;
2580         return 0;
2581 }
2582
2583 /* add playback controls from the parsed DAC table */
2584 static int ad1988_auto_create_multi_out_ctls(struct ad198x_spec *spec,
2585                                              const struct auto_pin_cfg *cfg)
2586 {
2587         char name[32];
2588         static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
2589         hda_nid_t nid;
2590         int i, err;
2591
2592         for (i = 0; i < cfg->line_outs; i++) {
2593                 hda_nid_t dac = spec->multiout.dac_nids[i];
2594                 if (! dac)
2595                         continue;
2596                 nid = ad1988_mixer_nids[ad1988_pin_idx(cfg->line_out_pins[i])];
2597                 if (i == 2) {
2598                         /* Center/LFE */
2599                         err = add_control(spec, AD_CTL_WIDGET_VOL,
2600                                           "Center Playback Volume",
2601                                           HDA_COMPOSE_AMP_VAL(dac, 1, 0, HDA_OUTPUT));
2602                         if (err < 0)
2603                                 return err;
2604                         err = add_control(spec, AD_CTL_WIDGET_VOL,
2605                                           "LFE Playback Volume",
2606                                           HDA_COMPOSE_AMP_VAL(dac, 2, 0, HDA_OUTPUT));
2607                         if (err < 0)
2608                                 return err;
2609                         err = add_control(spec, AD_CTL_BIND_MUTE,
2610                                           "Center Playback Switch",
2611                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT));
2612                         if (err < 0)
2613                                 return err;
2614                         err = add_control(spec, AD_CTL_BIND_MUTE,
2615                                           "LFE Playback Switch",
2616                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT));
2617                         if (err < 0)
2618                                 return err;
2619                 } else {
2620                         sprintf(name, "%s Playback Volume", chname[i]);
2621                         err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2622                                           HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT));
2623                         if (err < 0)
2624                                 return err;
2625                         sprintf(name, "%s Playback Switch", chname[i]);
2626                         err = add_control(spec, AD_CTL_BIND_MUTE, name,
2627                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
2628                         if (err < 0)
2629                                 return err;
2630                 }
2631         }
2632         return 0;
2633 }
2634
2635 /* add playback controls for speaker and HP outputs */
2636 static int ad1988_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
2637                                         const char *pfx)
2638 {
2639         struct ad198x_spec *spec = codec->spec;
2640         hda_nid_t nid;
2641         int i, idx, err;
2642         char name[32];
2643
2644         if (! pin)
2645                 return 0;
2646
2647         idx = ad1988_pin_idx(pin);
2648         nid = ad1988_idx_to_dac(codec, idx);
2649         /* check whether the corresponding DAC was already taken */
2650         for (i = 0; i < spec->autocfg.line_outs; i++) {
2651                 hda_nid_t pin = spec->autocfg.line_out_pins[i];
2652                 hda_nid_t dac = ad1988_idx_to_dac(codec, ad1988_pin_idx(pin));
2653                 if (dac == nid)
2654                         break;
2655         }
2656         if (i >= spec->autocfg.line_outs) {
2657                 /* specify the DAC as the extra output */
2658                 if (!spec->multiout.hp_nid)
2659                         spec->multiout.hp_nid = nid;
2660                 else
2661                         spec->multiout.extra_out_nid[0] = nid;
2662                 /* control HP volume/switch on the output mixer amp */
2663                 sprintf(name, "%s Playback Volume", pfx);
2664                 err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2665                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
2666                 if (err < 0)
2667                         return err;
2668         }
2669         nid = ad1988_mixer_nids[idx];
2670         sprintf(name, "%s Playback Switch", pfx);
2671         if ((err = add_control(spec, AD_CTL_BIND_MUTE, name,
2672                                HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
2673                 return err;
2674         return 0;
2675 }
2676
2677 /* create input playback/capture controls for the given pin */
2678 static int new_analog_input(struct ad198x_spec *spec, hda_nid_t pin,
2679                             const char *ctlname, int boost)
2680 {
2681         char name[32];
2682         int err, idx;
2683
2684         sprintf(name, "%s Playback Volume", ctlname);
2685         idx = ad1988_pin_to_loopback_idx(pin);
2686         if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2687                                HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2688                 return err;
2689         sprintf(name, "%s Playback Switch", ctlname);
2690         if ((err = add_control(spec, AD_CTL_WIDGET_MUTE, name,
2691                                HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2692                 return err;
2693         if (boost) {
2694                 hda_nid_t bnid;
2695                 idx = ad1988_pin_idx(pin);
2696                 bnid = ad1988_boost_nids[idx];
2697                 if (bnid) {
2698                         sprintf(name, "%s Boost", ctlname);
2699                         return add_control(spec, AD_CTL_WIDGET_VOL, name,
2700                                            HDA_COMPOSE_AMP_VAL(bnid, 3, idx, HDA_OUTPUT));
2701
2702                 }
2703         }
2704         return 0;
2705 }
2706
2707 /* create playback/capture controls for input pins */
2708 static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec,
2709                                                 const struct auto_pin_cfg *cfg)
2710 {
2711         struct hda_input_mux *imux = &spec->private_imux;
2712         int i, err;
2713
2714         for (i = 0; i < AUTO_PIN_LAST; i++) {
2715                 err = new_analog_input(spec, cfg->input_pins[i],
2716                                        auto_pin_cfg_labels[i],
2717                                        i <= AUTO_PIN_FRONT_MIC);
2718                 if (err < 0)
2719                         return err;
2720                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2721                 imux->items[imux->num_items].index = ad1988_pin_to_adc_idx(cfg->input_pins[i]);
2722                 imux->num_items++;
2723         }
2724         imux->items[imux->num_items].label = "Mix";
2725         imux->items[imux->num_items].index = 9;
2726         imux->num_items++;
2727
2728         if ((err = add_control(spec, AD_CTL_WIDGET_VOL,
2729                                "Analog Mix Playback Volume",
2730                                HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2731                 return err;
2732         if ((err = add_control(spec, AD_CTL_WIDGET_MUTE,
2733                                "Analog Mix Playback Switch",
2734                                HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2735                 return err;
2736
2737         return 0;
2738 }
2739
2740 static void ad1988_auto_set_output_and_unmute(struct hda_codec *codec,
2741                                               hda_nid_t nid, int pin_type,
2742                                               int dac_idx)
2743 {
2744         /* set as output */
2745         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2746         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
2747         switch (nid) {
2748         case 0x11: /* port-A - DAC 04 */
2749                 snd_hda_codec_write(codec, 0x37, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2750                 break;
2751         case 0x14: /* port-B - DAC 06 */
2752                 snd_hda_codec_write(codec, 0x30, 0, AC_VERB_SET_CONNECT_SEL, 0x02);
2753                 break;
2754         case 0x15: /* port-C - DAC 05 */
2755                 snd_hda_codec_write(codec, 0x31, 0, AC_VERB_SET_CONNECT_SEL, 0x00);
2756                 break;
2757         case 0x17: /* port-E - DAC 0a */
2758                 snd_hda_codec_write(codec, 0x32, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2759                 break;
2760         case 0x13: /* mono - DAC 04 */
2761                 snd_hda_codec_write(codec, 0x36, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2762                 break;
2763         }
2764 }
2765
2766 static void ad1988_auto_init_multi_out(struct hda_codec *codec)
2767 {
2768         struct ad198x_spec *spec = codec->spec;
2769         int i;
2770
2771         for (i = 0; i < spec->autocfg.line_outs; i++) {
2772                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2773                 ad1988_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
2774         }
2775 }
2776
2777 static void ad1988_auto_init_extra_out(struct hda_codec *codec)
2778 {
2779         struct ad198x_spec *spec = codec->spec;
2780         hda_nid_t pin;
2781
2782         pin = spec->autocfg.speaker_pins[0];
2783         if (pin) /* connect to front */
2784                 ad1988_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
2785         pin = spec->autocfg.hp_pins[0];
2786         if (pin) /* connect to front */
2787                 ad1988_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
2788 }
2789
2790 static void ad1988_auto_init_analog_input(struct hda_codec *codec)
2791 {
2792         struct ad198x_spec *spec = codec->spec;
2793         int i, idx;
2794
2795         for (i = 0; i < AUTO_PIN_LAST; i++) {
2796                 hda_nid_t nid = spec->autocfg.input_pins[i];
2797                 if (! nid)
2798                         continue;
2799                 switch (nid) {
2800                 case 0x15: /* port-C */
2801                         snd_hda_codec_write(codec, 0x33, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
2802                         break;
2803                 case 0x17: /* port-E */
2804                         snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
2805                         break;
2806                 }
2807                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2808                                     i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
2809                 if (nid != AD1988_PIN_CD_NID)
2810                         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2811                                             AMP_OUT_MUTE);
2812                 idx = ad1988_pin_idx(nid);
2813                 if (ad1988_boost_nids[idx])
2814                         snd_hda_codec_write(codec, ad1988_boost_nids[idx], 0,
2815                                             AC_VERB_SET_AMP_GAIN_MUTE,
2816                                             AMP_OUT_ZERO);
2817         }
2818 }
2819
2820 /* parse the BIOS configuration and set up the alc_spec */
2821 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
2822 static int ad1988_parse_auto_config(struct hda_codec *codec)
2823 {
2824         struct ad198x_spec *spec = codec->spec;
2825         int err;
2826
2827         if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2828                 return err;
2829         if ((err = ad1988_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2830                 return err;
2831         if (! spec->autocfg.line_outs)
2832                 return 0; /* can't find valid BIOS pin config */
2833         if ((err = ad1988_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
2834             (err = ad1988_auto_create_extra_out(codec,
2835                                                 spec->autocfg.speaker_pins[0],
2836                                                 "Speaker")) < 0 ||
2837             (err = ad1988_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
2838                                                 "Headphone")) < 0 ||
2839             (err = ad1988_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
2840                 return err;
2841
2842         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2843
2844         if (spec->autocfg.dig_out_pin)
2845                 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2846         if (spec->autocfg.dig_in_pin)
2847                 spec->dig_in_nid = AD1988_SPDIF_IN;
2848
2849         if (spec->kctl_alloc)
2850                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2851
2852         spec->init_verbs[spec->num_init_verbs++] = ad1988_6stack_init_verbs;
2853
2854         spec->input_mux = &spec->private_imux;
2855
2856         return 1;
2857 }
2858
2859 /* init callback for auto-configuration model -- overriding the default init */
2860 static int ad1988_auto_init(struct hda_codec *codec)
2861 {
2862         ad198x_init(codec);
2863         ad1988_auto_init_multi_out(codec);
2864         ad1988_auto_init_extra_out(codec);
2865         ad1988_auto_init_analog_input(codec);
2866         return 0;
2867 }
2868
2869
2870 /*
2871  */
2872
2873 static const char *ad1988_models[AD1988_MODEL_LAST] = {
2874         [AD1988_6STACK]         = "6stack",
2875         [AD1988_6STACK_DIG]     = "6stack-dig",
2876         [AD1988_3STACK]         = "3stack",
2877         [AD1988_3STACK_DIG]     = "3stack-dig",
2878         [AD1988_LAPTOP]         = "laptop",
2879         [AD1988_LAPTOP_DIG]     = "laptop-dig",
2880         [AD1988_AUTO]           = "auto",
2881 };
2882
2883 static struct snd_pci_quirk ad1988_cfg_tbl[] = {
2884         SND_PCI_QUIRK(0x1043, 0x81ec, "Asus P5B-DLX", AD1988_6STACK_DIG),
2885         SND_PCI_QUIRK(0x1043, 0x81f6, "Asus M2N-SLI", AD1988_6STACK_DIG),
2886         SND_PCI_QUIRK(0x1043, 0x8277, "Asus P5K-E/WIFI-AP", AD1988_6STACK_DIG),
2887         SND_PCI_QUIRK(0x1043, 0x8311, "Asus P5Q-Premium/Pro", AD1988_6STACK_DIG),
2888         {}
2889 };
2890
2891 static int patch_ad1988(struct hda_codec *codec)
2892 {
2893         struct ad198x_spec *spec;
2894         int board_config;
2895
2896         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2897         if (spec == NULL)
2898                 return -ENOMEM;
2899
2900         codec->spec = spec;
2901
2902         if (is_rev2(codec))
2903                 snd_printk(KERN_INFO "patch_analog: AD1988A rev.2 is detected, enable workarounds\n");
2904
2905         board_config = snd_hda_check_board_config(codec, AD1988_MODEL_LAST,
2906                                                   ad1988_models, ad1988_cfg_tbl);
2907         if (board_config < 0) {
2908                 printk(KERN_INFO "hda_codec: Unknown model for AD1988, trying auto-probe from BIOS...\n");
2909                 board_config = AD1988_AUTO;
2910         }
2911
2912         if (board_config == AD1988_AUTO) {
2913                 /* automatic parse from the BIOS config */
2914                 int err = ad1988_parse_auto_config(codec);
2915                 if (err < 0) {
2916                         ad198x_free(codec);
2917                         return err;
2918                 } else if (! err) {
2919                         printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using 6-stack mode...\n");
2920                         board_config = AD1988_6STACK;
2921                 }
2922         }
2923
2924         switch (board_config) {
2925         case AD1988_6STACK:
2926         case AD1988_6STACK_DIG:
2927                 spec->multiout.max_channels = 8;
2928                 spec->multiout.num_dacs = 4;
2929                 if (is_rev2(codec))
2930                         spec->multiout.dac_nids = ad1988_6stack_dac_nids_rev2;
2931                 else
2932                         spec->multiout.dac_nids = ad1988_6stack_dac_nids;
2933                 spec->input_mux = &ad1988_6stack_capture_source;
2934                 spec->num_mixers = 2;
2935                 if (is_rev2(codec))
2936                         spec->mixers[0] = ad1988_6stack_mixers1_rev2;
2937                 else
2938                         spec->mixers[0] = ad1988_6stack_mixers1;
2939                 spec->mixers[1] = ad1988_6stack_mixers2;
2940                 spec->num_init_verbs = 1;
2941                 spec->init_verbs[0] = ad1988_6stack_init_verbs;
2942                 if (board_config == AD1988_6STACK_DIG) {
2943                         spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2944                         spec->dig_in_nid = AD1988_SPDIF_IN;
2945                 }
2946                 break;
2947         case AD1988_3STACK:
2948         case AD1988_3STACK_DIG:
2949                 spec->multiout.max_channels = 6;
2950                 spec->multiout.num_dacs = 3;
2951                 if (is_rev2(codec))
2952                         spec->multiout.dac_nids = ad1988_3stack_dac_nids_rev2;
2953                 else
2954                         spec->multiout.dac_nids = ad1988_3stack_dac_nids;
2955                 spec->input_mux = &ad1988_6stack_capture_source;
2956                 spec->channel_mode = ad1988_3stack_modes;
2957                 spec->num_channel_mode = ARRAY_SIZE(ad1988_3stack_modes);
2958                 spec->num_mixers = 2;
2959                 if (is_rev2(codec))
2960                         spec->mixers[0] = ad1988_3stack_mixers1_rev2;
2961                 else
2962                         spec->mixers[0] = ad1988_3stack_mixers1;
2963                 spec->mixers[1] = ad1988_3stack_mixers2;
2964                 spec->num_init_verbs = 1;
2965                 spec->init_verbs[0] = ad1988_3stack_init_verbs;
2966                 if (board_config == AD1988_3STACK_DIG)
2967                         spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2968                 break;
2969         case AD1988_LAPTOP:
2970         case AD1988_LAPTOP_DIG:
2971                 spec->multiout.max_channels = 2;
2972                 spec->multiout.num_dacs = 1;
2973                 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
2974                 spec->input_mux = &ad1988_laptop_capture_source;
2975                 spec->num_mixers = 1;
2976                 spec->mixers[0] = ad1988_laptop_mixers;
2977                 spec->num_init_verbs = 1;
2978                 spec->init_verbs[0] = ad1988_laptop_init_verbs;
2979                 if (board_config == AD1988_LAPTOP_DIG)
2980                         spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2981                 break;
2982         }
2983
2984         spec->num_adc_nids = ARRAY_SIZE(ad1988_adc_nids);
2985         spec->adc_nids = ad1988_adc_nids;
2986         spec->capsrc_nids = ad1988_capsrc_nids;
2987         spec->mixers[spec->num_mixers++] = ad1988_capture_mixers;
2988         spec->init_verbs[spec->num_init_verbs++] = ad1988_capture_init_verbs;
2989         if (spec->multiout.dig_out_nid) {
2990                 if (codec->vendor_id >= 0x11d4989a) {
2991                         spec->mixers[spec->num_mixers++] =
2992                                 ad1989_spdif_out_mixers;
2993                         spec->init_verbs[spec->num_init_verbs++] =
2994                                 ad1989_spdif_init_verbs;
2995                         codec->slave_dig_outs = ad1989b_slave_dig_outs;
2996                 } else {
2997                         spec->mixers[spec->num_mixers++] =
2998                                 ad1988_spdif_out_mixers;
2999                         spec->init_verbs[spec->num_init_verbs++] =
3000                                 ad1988_spdif_init_verbs;
3001                 }
3002         }
3003         if (spec->dig_in_nid && codec->vendor_id < 0x11d4989a)
3004                 spec->mixers[spec->num_mixers++] = ad1988_spdif_in_mixers;
3005
3006         codec->patch_ops = ad198x_patch_ops;
3007         switch (board_config) {
3008         case AD1988_AUTO:
3009                 codec->patch_ops.init = ad1988_auto_init;
3010                 break;
3011         case AD1988_LAPTOP:
3012         case AD1988_LAPTOP_DIG:
3013                 codec->patch_ops.unsol_event = ad1988_laptop_unsol_event;
3014                 break;
3015         }
3016 #ifdef CONFIG_SND_HDA_POWER_SAVE
3017         spec->loopback.amplist = ad1988_loopbacks;
3018 #endif
3019         spec->vmaster_nid = 0x04;
3020
3021         return 0;
3022 }
3023
3024
3025 /*
3026  * AD1884 / AD1984
3027  *
3028  * port-B - front line/mic-in
3029  * port-E - aux in/out
3030  * port-F - aux in/out
3031  * port-C - rear line/mic-in
3032  * port-D - rear line/hp-out
3033  * port-A - front line/hp-out
3034  *
3035  * AD1984 = AD1884 + two digital mic-ins
3036  *
3037  * FIXME:
3038  * For simplicity, we share the single DAC for both HP and line-outs
3039  * right now.  The inidividual playbacks could be easily implemented,
3040  * but no build-up framework is given, so far.
3041  */
3042
3043 static hda_nid_t ad1884_dac_nids[1] = {
3044         0x04,
3045 };
3046
3047 static hda_nid_t ad1884_adc_nids[2] = {
3048         0x08, 0x09,
3049 };
3050
3051 static hda_nid_t ad1884_capsrc_nids[2] = {
3052         0x0c, 0x0d,
3053 };
3054
3055 #define AD1884_SPDIF_OUT        0x02
3056
3057 static struct hda_input_mux ad1884_capture_source = {
3058         .num_items = 4,
3059         .items = {
3060                 { "Front Mic", 0x0 },
3061                 { "Mic", 0x1 },
3062                 { "CD", 0x2 },
3063                 { "Mix", 0x3 },
3064         },
3065 };
3066
3067 static struct snd_kcontrol_new ad1884_base_mixers[] = {
3068         HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3069         /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3070         HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3071         HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3072         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3073         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3074         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3075         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3076         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3077         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3078         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
3079         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
3080         /*
3081         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x20, 0x03, HDA_INPUT),
3082         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x20, 0x03, HDA_INPUT),
3083         HDA_CODEC_VOLUME("Digital Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
3084         HDA_CODEC_MUTE("Digital Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
3085         */
3086         HDA_CODEC_VOLUME("Mic Boost", 0x15, 0x0, HDA_INPUT),
3087         HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3088         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3089         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3090         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3091         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3092         {
3093                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3094                 /* The multiple "Capture Source" controls confuse alsamixer
3095                  * So call somewhat different..
3096                  */
3097                 /* .name = "Capture Source", */
3098                 .name = "Input Source",
3099                 .count = 2,
3100                 .info = ad198x_mux_enum_info,
3101                 .get = ad198x_mux_enum_get,
3102                 .put = ad198x_mux_enum_put,
3103         },
3104         /* SPDIF controls */
3105         HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3106         {
3107                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3108                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3109                 /* identical with ad1983 */
3110                 .info = ad1983_spdif_route_info,
3111                 .get = ad1983_spdif_route_get,
3112                 .put = ad1983_spdif_route_put,
3113         },
3114         { } /* end */
3115 };
3116
3117 static struct snd_kcontrol_new ad1984_dmic_mixers[] = {
3118         HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x05, 0x0, HDA_INPUT),
3119         HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x05, 0x0, HDA_INPUT),
3120         HDA_CODEC_VOLUME_IDX("Digital Mic Capture Volume", 1, 0x06, 0x0,
3121                              HDA_INPUT),
3122         HDA_CODEC_MUTE_IDX("Digital Mic Capture Switch", 1, 0x06, 0x0,
3123                            HDA_INPUT),
3124         { } /* end */
3125 };
3126
3127 /*
3128  * initialization verbs
3129  */
3130 static struct hda_verb ad1884_init_verbs[] = {
3131         /* DACs; mute as default */
3132         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3133         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3134         /* Port-A (HP) mixer */
3135         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3136         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3137         /* Port-A pin */
3138         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3139         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3140         /* HP selector - select DAC2 */
3141         {0x22, AC_VERB_SET_CONNECT_SEL, 0x1},
3142         /* Port-D (Line-out) mixer */
3143         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3144         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3145         /* Port-D pin */
3146         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3147         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3148         /* Mono-out mixer */
3149         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3150         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3151         /* Mono-out pin */
3152         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3153         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3154         /* Mono selector */
3155         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
3156         /* Port-B (front mic) pin */
3157         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3158         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3159         /* Port-C (rear mic) pin */
3160         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3161         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3162         /* Analog mixer; mute as default */
3163         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3164         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3165         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3166         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3167         /* Analog Mix output amp */
3168         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
3169         /* SPDIF output selector */
3170         {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
3171         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3172         { } /* end */
3173 };
3174
3175 #ifdef CONFIG_SND_HDA_POWER_SAVE
3176 static struct hda_amp_list ad1884_loopbacks[] = {
3177         { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3178         { 0x20, HDA_INPUT, 1 }, /* Mic */
3179         { 0x20, HDA_INPUT, 2 }, /* CD */
3180         { 0x20, HDA_INPUT, 4 }, /* Docking */
3181         { } /* end */
3182 };
3183 #endif
3184
3185 static const char *ad1884_slave_vols[] = {
3186         "PCM Playback Volume",
3187         "Mic Playback Volume",
3188         "Mono Playback Volume",
3189         "Front Mic Playback Volume",
3190         "Mic Playback Volume",
3191         "CD Playback Volume",
3192         "Internal Mic Playback Volume",
3193         "Docking Mic Playback Volume"
3194         "Beep Playback Volume",
3195         "IEC958 Playback Volume",
3196         NULL
3197 };
3198
3199 static int patch_ad1884(struct hda_codec *codec)
3200 {
3201         struct ad198x_spec *spec;
3202
3203         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3204         if (spec == NULL)
3205                 return -ENOMEM;
3206
3207         codec->spec = spec;
3208
3209         spec->multiout.max_channels = 2;
3210         spec->multiout.num_dacs = ARRAY_SIZE(ad1884_dac_nids);
3211         spec->multiout.dac_nids = ad1884_dac_nids;
3212         spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3213         spec->num_adc_nids = ARRAY_SIZE(ad1884_adc_nids);
3214         spec->adc_nids = ad1884_adc_nids;
3215         spec->capsrc_nids = ad1884_capsrc_nids;
3216         spec->input_mux = &ad1884_capture_source;
3217         spec->num_mixers = 1;
3218         spec->mixers[0] = ad1884_base_mixers;
3219         spec->num_init_verbs = 1;
3220         spec->init_verbs[0] = ad1884_init_verbs;
3221         spec->spdif_route = 0;
3222 #ifdef CONFIG_SND_HDA_POWER_SAVE
3223         spec->loopback.amplist = ad1884_loopbacks;
3224 #endif
3225         spec->vmaster_nid = 0x04;
3226         /* we need to cover all playback volumes */
3227         spec->slave_vols = ad1884_slave_vols;
3228
3229         codec->patch_ops = ad198x_patch_ops;
3230
3231         return 0;
3232 }
3233
3234 /*
3235  * Lenovo Thinkpad T61/X61
3236  */
3237 static struct hda_input_mux ad1984_thinkpad_capture_source = {
3238         .num_items = 4,
3239         .items = {
3240                 { "Mic", 0x0 },
3241                 { "Internal Mic", 0x1 },
3242                 { "Mix", 0x3 },
3243                 { "Docking-Station", 0x4 },
3244         },
3245 };
3246
3247
3248 /*
3249  * Dell Precision T3400
3250  */
3251 static struct hda_input_mux ad1984_dell_desktop_capture_source = {
3252         .num_items = 3,
3253         .items = {
3254                 { "Front Mic", 0x0 },
3255                 { "Line-In", 0x1 },
3256                 { "Mix", 0x3 },
3257         },
3258 };
3259
3260
3261 static struct snd_kcontrol_new ad1984_thinkpad_mixers[] = {
3262         HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3263         /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3264         HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3265         HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3266         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3267         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3268         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3269         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3270         HDA_CODEC_VOLUME("Docking Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3271         HDA_CODEC_MUTE("Docking Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3272         HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
3273         HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT),
3274         HDA_CODEC_VOLUME("Docking Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3275         HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
3276         HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
3277         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3278         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3279         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3280         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3281         {
3282                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3283                 /* The multiple "Capture Source" controls confuse alsamixer
3284                  * So call somewhat different..
3285                  */
3286                 /* .name = "Capture Source", */
3287                 .name = "Input Source",
3288                 .count = 2,
3289                 .info = ad198x_mux_enum_info,
3290                 .get = ad198x_mux_enum_get,
3291                 .put = ad198x_mux_enum_put,
3292         },
3293         /* SPDIF controls */
3294         HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3295         {
3296                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3297                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3298                 /* identical with ad1983 */
3299                 .info = ad1983_spdif_route_info,
3300                 .get = ad1983_spdif_route_get,
3301                 .put = ad1983_spdif_route_put,
3302         },
3303         { } /* end */
3304 };
3305
3306 /* additional verbs */
3307 static struct hda_verb ad1984_thinkpad_init_verbs[] = {
3308         /* Port-E (docking station mic) pin */
3309         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3310         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3311         /* docking mic boost */
3312         {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3313         /* Analog mixer - docking mic; mute as default */
3314         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3315         /* enable EAPD bit */
3316         {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
3317         { } /* end */
3318 };
3319
3320 /*
3321  * Dell Precision T3400
3322  */
3323 static struct snd_kcontrol_new ad1984_dell_desktop_mixers[] = {
3324         HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3325         HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3326         HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3327         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3328         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3329         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3330         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3331         HDA_CODEC_VOLUME("Line-In Playback Volume", 0x20, 0x01, HDA_INPUT),
3332         HDA_CODEC_MUTE("Line-In Playback Switch", 0x20, 0x01, HDA_INPUT),
3333         /*
3334         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x20, 0x03, HDA_INPUT),
3335         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x20, 0x03, HDA_INPUT),
3336         */
3337         HDA_CODEC_VOLUME("Line-In Boost", 0x15, 0x0, HDA_INPUT),
3338         HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3339         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3340         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3341         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3342         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3343         {
3344                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3345                 /* The multiple "Capture Source" controls confuse alsamixer
3346                  * So call somewhat different..
3347                  */
3348                 /* .name = "Capture Source", */
3349                 .name = "Input Source",
3350                 .count = 2,
3351                 .info = ad198x_mux_enum_info,
3352                 .get = ad198x_mux_enum_get,
3353                 .put = ad198x_mux_enum_put,
3354         },
3355         { } /* end */
3356 };
3357
3358 /* Digial MIC ADC NID 0x05 + 0x06 */
3359 static int ad1984_pcm_dmic_prepare(struct hda_pcm_stream *hinfo,
3360                                    struct hda_codec *codec,
3361                                    unsigned int stream_tag,
3362                                    unsigned int format,
3363                                    struct snd_pcm_substream *substream)
3364 {
3365         snd_hda_codec_setup_stream(codec, 0x05 + substream->number,
3366                                    stream_tag, 0, format);
3367         return 0;
3368 }
3369
3370 static int ad1984_pcm_dmic_cleanup(struct hda_pcm_stream *hinfo,
3371                                    struct hda_codec *codec,
3372                                    struct snd_pcm_substream *substream)
3373 {
3374         snd_hda_codec_cleanup_stream(codec, 0x05 + substream->number);
3375         return 0;
3376 }
3377
3378 static struct hda_pcm_stream ad1984_pcm_dmic_capture = {
3379         .substreams = 2,
3380         .channels_min = 2,
3381         .channels_max = 2,
3382         .nid = 0x05,
3383         .ops = {
3384                 .prepare = ad1984_pcm_dmic_prepare,
3385                 .cleanup = ad1984_pcm_dmic_cleanup
3386         },
3387 };
3388
3389 static int ad1984_build_pcms(struct hda_codec *codec)
3390 {
3391         struct ad198x_spec *spec = codec->spec;
3392         struct hda_pcm *info;
3393         int err;
3394
3395         err = ad198x_build_pcms(codec);
3396         if (err < 0)
3397                 return err;
3398
3399         info = spec->pcm_rec + codec->num_pcms;
3400         codec->num_pcms++;
3401         info->name = "AD1984 Digital Mic";
3402         info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad1984_pcm_dmic_capture;
3403         return 0;
3404 }
3405
3406 /* models */
3407 enum {
3408         AD1984_BASIC,
3409         AD1984_THINKPAD,
3410         AD1984_DELL_DESKTOP,
3411         AD1984_MODELS
3412 };
3413
3414 static const char *ad1984_models[AD1984_MODELS] = {
3415         [AD1984_BASIC]          = "basic",
3416         [AD1984_THINKPAD]       = "thinkpad",
3417         [AD1984_DELL_DESKTOP]   = "dell_desktop",
3418 };
3419
3420 static struct snd_pci_quirk ad1984_cfg_tbl[] = {
3421         /* Lenovo Thinkpad T61/X61 */
3422         SND_PCI_QUIRK(0x17aa, 0, "Lenovo Thinkpad", AD1984_THINKPAD),
3423         SND_PCI_QUIRK(0x1028, 0x0214, "Dell T3400", AD1984_DELL_DESKTOP),
3424         {}
3425 };
3426
3427 static int patch_ad1984(struct hda_codec *codec)
3428 {
3429         struct ad198x_spec *spec;
3430         int board_config, err;
3431
3432         err = patch_ad1884(codec);
3433         if (err < 0)
3434                 return err;
3435         spec = codec->spec;
3436         board_config = snd_hda_check_board_config(codec, AD1984_MODELS,
3437                                                   ad1984_models, ad1984_cfg_tbl);
3438         switch (board_config) {
3439         case AD1984_BASIC:
3440                 /* additional digital mics */
3441                 spec->mixers[spec->num_mixers++] = ad1984_dmic_mixers;
3442                 codec->patch_ops.build_pcms = ad1984_build_pcms;
3443                 break;
3444         case AD1984_THINKPAD:
3445                 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3446                 spec->input_mux = &ad1984_thinkpad_capture_source;
3447                 spec->mixers[0] = ad1984_thinkpad_mixers;
3448                 spec->init_verbs[spec->num_init_verbs++] = ad1984_thinkpad_init_verbs;
3449                 break;
3450         case AD1984_DELL_DESKTOP:
3451                 spec->multiout.dig_out_nid = 0;
3452                 spec->input_mux = &ad1984_dell_desktop_capture_source;
3453                 spec->mixers[0] = ad1984_dell_desktop_mixers;
3454                 break;
3455         }
3456         return 0;
3457 }
3458
3459
3460 /*
3461  * AD1883 / AD1884A / AD1984A / AD1984B
3462  *
3463  * port-B (0x14) - front mic-in
3464  * port-E (0x1c) - rear mic-in
3465  * port-F (0x16) - CD / ext out
3466  * port-C (0x15) - rear line-in
3467  * port-D (0x12) - rear line-out
3468  * port-A (0x11) - front hp-out
3469  *
3470  * AD1984A = AD1884A + digital-mic
3471  * AD1883 = equivalent with AD1984A
3472  * AD1984B = AD1984A + extra SPDIF-out
3473  *
3474  * FIXME:
3475  * We share the single DAC for both HP and line-outs (see AD1884/1984).
3476  */
3477
3478 static hda_nid_t ad1884a_dac_nids[1] = {
3479         0x03,
3480 };
3481
3482 #define ad1884a_adc_nids        ad1884_adc_nids
3483 #define ad1884a_capsrc_nids     ad1884_capsrc_nids
3484
3485 #define AD1884A_SPDIF_OUT       0x02
3486
3487 static struct hda_input_mux ad1884a_capture_source = {
3488         .num_items = 5,
3489         .items = {
3490                 { "Front Mic", 0x0 },
3491                 { "Mic", 0x4 },
3492                 { "Line", 0x1 },
3493                 { "CD", 0x2 },
3494                 { "Mix", 0x3 },
3495         },
3496 };
3497
3498 static struct snd_kcontrol_new ad1884a_base_mixers[] = {
3499         HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3500         HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
3501         HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3502         HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3503         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3504         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3505         HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3506         HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3507         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3508         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3509         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x01, HDA_INPUT),
3510         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x01, HDA_INPUT),
3511         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3512         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3513         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
3514         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
3515         HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
3516         HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
3517         HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3518         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x0, HDA_INPUT),
3519         HDA_CODEC_VOLUME("Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3520         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3521         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3522         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3523         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3524         {
3525                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3526                 /* The multiple "Capture Source" controls confuse alsamixer
3527                  * So call somewhat different..
3528                  */
3529                 /* .name = "Capture Source", */
3530                 .name = "Input Source",
3531                 .count = 2,
3532                 .info = ad198x_mux_enum_info,
3533                 .get = ad198x_mux_enum_get,
3534                 .put = ad198x_mux_enum_put,
3535         },
3536         /* SPDIF controls */
3537         HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3538         {
3539                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3540                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3541                 /* identical with ad1983 */
3542                 .info = ad1983_spdif_route_info,
3543                 .get = ad1983_spdif_route_get,
3544                 .put = ad1983_spdif_route_put,
3545         },
3546         { } /* end */
3547 };
3548
3549 /*
3550  * initialization verbs
3551  */
3552 static struct hda_verb ad1884a_init_verbs[] = {
3553         /* DACs; unmute as default */
3554         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
3555         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
3556         /* Port-A (HP) mixer - route only from analog mixer */
3557         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3558         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3559         /* Port-A pin */
3560         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3561         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3562         /* Port-D (Line-out) mixer - route only from analog mixer */
3563         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3564         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3565         /* Port-D pin */
3566         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3567         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3568         /* Mono-out mixer - route only from analog mixer */
3569         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3570         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3571         /* Mono-out pin */
3572         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3573         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3574         /* Port-B (front mic) pin */
3575         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3576         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3577         /* Port-C (rear line-in) pin */
3578         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3579         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3580         /* Port-E (rear mic) pin */
3581         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3582         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3583         {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* no boost */
3584         /* Port-F (CD) pin */
3585         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3586         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3587         /* Analog mixer; mute as default */
3588         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3589         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3590         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3591         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3592         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, /* aux */
3593         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
3594         /* Analog Mix output amp */
3595         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3596         /* capture sources */
3597         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
3598         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3599         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
3600         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3601         /* SPDIF output amp */
3602         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3603         { } /* end */
3604 };
3605
3606 #ifdef CONFIG_SND_HDA_POWER_SAVE
3607 static struct hda_amp_list ad1884a_loopbacks[] = {
3608         { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3609         { 0x20, HDA_INPUT, 1 }, /* Mic */
3610         { 0x20, HDA_INPUT, 2 }, /* CD */
3611         { 0x20, HDA_INPUT, 4 }, /* Docking */
3612         { } /* end */
3613 };
3614 #endif
3615
3616 /*
3617  * Laptop model
3618  *
3619  * Port A: Headphone jack
3620  * Port B: MIC jack
3621  * Port C: Internal MIC
3622  * Port D: Dock Line Out (if enabled)
3623  * Port E: Dock Line In (if enabled)
3624  * Port F: Internal speakers
3625  */
3626
3627 static struct hda_input_mux ad1884a_laptop_capture_source = {
3628         .num_items = 4,
3629         .items = {
3630                 { "Mic", 0x0 },         /* port-B */
3631                 { "Internal Mic", 0x1 }, /* port-C */
3632                 { "Dock Mic", 0x4 },    /* port-E */
3633                 { "Mix", 0x3 },
3634         },
3635 };
3636
3637 static struct snd_kcontrol_new ad1884a_laptop_mixers[] = {
3638         HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3639         HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
3640         HDA_CODEC_MUTE("Dock Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3641         HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3642         HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3643         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3644         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3645         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3646         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3647         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3648         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3649         HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
3650         HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
3651         HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
3652         HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT),
3653         HDA_CODEC_VOLUME("Dock Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3654         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3655         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3656         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3657         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3658         {
3659                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3660                 /* The multiple "Capture Source" controls confuse alsamixer
3661                  * So call somewhat different..
3662                  */
3663                 /* .name = "Capture Source", */
3664                 .name = "Input Source",
3665                 .count = 2,
3666                 .info = ad198x_mux_enum_info,
3667                 .get = ad198x_mux_enum_get,
3668                 .put = ad198x_mux_enum_put,
3669         },
3670         { } /* end */
3671 };
3672
3673 static struct snd_kcontrol_new ad1884a_mobile_mixers[] = {
3674         HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3675         HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
3676         HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3677         HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3678         HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
3679         HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
3680         HDA_CODEC_VOLUME("Mic Capture Volume", 0x14, 0x0, HDA_INPUT),
3681         HDA_CODEC_VOLUME("Internal Mic Capture Volume", 0x15, 0x0, HDA_INPUT),
3682         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3683         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3684         { } /* end */
3685 };
3686
3687 /* mute internal speaker if HP is plugged */
3688 static void ad1884a_hp_automute(struct hda_codec *codec)
3689 {
3690         unsigned int present;
3691
3692         present = snd_hda_codec_read(codec, 0x11, 0,
3693                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
3694         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
3695                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
3696         snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE,
3697                             present ? 0x00 : 0x02);
3698 }
3699
3700 /* switch to external mic if plugged */
3701 static void ad1884a_hp_automic(struct hda_codec *codec)
3702 {
3703         unsigned int present;
3704
3705         present = snd_hda_codec_read(codec, 0x14, 0,
3706                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
3707         snd_hda_codec_write(codec, 0x0c, 0, AC_VERB_SET_CONNECT_SEL,
3708                             present ? 0 : 1);
3709 }
3710
3711 #define AD1884A_HP_EVENT                0x37
3712 #define AD1884A_MIC_EVENT               0x36
3713
3714 /* unsolicited event for HP jack sensing */
3715 static void ad1884a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
3716 {
3717         switch (res >> 26) {
3718         case AD1884A_HP_EVENT:
3719                 ad1884a_hp_automute(codec);
3720                 break;
3721         case AD1884A_MIC_EVENT:
3722                 ad1884a_hp_automic(codec);
3723                 break;
3724         }
3725 }
3726
3727 /* initialize jack-sensing, too */
3728 static int ad1884a_hp_init(struct hda_codec *codec)
3729 {
3730         ad198x_init(codec);
3731         ad1884a_hp_automute(codec);
3732         ad1884a_hp_automic(codec);
3733         return 0;
3734 }
3735
3736 /* additional verbs for laptop model */
3737 static struct hda_verb ad1884a_laptop_verbs[] = {
3738         /* Port-A (HP) pin - always unmuted */
3739         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3740         /* Port-F (int speaker) mixer - route only from analog mixer */
3741         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3742         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3743         /* Port-F pin */
3744         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3745         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3746         /* Port-C pin - internal mic-in */
3747         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3748         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
3749         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
3750         /* analog mix */
3751         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3752         /* unsolicited event for pin-sense */
3753         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
3754         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
3755         { } /* end */
3756 };
3757
3758 /*
3759  * Thinkpad X300
3760  * 0x11 - HP
3761  * 0x12 - speaker
3762  * 0x14 - mic-in
3763  * 0x17 - built-in mic
3764  */
3765
3766 static struct hda_verb ad1984a_thinkpad_verbs[] = {
3767         /* HP unmute */
3768         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3769         /* analog mix */
3770         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3771         /* turn on EAPD */
3772         {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
3773         /* unsolicited event for pin-sense */
3774         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
3775         /* internal mic - dmic */
3776         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3777         /* set magic COEFs for dmic */
3778         {0x01, AC_VERB_SET_COEF_INDEX, 0x13f7},
3779         {0x01, AC_VERB_SET_PROC_COEF, 0x08},
3780         { } /* end */
3781 };
3782
3783 static struct snd_kcontrol_new ad1984a_thinkpad_mixers[] = {
3784         HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3785         HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
3786         HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3787         HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3788         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3789         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3790         HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
3791         HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
3792         HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
3793         HDA_CODEC_VOLUME("Internal Mic Boost", 0x17, 0x0, HDA_INPUT),
3794         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3795         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3796         {
3797                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3798                 .name = "Capture Source",
3799                 .info = ad198x_mux_enum_info,
3800                 .get = ad198x_mux_enum_get,
3801                 .put = ad198x_mux_enum_put,
3802         },
3803         { } /* end */
3804 };
3805
3806 static struct hda_input_mux ad1984a_thinkpad_capture_source = {
3807         .num_items = 3,
3808         .items = {
3809                 { "Mic", 0x0 },
3810                 { "Internal Mic", 0x5 },
3811                 { "Mix", 0x3 },
3812         },
3813 };
3814
3815 /* mute internal speaker if HP is plugged */
3816 static void ad1984a_thinkpad_automute(struct hda_codec *codec)
3817 {
3818         unsigned int present;
3819
3820         present = snd_hda_codec_read(codec, 0x11, 0, AC_VERB_GET_PIN_SENSE, 0)
3821                 & AC_PINSENSE_PRESENCE;
3822         snd_hda_codec_amp_stereo(codec, 0x12, HDA_OUTPUT, 0,
3823                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
3824 }
3825
3826 /* unsolicited event for HP jack sensing */
3827 static void ad1984a_thinkpad_unsol_event(struct hda_codec *codec,
3828                                          unsigned int res)
3829 {
3830         if ((res >> 26) != AD1884A_HP_EVENT)
3831                 return;
3832         ad1984a_thinkpad_automute(codec);
3833 }
3834
3835 /* initialize jack-sensing, too */
3836 static int ad1984a_thinkpad_init(struct hda_codec *codec)
3837 {
3838         ad198x_init(codec);
3839         ad1984a_thinkpad_automute(codec);
3840         return 0;
3841 }
3842
3843 /*
3844  */
3845
3846 enum {
3847         AD1884A_DESKTOP,
3848         AD1884A_LAPTOP,
3849         AD1884A_MOBILE,
3850         AD1884A_THINKPAD,
3851         AD1884A_MODELS
3852 };
3853
3854 static const char *ad1884a_models[AD1884A_MODELS] = {
3855         [AD1884A_DESKTOP]       = "desktop",
3856         [AD1884A_LAPTOP]        = "laptop",
3857         [AD1884A_MOBILE]        = "mobile",
3858         [AD1884A_THINKPAD]      = "thinkpad",
3859 };
3860
3861 static struct snd_pci_quirk ad1884a_cfg_tbl[] = {
3862         SND_PCI_QUIRK(0x103c, 0x3030, "HP", AD1884A_MOBILE),
3863         SND_PCI_QUIRK(0x17aa, 0x20ac, "Thinkpad X300", AD1884A_THINKPAD),
3864         {}
3865 };
3866
3867 static int patch_ad1884a(struct hda_codec *codec)
3868 {
3869         struct ad198x_spec *spec;
3870         int board_config;
3871
3872         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3873         if (spec == NULL)
3874                 return -ENOMEM;
3875
3876         codec->spec = spec;
3877
3878         spec->multiout.max_channels = 2;
3879         spec->multiout.num_dacs = ARRAY_SIZE(ad1884a_dac_nids);
3880         spec->multiout.dac_nids = ad1884a_dac_nids;
3881         spec->multiout.dig_out_nid = AD1884A_SPDIF_OUT;
3882         spec->num_adc_nids = ARRAY_SIZE(ad1884a_adc_nids);
3883         spec->adc_nids = ad1884a_adc_nids;
3884         spec->capsrc_nids = ad1884a_capsrc_nids;
3885         spec->input_mux = &ad1884a_capture_source;
3886         spec->num_mixers = 1;
3887         spec->mixers[0] = ad1884a_base_mixers;
3888         spec->num_init_verbs = 1;
3889         spec->init_verbs[0] = ad1884a_init_verbs;
3890         spec->spdif_route = 0;
3891 #ifdef CONFIG_SND_HDA_POWER_SAVE
3892         spec->loopback.amplist = ad1884a_loopbacks;
3893 #endif
3894         codec->patch_ops = ad198x_patch_ops;
3895
3896         /* override some parameters */
3897         board_config = snd_hda_check_board_config(codec, AD1884A_MODELS,
3898                                                   ad1884a_models,
3899                                                   ad1884a_cfg_tbl);
3900         switch (board_config) {
3901         case AD1884A_LAPTOP:
3902                 spec->mixers[0] = ad1884a_laptop_mixers;
3903                 spec->init_verbs[spec->num_init_verbs++] = ad1884a_laptop_verbs;
3904                 spec->multiout.dig_out_nid = 0;
3905                 spec->input_mux = &ad1884a_laptop_capture_source;
3906                 codec->patch_ops.unsol_event = ad1884a_hp_unsol_event;
3907                 codec->patch_ops.init = ad1884a_hp_init;
3908                 break;
3909         case AD1884A_MOBILE:
3910                 spec->mixers[0] = ad1884a_mobile_mixers;
3911                 spec->init_verbs[spec->num_init_verbs++] = ad1884a_laptop_verbs;
3912                 spec->multiout.dig_out_nid = 0;
3913                 codec->patch_ops.unsol_event = ad1884a_hp_unsol_event;
3914                 codec->patch_ops.init = ad1884a_hp_init;
3915                 break;
3916         case AD1884A_THINKPAD:
3917                 spec->mixers[0] = ad1984a_thinkpad_mixers;
3918                 spec->init_verbs[spec->num_init_verbs++] =
3919                         ad1984a_thinkpad_verbs;
3920                 spec->multiout.dig_out_nid = 0;
3921                 spec->input_mux = &ad1984a_thinkpad_capture_source;
3922                 codec->patch_ops.unsol_event = ad1984a_thinkpad_unsol_event;
3923                 codec->patch_ops.init = ad1984a_thinkpad_init;
3924                 break;
3925         }
3926
3927         return 0;
3928 }
3929
3930
3931 /*
3932  * AD1882 / AD1882A
3933  *
3934  * port-A - front hp-out
3935  * port-B - front mic-in
3936  * port-C - rear line-in, shared surr-out (3stack)
3937  * port-D - rear line-out
3938  * port-E - rear mic-in, shared clfe-out (3stack)
3939  * port-F - rear surr-out (6stack)
3940  * port-G - rear clfe-out (6stack)
3941  */
3942
3943 static hda_nid_t ad1882_dac_nids[3] = {
3944         0x04, 0x03, 0x05
3945 };
3946
3947 static hda_nid_t ad1882_adc_nids[2] = {
3948         0x08, 0x09,
3949 };
3950
3951 static hda_nid_t ad1882_capsrc_nids[2] = {
3952         0x0c, 0x0d,
3953 };
3954
3955 #define AD1882_SPDIF_OUT        0x02
3956
3957 /* list: 0x11, 0x39, 0x3a, 0x18, 0x3c, 0x3b, 0x12, 0x20 */
3958 static struct hda_input_mux ad1882_capture_source = {
3959         .num_items = 5,
3960         .items = {
3961                 { "Front Mic", 0x1 },
3962                 { "Mic", 0x4 },
3963                 { "Line", 0x2 },
3964                 { "CD", 0x3 },
3965                 { "Mix", 0x7 },
3966         },
3967 };
3968
3969 /* list: 0x11, 0x39, 0x3a, 0x3c, 0x18, 0x1f, 0x12, 0x20 */
3970 static struct hda_input_mux ad1882a_capture_source = {
3971         .num_items = 5,
3972         .items = {
3973                 { "Front Mic", 0x1 },
3974                 { "Mic", 0x4},
3975                 { "Line", 0x2 },
3976                 { "Digital Mic", 0x06 },
3977                 { "Mix", 0x7 },
3978         },
3979 };
3980
3981 static struct snd_kcontrol_new ad1882_base_mixers[] = {
3982         HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3983         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
3984         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
3985         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
3986         HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3987         HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3988         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3989         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3990
3991         HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
3992         HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
3993         HDA_CODEC_VOLUME("Line-In Boost", 0x3a, 0x0, HDA_OUTPUT),
3994         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3995         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3996         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3997         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3998         {
3999                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4000                 /* The multiple "Capture Source" controls confuse alsamixer
4001                  * So call somewhat different..
4002                  */
4003                 /* .name = "Capture Source", */
4004                 .name = "Input Source",
4005                 .count = 2,
4006                 .info = ad198x_mux_enum_info,
4007                 .get = ad198x_mux_enum_get,
4008                 .put = ad198x_mux_enum_put,
4009         },
4010         /* SPDIF controls */
4011         HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
4012         {
4013                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4014                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
4015                 /* identical with ad1983 */
4016                 .info = ad1983_spdif_route_info,
4017                 .get = ad1983_spdif_route_get,
4018                 .put = ad1983_spdif_route_put,
4019         },
4020         { } /* end */
4021 };
4022
4023 static struct snd_kcontrol_new ad1882_loopback_mixers[] = {
4024         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4025         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4026         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
4027         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
4028         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x04, HDA_INPUT),
4029         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x04, HDA_INPUT),
4030         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
4031         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
4032         HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x07, HDA_INPUT),
4033         HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x07, HDA_INPUT),
4034         { } /* end */
4035 };
4036
4037 static struct snd_kcontrol_new ad1882a_loopback_mixers[] = {
4038         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4039         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4040         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
4041         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
4042         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x01, HDA_INPUT),
4043         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x01, HDA_INPUT),
4044         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
4045         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
4046         HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x07, HDA_INPUT),
4047         HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x07, HDA_INPUT),
4048         HDA_CODEC_VOLUME("Digital Mic Boost", 0x1f, 0x0, HDA_INPUT),
4049         { } /* end */
4050 };
4051
4052 static struct snd_kcontrol_new ad1882_3stack_mixers[] = {
4053         HDA_CODEC_MUTE("Surround Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4054         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x17, 1, 0x0, HDA_OUTPUT),
4055         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x17, 2, 0x0, HDA_OUTPUT),
4056         {
4057                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4058                 .name = "Channel Mode",
4059                 .info = ad198x_ch_mode_info,
4060                 .get = ad198x_ch_mode_get,
4061                 .put = ad198x_ch_mode_put,
4062         },
4063         { } /* end */
4064 };
4065
4066 static struct snd_kcontrol_new ad1882_6stack_mixers[] = {
4067         HDA_CODEC_MUTE("Surround Playback Switch", 0x16, 0x0, HDA_OUTPUT),
4068         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x24, 1, 0x0, HDA_OUTPUT),
4069         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x24, 2, 0x0, HDA_OUTPUT),
4070         { } /* end */
4071 };
4072
4073 static struct hda_verb ad1882_ch2_init[] = {
4074         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4075         {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4076         {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4077         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4078         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4079         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4080         { } /* end */
4081 };
4082
4083 static struct hda_verb ad1882_ch4_init[] = {
4084         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4085         {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4086         {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4087         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4088         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4089         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4090         { } /* end */
4091 };
4092
4093 static struct hda_verb ad1882_ch6_init[] = {
4094         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4095         {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4096         {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4097         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4098         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4099         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4100         { } /* end */
4101 };
4102
4103 static struct hda_channel_mode ad1882_modes[3] = {
4104         { 2, ad1882_ch2_init },
4105         { 4, ad1882_ch4_init },
4106         { 6, ad1882_ch6_init },
4107 };
4108
4109 /*
4110  * initialization verbs
4111  */
4112 static struct hda_verb ad1882_init_verbs[] = {
4113         /* DACs; mute as default */
4114         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4115         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4116         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4117         /* Port-A (HP) mixer */
4118         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4119         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4120         /* Port-A pin */
4121         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4122         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4123         /* HP selector - select DAC2 */
4124         {0x37, AC_VERB_SET_CONNECT_SEL, 0x1},
4125         /* Port-D (Line-out) mixer */
4126         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4127         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4128         /* Port-D pin */
4129         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4130         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4131         /* Mono-out mixer */
4132         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4133         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4134         /* Mono-out pin */
4135         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4136         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4137         /* Port-B (front mic) pin */
4138         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4139         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4140         {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
4141         /* Port-C (line-in) pin */
4142         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4143         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4144         {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
4145         /* Port-C mixer - mute as input */
4146         {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4147         {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4148         /* Port-E (mic-in) pin */
4149         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4150         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4151         {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
4152         /* Port-E mixer - mute as input */
4153         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4154         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4155         /* Port-F (surround) */
4156         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4157         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4158         /* Port-G (CLFE) */
4159         {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4160         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4161         /* Analog mixer; mute as default */
4162         /* list: 0x39, 0x3a, 0x11, 0x12, 0x3c, 0x3b, 0x18, 0x1a */
4163         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4164         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4165         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4166         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4167         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4168         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
4169         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
4170         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
4171         /* Analog Mix output amp */
4172         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
4173         /* SPDIF output selector */
4174         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
4175         {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
4176         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
4177         { } /* end */
4178 };
4179
4180 #ifdef CONFIG_SND_HDA_POWER_SAVE
4181 static struct hda_amp_list ad1882_loopbacks[] = {
4182         { 0x20, HDA_INPUT, 0 }, /* Front Mic */
4183         { 0x20, HDA_INPUT, 1 }, /* Mic */
4184         { 0x20, HDA_INPUT, 4 }, /* Line */
4185         { 0x20, HDA_INPUT, 6 }, /* CD */
4186         { } /* end */
4187 };
4188 #endif
4189
4190 /* models */
4191 enum {
4192         AD1882_3STACK,
4193         AD1882_6STACK,
4194         AD1882_MODELS
4195 };
4196
4197 static const char *ad1882_models[AD1986A_MODELS] = {
4198         [AD1882_3STACK]         = "3stack",
4199         [AD1882_6STACK]         = "6stack",
4200 };
4201
4202
4203 static int patch_ad1882(struct hda_codec *codec)
4204 {
4205         struct ad198x_spec *spec;
4206         int board_config;
4207
4208         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4209         if (spec == NULL)
4210                 return -ENOMEM;
4211
4212         codec->spec = spec;
4213
4214         spec->multiout.max_channels = 6;
4215         spec->multiout.num_dacs = 3;
4216         spec->multiout.dac_nids = ad1882_dac_nids;
4217         spec->multiout.dig_out_nid = AD1882_SPDIF_OUT;
4218         spec->num_adc_nids = ARRAY_SIZE(ad1882_adc_nids);
4219         spec->adc_nids = ad1882_adc_nids;
4220         spec->capsrc_nids = ad1882_capsrc_nids;
4221         if (codec->vendor_id == 0x11d1882)
4222                 spec->input_mux = &ad1882_capture_source;
4223         else
4224                 spec->input_mux = &ad1882a_capture_source;
4225         spec->num_mixers = 2;
4226         spec->mixers[0] = ad1882_base_mixers;
4227         if (codec->vendor_id == 0x11d1882)
4228                 spec->mixers[1] = ad1882_loopback_mixers;
4229         else
4230                 spec->mixers[1] = ad1882a_loopback_mixers;
4231         spec->num_init_verbs = 1;
4232         spec->init_verbs[0] = ad1882_init_verbs;
4233         spec->spdif_route = 0;
4234 #ifdef CONFIG_SND_HDA_POWER_SAVE
4235         spec->loopback.amplist = ad1882_loopbacks;
4236 #endif
4237         spec->vmaster_nid = 0x04;
4238
4239         codec->patch_ops = ad198x_patch_ops;
4240
4241         /* override some parameters */
4242         board_config = snd_hda_check_board_config(codec, AD1882_MODELS,
4243                                                   ad1882_models, NULL);
4244         switch (board_config) {
4245         default:
4246         case AD1882_3STACK:
4247                 spec->num_mixers = 3;
4248                 spec->mixers[2] = ad1882_3stack_mixers;
4249                 spec->channel_mode = ad1882_modes;
4250                 spec->num_channel_mode = ARRAY_SIZE(ad1882_modes);
4251                 spec->need_dac_fix = 1;
4252                 spec->multiout.max_channels = 2;
4253                 spec->multiout.num_dacs = 1;
4254                 break;
4255         case AD1882_6STACK:
4256                 spec->num_mixers = 3;
4257                 spec->mixers[2] = ad1882_6stack_mixers;
4258                 break;
4259         }
4260         return 0;
4261 }
4262
4263
4264 /*
4265  * patch entries
4266  */
4267 struct hda_codec_preset snd_hda_preset_analog[] = {
4268         { .id = 0x11d4184a, .name = "AD1884A", .patch = patch_ad1884a },
4269         { .id = 0x11d41882, .name = "AD1882", .patch = patch_ad1882 },
4270         { .id = 0x11d41883, .name = "AD1883", .patch = patch_ad1884a },
4271         { .id = 0x11d41884, .name = "AD1884", .patch = patch_ad1884 },
4272         { .id = 0x11d4194a, .name = "AD1984A", .patch = patch_ad1884a },
4273         { .id = 0x11d4194b, .name = "AD1984B", .patch = patch_ad1884a },
4274         { .id = 0x11d41981, .name = "AD1981", .patch = patch_ad1981 },
4275         { .id = 0x11d41983, .name = "AD1983", .patch = patch_ad1983 },
4276         { .id = 0x11d41984, .name = "AD1984", .patch = patch_ad1984 },
4277         { .id = 0x11d41986, .name = "AD1986A", .patch = patch_ad1986a },
4278         { .id = 0x11d41988, .name = "AD1988", .patch = patch_ad1988 },
4279         { .id = 0x11d4198b, .name = "AD1988B", .patch = patch_ad1988 },
4280         { .id = 0x11d4882a, .name = "AD1882A", .patch = patch_ad1882 },
4281         { .id = 0x11d4989a, .name = "AD1989A", .patch = patch_ad1988 },
4282         { .id = 0x11d4989b, .name = "AD1989B", .patch = patch_ad1988 },
4283         {} /* terminator */
4284 };