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