sound/pci/hda/patch_analog.c

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