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                 /* set the upper-limit for mixer amp to 0dB for avoiding the
1900                  * possible damage by overloading
1901                  */
1902                 snd_hda_override_amp_caps(codec, 0x11, HDA_INPUT,
1903                                           (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
1904                                           (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
1905                                           (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
1906                                           (1 << AC_AMPCAP_MUTE_SHIFT));
1907                 break;
1908         case AD1981_TOSHIBA:
1909                 spec->mixers[0] = ad1981_hp_mixers;
1910                 spec->mixers[1] = ad1981_toshiba_mixers;
1911                 spec->num_init_verbs = 2;
1912                 spec->init_verbs[1] = ad1981_toshiba_init_verbs;
1913                 spec->multiout.dig_out_nid = 0;
1914                 spec->input_mux = &ad1981_hp_capture_source;
1915                 codec->patch_ops.init = ad1981_hp_init;
1916                 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1917                 break;
1918         }
1919
1920         codec->no_trigger_sense = 1;
1921
1922         return 0;
1923 }
1924
1925
1926 /*
1927  * AD1988
1928  *
1929  * Output pins and routes
1930  *
1931  *        Pin               Mix     Sel     DAC (*)
1932  * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06
1933  * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06
1934  * port-C 0x15 (mute)    <- 0x2c <- 0x31 <- 05/0a
1935  * port-D 0x12 (mute/hp) <- 0x29         <- 04
1936  * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a
1937  * port-F 0x16 (mute)    <- 0x2a         <- 06
1938  * port-G 0x24 (mute)    <- 0x27         <- 05
1939  * port-H 0x25 (mute)    <- 0x28         <- 0a
1940  * mono   0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06
1941  *
1942  * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah
1943  * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug.
1944  *
1945  * Input pins and routes
1946  *
1947  *        pin     boost   mix input # / adc input #
1948  * port-A 0x11 -> 0x38 -> mix 2, ADC 0
1949  * port-B 0x14 -> 0x39 -> mix 0, ADC 1
1950  * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2
1951  * port-D 0x12 -> 0x3d -> mix 3, ADC 8
1952  * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4
1953  * port-F 0x16 -> 0x3b -> mix 5, ADC 3
1954  * port-G 0x24 -> N/A  -> 33:1 - mix 1, 34:1 - mix 4, ADC 6
1955  * port-H 0x25 -> N/A  -> 33:2 - mix 1, 34:2 - mix 4, ADC 7
1956  *
1957  *
1958  * DAC assignment
1959  *   6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03
1960  *   3stack - front/surr/CLFE/opt DACs - 04/05/0a/03
1961  *
1962  * Inputs of Analog Mix (0x20)
1963  *   0:Port-B (front mic)
1964  *   1:Port-C/G/H (line-in)
1965  *   2:Port-A
1966  *   3:Port-D (line-in/2)
1967  *   4:Port-E/G/H (mic-in)
1968  *   5:Port-F (mic2-in)
1969  *   6:CD
1970  *   7:Beep
1971  *
1972  * ADC selection
1973  *   0:Port-A
1974  *   1:Port-B (front mic-in)
1975  *   2:Port-C (line-in)
1976  *   3:Port-F (mic2-in)
1977  *   4:Port-E (mic-in)
1978  *   5:CD
1979  *   6:Port-G
1980  *   7:Port-H
1981  *   8:Port-D (line-in/2)
1982  *   9:Mix
1983  *
1984  * Proposed pin assignments by the datasheet
1985  *
1986  * 6-stack
1987  * Port-A front headphone
1988  *      B front mic-in
1989  *      C rear line-in
1990  *      D rear front-out
1991  *      E rear mic-in
1992  *      F rear surround
1993  *      G rear CLFE
1994  *      H rear side
1995  *
1996  * 3-stack
1997  * Port-A front headphone
1998  *      B front mic
1999  *      C rear line-in/surround
2000  *      D rear front-out
2001  *      E rear mic-in/CLFE
2002  *
2003  * laptop
2004  * Port-A headphone
2005  *      B mic-in
2006  *      C docking station
2007  *      D internal speaker (with EAPD)
2008  *      E/F quad mic array
2009  */
2010
2011
2012 /* models */
2013 enum {
2014         AD1988_6STACK,
2015         AD1988_6STACK_DIG,
2016         AD1988_3STACK,
2017         AD1988_3STACK_DIG,
2018         AD1988_LAPTOP,
2019         AD1988_LAPTOP_DIG,
2020         AD1988_AUTO,
2021         AD1988_MODEL_LAST,
2022 };
2023
2024 /* reivision id to check workarounds */
2025 #define AD1988A_REV2            0x100200
2026
2027 #define is_rev2(codec) \
2028         ((codec)->vendor_id == 0x11d41988 && \
2029          (codec)->revision_id == AD1988A_REV2)
2030
2031 /*
2032  * mixers
2033  */
2034
2035 static hda_nid_t ad1988_6stack_dac_nids[4] = {
2036         0x04, 0x06, 0x05, 0x0a
2037 };
2038
2039 static hda_nid_t ad1988_3stack_dac_nids[3] = {
2040         0x04, 0x05, 0x0a
2041 };
2042
2043 /* for AD1988A revision-2, DAC2-4 are swapped */
2044 static hda_nid_t ad1988_6stack_dac_nids_rev2[4] = {
2045         0x04, 0x05, 0x0a, 0x06
2046 };
2047
2048 static hda_nid_t ad1988_3stack_dac_nids_rev2[3] = {
2049         0x04, 0x0a, 0x06
2050 };
2051
2052 static hda_nid_t ad1988_adc_nids[3] = {
2053         0x08, 0x09, 0x0f
2054 };
2055
2056 static hda_nid_t ad1988_capsrc_nids[3] = {
2057         0x0c, 0x0d, 0x0e
2058 };
2059
2060 #define AD1988_SPDIF_OUT                0x02
2061 #define AD1988_SPDIF_OUT_HDMI   0x0b
2062 #define AD1988_SPDIF_IN         0x07
2063
2064 static hda_nid_t ad1989b_slave_dig_outs[] = {
2065         AD1988_SPDIF_OUT, AD1988_SPDIF_OUT_HDMI, 0
2066 };
2067
2068 static struct hda_input_mux ad1988_6stack_capture_source = {
2069         .num_items = 5,
2070         .items = {
2071                 { "Front Mic", 0x1 },   /* port-B */
2072                 { "Line", 0x2 },        /* port-C */
2073                 { "Mic", 0x4 },         /* port-E */
2074                 { "CD", 0x5 },
2075                 { "Mix", 0x9 },
2076         },
2077 };
2078
2079 static struct hda_input_mux ad1988_laptop_capture_source = {
2080         .num_items = 3,
2081         .items = {
2082                 { "Mic/Line", 0x1 },    /* port-B */
2083                 { "CD", 0x5 },
2084                 { "Mix", 0x9 },
2085         },
2086 };
2087
2088 /*
2089  */
2090 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
2091                                struct snd_ctl_elem_info *uinfo)
2092 {
2093         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2094         struct ad198x_spec *spec = codec->spec;
2095         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
2096                                     spec->num_channel_mode);
2097 }
2098
2099 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
2100                               struct snd_ctl_elem_value *ucontrol)
2101 {
2102         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2103         struct ad198x_spec *spec = codec->spec;
2104         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
2105                                    spec->num_channel_mode, spec->multiout.max_channels);
2106 }
2107
2108 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
2109                               struct snd_ctl_elem_value *ucontrol)
2110 {
2111         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2112         struct ad198x_spec *spec = codec->spec;
2113         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
2114                                       spec->num_channel_mode,
2115                                       &spec->multiout.max_channels);
2116         if (err >= 0 && spec->need_dac_fix)
2117                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
2118         return err;
2119 }
2120
2121 /* 6-stack mode */
2122 static struct snd_kcontrol_new ad1988_6stack_mixers1[] = {
2123         HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2124         HDA_CODEC_VOLUME("Surround Playback Volume", 0x06, 0x0, HDA_OUTPUT),
2125         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
2126         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
2127         HDA_CODEC_VOLUME("Side Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
2128         { } /* end */
2129 };
2130
2131 static struct snd_kcontrol_new ad1988_6stack_mixers1_rev2[] = {
2132         HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2133         HDA_CODEC_VOLUME("Surround Playback Volume", 0x05, 0x0, HDA_OUTPUT),
2134         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
2135         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0a, 2, 0x0, HDA_OUTPUT),
2136         HDA_CODEC_VOLUME("Side Playback Volume", 0x06, 0x0, HDA_OUTPUT),
2137         { } /* end */
2138 };
2139
2140 static struct snd_kcontrol_new ad1988_6stack_mixers2[] = {
2141         HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
2142         HDA_BIND_MUTE("Surround Playback Switch", 0x2a, 2, HDA_INPUT),
2143         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x27, 1, 2, HDA_INPUT),
2144         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x27, 2, 2, HDA_INPUT),
2145         HDA_BIND_MUTE("Side Playback Switch", 0x28, 2, HDA_INPUT),
2146         HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
2147         HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2148
2149         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2150         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2151         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2152         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2153         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2154         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2155         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
2156         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
2157
2158         HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2159         HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2160
2161         HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2162         HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
2163
2164         { } /* end */
2165 };
2166
2167 /* 3-stack mode */
2168 static struct snd_kcontrol_new ad1988_3stack_mixers1[] = {
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", 0x05, 1, 0x0, HDA_OUTPUT),
2172         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
2173         { } /* end */
2174 };
2175
2176 static struct snd_kcontrol_new ad1988_3stack_mixers1_rev2[] = {
2177         HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2178         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
2179         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x06, 1, 0x0, HDA_OUTPUT),
2180         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x06, 2, 0x0, HDA_OUTPUT),
2181         { } /* end */
2182 };
2183
2184 static struct snd_kcontrol_new ad1988_3stack_mixers2[] = {
2185         HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
2186         HDA_BIND_MUTE("Surround Playback Switch", 0x2c, 2, HDA_INPUT),
2187         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x26, 1, 2, HDA_INPUT),
2188         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x26, 2, 2, HDA_INPUT),
2189         HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
2190         HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2191
2192         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2193         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2194         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2195         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2196         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2197         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2198         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
2199         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
2200
2201         HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2202         HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2203
2204         HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2205         HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
2206         {
2207                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2208                 .name = "Channel Mode",
2209                 .info = ad198x_ch_mode_info,
2210                 .get = ad198x_ch_mode_get,
2211                 .put = ad198x_ch_mode_put,
2212         },
2213
2214         { } /* end */
2215 };
2216
2217 /* laptop mode */
2218 static struct snd_kcontrol_new ad1988_laptop_mixers[] = {
2219         HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2220         HDA_CODEC_MUTE("PCM Playback Switch", 0x29, 0x0, HDA_INPUT),
2221         HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2222
2223         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2224         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2225         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2226         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2227         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2228         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2229
2230         HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2231         HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2232
2233         HDA_CODEC_VOLUME("Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2234
2235         {
2236                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2237                 .name = "External Amplifier",
2238                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x12,
2239                 .info = ad198x_eapd_info,
2240                 .get = ad198x_eapd_get,
2241                 .put = ad198x_eapd_put,
2242                 .private_value = 0x12, /* port-D */
2243         },
2244
2245         { } /* end */
2246 };
2247
2248 /* capture */
2249 static struct snd_kcontrol_new ad1988_capture_mixers[] = {
2250         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
2251         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
2252         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
2253         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
2254         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x0e, 0x0, HDA_OUTPUT),
2255         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x0e, 0x0, HDA_OUTPUT),
2256         {
2257                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2258                 /* The multiple "Capture Source" controls confuse alsamixer
2259                  * So call somewhat different..
2260                  */
2261                 /* .name = "Capture Source", */
2262                 .name = "Input Source",
2263                 .count = 3,
2264                 .info = ad198x_mux_enum_info,
2265                 .get = ad198x_mux_enum_get,
2266                 .put = ad198x_mux_enum_put,
2267         },
2268         { } /* end */
2269 };
2270
2271 static int ad1988_spdif_playback_source_info(struct snd_kcontrol *kcontrol,
2272                                              struct snd_ctl_elem_info *uinfo)
2273 {
2274         static char *texts[] = {
2275                 "PCM", "ADC1", "ADC2", "ADC3"
2276         };
2277         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2278         uinfo->count = 1;
2279         uinfo->value.enumerated.items = 4;
2280         if (uinfo->value.enumerated.item >= 4)
2281                 uinfo->value.enumerated.item = 3;
2282         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2283         return 0;
2284 }
2285
2286 static int ad1988_spdif_playback_source_get(struct snd_kcontrol *kcontrol,
2287                                             struct snd_ctl_elem_value *ucontrol)
2288 {
2289         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2290         unsigned int sel;
2291
2292         sel = snd_hda_codec_read(codec, 0x1d, 0, AC_VERB_GET_AMP_GAIN_MUTE,
2293                                  AC_AMP_GET_INPUT);
2294         if (!(sel & 0x80))
2295                 ucontrol->value.enumerated.item[0] = 0;
2296         else {
2297                 sel = snd_hda_codec_read(codec, 0x0b, 0,
2298                                          AC_VERB_GET_CONNECT_SEL, 0);
2299                 if (sel < 3)
2300                         sel++;
2301                 else
2302                         sel = 0;
2303                 ucontrol->value.enumerated.item[0] = sel;
2304         }
2305         return 0;
2306 }
2307
2308 static int ad1988_spdif_playback_source_put(struct snd_kcontrol *kcontrol,
2309                                             struct snd_ctl_elem_value *ucontrol)
2310 {
2311         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2312         unsigned int val, sel;
2313         int change;
2314
2315         val = ucontrol->value.enumerated.item[0];
2316         if (val > 3)
2317                 return -EINVAL;
2318         if (!val) {
2319                 sel = snd_hda_codec_read(codec, 0x1d, 0,
2320                                          AC_VERB_GET_AMP_GAIN_MUTE,
2321                                          AC_AMP_GET_INPUT);
2322                 change = sel & 0x80;
2323                 if (change) {
2324                         snd_hda_codec_write_cache(codec, 0x1d, 0,
2325                                                   AC_VERB_SET_AMP_GAIN_MUTE,
2326                                                   AMP_IN_UNMUTE(0));
2327                         snd_hda_codec_write_cache(codec, 0x1d, 0,
2328                                                   AC_VERB_SET_AMP_GAIN_MUTE,
2329                                                   AMP_IN_MUTE(1));
2330                 }
2331         } else {
2332                 sel = snd_hda_codec_read(codec, 0x1d, 0,
2333                                          AC_VERB_GET_AMP_GAIN_MUTE,
2334                                          AC_AMP_GET_INPUT | 0x01);
2335                 change = sel & 0x80;
2336                 if (change) {
2337                         snd_hda_codec_write_cache(codec, 0x1d, 0,
2338                                                   AC_VERB_SET_AMP_GAIN_MUTE,
2339                                                   AMP_IN_MUTE(0));
2340                         snd_hda_codec_write_cache(codec, 0x1d, 0,
2341                                                   AC_VERB_SET_AMP_GAIN_MUTE,
2342                                                   AMP_IN_UNMUTE(1));
2343                 }
2344                 sel = snd_hda_codec_read(codec, 0x0b, 0,
2345                                          AC_VERB_GET_CONNECT_SEL, 0) + 1;
2346                 change |= sel != val;
2347                 if (change)
2348                         snd_hda_codec_write_cache(codec, 0x0b, 0,
2349                                                   AC_VERB_SET_CONNECT_SEL,
2350                                                   val - 1);
2351         }
2352         return change;
2353 }
2354
2355 static struct snd_kcontrol_new ad1988_spdif_out_mixers[] = {
2356         HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2357         {
2358                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2359                 .name = "IEC958 Playback Source",
2360                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x1b,
2361                 .info = ad1988_spdif_playback_source_info,
2362                 .get = ad1988_spdif_playback_source_get,
2363                 .put = ad1988_spdif_playback_source_put,
2364         },
2365         { } /* end */
2366 };
2367
2368 static struct snd_kcontrol_new ad1988_spdif_in_mixers[] = {
2369         HDA_CODEC_VOLUME("IEC958 Capture Volume", 0x1c, 0x0, HDA_INPUT),
2370         { } /* end */
2371 };
2372
2373 static struct snd_kcontrol_new ad1989_spdif_out_mixers[] = {
2374         HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2375         HDA_CODEC_VOLUME("HDMI Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
2376         { } /* end */
2377 };
2378
2379 /*
2380  * initialization verbs
2381  */
2382
2383 /*
2384  * for 6-stack (+dig)
2385  */
2386 static struct hda_verb ad1988_6stack_init_verbs[] = {
2387         /* Front, Surround, CLFE, side DAC; unmute as default */
2388         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2389         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2390         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2391         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2392         /* Port-A front headphon path */
2393         {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2394         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2395         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2396         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2397         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2398         /* Port-D line-out path */
2399         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2400         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2401         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2402         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2403         /* Port-F surround path */
2404         {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2405         {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2406         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2407         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2408         /* Port-G CLFE path */
2409         {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2410         {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2411         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2412         {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2413         /* Port-H side path */
2414         {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2415         {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2416         {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2417         {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2418         /* Mono out path */
2419         {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2420         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2421         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2422         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2423         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2424         /* Port-B front mic-in path */
2425         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2426         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2427         {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2428         /* Port-C line-in path */
2429         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2430         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2431         {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2432         {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2433         /* Port-E mic-in path */
2434         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2435         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2436         {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2437         {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2438         /* Analog CD Input */
2439         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2440         /* Analog Mix output amp */
2441         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2442
2443         { }
2444 };
2445
2446 static struct hda_verb ad1988_capture_init_verbs[] = {
2447         /* mute analog mix */
2448         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2449         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2450         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2451         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2452         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2453         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2454         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2455         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2456         /* select ADCs - front-mic */
2457         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2458         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2459         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2460
2461         { }
2462 };
2463
2464 static struct hda_verb ad1988_spdif_init_verbs[] = {
2465         /* SPDIF out sel */
2466         {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
2467         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0}, /* ADC1 */
2468         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2469         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2470         /* SPDIF out pin */
2471         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2472
2473         { }
2474 };
2475
2476 static struct hda_verb ad1988_spdif_in_init_verbs[] = {
2477         /* unmute SPDIF input pin */
2478         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2479         { }
2480 };
2481
2482 /* AD1989 has no ADC -> SPDIF route */
2483 static struct hda_verb ad1989_spdif_init_verbs[] = {
2484         /* SPDIF-1 out pin */
2485         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2486         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2487         /* SPDIF-2/HDMI out pin */
2488         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2489         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2490         { }
2491 };
2492
2493 /*
2494  * verbs for 3stack (+dig)
2495  */
2496 static struct hda_verb ad1988_3stack_ch2_init[] = {
2497         /* set port-C to line-in */
2498         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2499         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2500         /* set port-E to mic-in */
2501         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2502         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2503         { } /* end */
2504 };
2505
2506 static struct hda_verb ad1988_3stack_ch6_init[] = {
2507         /* set port-C to surround out */
2508         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2509         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2510         /* set port-E to CLFE out */
2511         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2512         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2513         { } /* end */
2514 };
2515
2516 static struct hda_channel_mode ad1988_3stack_modes[2] = {
2517         { 2, ad1988_3stack_ch2_init },
2518         { 6, ad1988_3stack_ch6_init },
2519 };
2520
2521 static struct hda_verb ad1988_3stack_init_verbs[] = {
2522         /* Front, Surround, CLFE, side DAC; unmute as default */
2523         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2524         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2525         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2526         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2527         /* Port-A front headphon path */
2528         {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2529         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2530         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2531         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2532         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2533         /* Port-D line-out path */
2534         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2535         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2536         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2537         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2538         /* Mono out path */
2539         {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2540         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2541         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2542         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2543         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2544         /* Port-B front mic-in path */
2545         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2546         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2547         {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2548         /* Port-C line-in/surround path - 6ch mode as default */
2549         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2550         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2551         {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2552         {0x31, AC_VERB_SET_CONNECT_SEL, 0x0}, /* output sel: DAC 0x05 */
2553         {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2554         /* Port-E mic-in/CLFE path - 6ch mode as default */
2555         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2556         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2557         {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2558         {0x32, AC_VERB_SET_CONNECT_SEL, 0x1}, /* output sel: DAC 0x0a */
2559         {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2560         /* mute analog mix */
2561         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2562         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2563         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2564         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2565         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2566         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2567         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2568         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2569         /* select ADCs - front-mic */
2570         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2571         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2572         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2573         /* Analog Mix output amp */
2574         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2575         { }
2576 };
2577
2578 /*
2579  * verbs for laptop mode (+dig)
2580  */
2581 static struct hda_verb ad1988_laptop_hp_on[] = {
2582         /* unmute port-A and mute port-D */
2583         { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2584         { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2585         { } /* end */
2586 };
2587 static struct hda_verb ad1988_laptop_hp_off[] = {
2588         /* mute port-A and unmute port-D */
2589         { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2590         { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2591         { } /* end */
2592 };
2593
2594 #define AD1988_HP_EVENT 0x01
2595
2596 static struct hda_verb ad1988_laptop_init_verbs[] = {
2597         /* Front, Surround, CLFE, side DAC; unmute as default */
2598         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2599         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2600         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2601         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2602         /* Port-A front headphon path */
2603         {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2604         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2605         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2606         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2607         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2608         /* unsolicited event for pin-sense */
2609         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1988_HP_EVENT },
2610         /* Port-D line-out path + EAPD */
2611         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2612         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2613         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2614         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2615         {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x00}, /* EAPD-off */
2616         /* Mono out path */
2617         {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2618         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2619         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2620         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2621         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2622         /* Port-B mic-in path */
2623         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2624         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2625         {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2626         /* Port-C docking station - try to output */
2627         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2628         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2629         {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2630         {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2631         /* mute analog mix */
2632         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2633         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2634         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2635         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2636         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2637         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2638         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2639         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2640         /* select ADCs - mic */
2641         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2642         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2643         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2644         /* Analog Mix output amp */
2645         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2646         { }
2647 };
2648
2649 static void ad1988_laptop_unsol_event(struct hda_codec *codec, unsigned int res)
2650 {
2651         if ((res >> 26) != AD1988_HP_EVENT)
2652                 return;
2653         if (snd_hda_jack_detect(codec, 0x11))
2654                 snd_hda_sequence_write(codec, ad1988_laptop_hp_on);
2655         else
2656                 snd_hda_sequence_write(codec, ad1988_laptop_hp_off);
2657 }
2658
2659 #ifdef CONFIG_SND_HDA_POWER_SAVE
2660 static struct hda_amp_list ad1988_loopbacks[] = {
2661         { 0x20, HDA_INPUT, 0 }, /* Front Mic */
2662         { 0x20, HDA_INPUT, 1 }, /* Line */
2663         { 0x20, HDA_INPUT, 4 }, /* Mic */
2664         { 0x20, HDA_INPUT, 6 }, /* CD */
2665         { } /* end */
2666 };
2667 #endif
2668
2669 /*
2670  * Automatic parse of I/O pins from the BIOS configuration
2671  */
2672
2673 enum {
2674         AD_CTL_WIDGET_VOL,
2675         AD_CTL_WIDGET_MUTE,
2676         AD_CTL_BIND_MUTE,
2677 };
2678 static struct snd_kcontrol_new ad1988_control_templates[] = {
2679         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2680         HDA_CODEC_MUTE(NULL, 0, 0, 0),
2681         HDA_BIND_MUTE(NULL, 0, 0, 0),
2682 };
2683
2684 /* add dynamic controls */
2685 static int add_control(struct ad198x_spec *spec, int type, const char *name,
2686                        unsigned long val)
2687 {
2688         struct snd_kcontrol_new *knew;
2689
2690         snd_array_init(&spec->kctls, sizeof(*knew), 32);
2691         knew = snd_array_new(&spec->kctls);
2692         if (!knew)
2693                 return -ENOMEM;
2694         *knew = ad1988_control_templates[type];
2695         knew->name = kstrdup(name, GFP_KERNEL);
2696         if (! knew->name)
2697                 return -ENOMEM;
2698         if (get_amp_nid_(val))
2699                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
2700         knew->private_value = val;
2701         return 0;
2702 }
2703
2704 #define AD1988_PIN_CD_NID               0x18
2705 #define AD1988_PIN_BEEP_NID             0x10
2706
2707 static hda_nid_t ad1988_mixer_nids[8] = {
2708         /* A     B     C     D     E     F     G     H */
2709         0x22, 0x2b, 0x2c, 0x29, 0x26, 0x2a, 0x27, 0x28
2710 };
2711
2712 static inline hda_nid_t ad1988_idx_to_dac(struct hda_codec *codec, int idx)
2713 {
2714         static hda_nid_t idx_to_dac[8] = {
2715                 /* A     B     C     D     E     F     G     H */
2716                 0x04, 0x06, 0x05, 0x04, 0x0a, 0x06, 0x05, 0x0a
2717         };
2718         static hda_nid_t idx_to_dac_rev2[8] = {
2719                 /* A     B     C     D     E     F     G     H */
2720                 0x04, 0x05, 0x0a, 0x04, 0x06, 0x05, 0x0a, 0x06
2721         };
2722         if (is_rev2(codec))
2723                 return idx_to_dac_rev2[idx];
2724         else
2725                 return idx_to_dac[idx];
2726 }
2727
2728 static hda_nid_t ad1988_boost_nids[8] = {
2729         0x38, 0x39, 0x3a, 0x3d, 0x3c, 0x3b, 0, 0
2730 };
2731
2732 static int ad1988_pin_idx(hda_nid_t nid)
2733 {
2734         static hda_nid_t ad1988_io_pins[8] = {
2735                 0x11, 0x14, 0x15, 0x12, 0x17, 0x16, 0x24, 0x25
2736         };
2737         int i;
2738         for (i = 0; i < ARRAY_SIZE(ad1988_io_pins); i++)
2739                 if (ad1988_io_pins[i] == nid)
2740                         return i;
2741         return 0; /* should be -1 */
2742 }
2743
2744 static int ad1988_pin_to_loopback_idx(hda_nid_t nid)
2745 {
2746         static int loopback_idx[8] = {
2747                 2, 0, 1, 3, 4, 5, 1, 4
2748         };
2749         switch (nid) {
2750         case AD1988_PIN_CD_NID:
2751                 return 6;
2752         default:
2753                 return loopback_idx[ad1988_pin_idx(nid)];
2754         }
2755 }
2756
2757 static int ad1988_pin_to_adc_idx(hda_nid_t nid)
2758 {
2759         static int adc_idx[8] = {
2760                 0, 1, 2, 8, 4, 3, 6, 7
2761         };
2762         switch (nid) {
2763         case AD1988_PIN_CD_NID:
2764                 return 5;
2765         default:
2766                 return adc_idx[ad1988_pin_idx(nid)];
2767         }
2768 }
2769
2770 /* fill in the dac_nids table from the parsed pin configuration */
2771 static int ad1988_auto_fill_dac_nids(struct hda_codec *codec,
2772                                      const struct auto_pin_cfg *cfg)
2773 {
2774         struct ad198x_spec *spec = codec->spec;
2775         int i, idx;
2776
2777         spec->multiout.dac_nids = spec->private_dac_nids;
2778
2779         /* check the pins hardwired to audio widget */
2780         for (i = 0; i < cfg->line_outs; i++) {
2781                 idx = ad1988_pin_idx(cfg->line_out_pins[i]);
2782                 spec->multiout.dac_nids[i] = ad1988_idx_to_dac(codec, idx);
2783         }
2784         spec->multiout.num_dacs = cfg->line_outs;
2785         return 0;
2786 }
2787
2788 /* add playback controls from the parsed DAC table */
2789 static int ad1988_auto_create_multi_out_ctls(struct ad198x_spec *spec,
2790                                              const struct auto_pin_cfg *cfg)
2791 {
2792         char name[32];
2793         static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
2794         hda_nid_t nid;
2795         int i, err;
2796
2797         for (i = 0; i < cfg->line_outs; i++) {
2798                 hda_nid_t dac = spec->multiout.dac_nids[i];
2799                 if (! dac)
2800                         continue;
2801                 nid = ad1988_mixer_nids[ad1988_pin_idx(cfg->line_out_pins[i])];
2802                 if (i == 2) {
2803                         /* Center/LFE */
2804                         err = add_control(spec, AD_CTL_WIDGET_VOL,
2805                                           "Center Playback Volume",
2806                                           HDA_COMPOSE_AMP_VAL(dac, 1, 0, HDA_OUTPUT));
2807                         if (err < 0)
2808                                 return err;
2809                         err = add_control(spec, AD_CTL_WIDGET_VOL,
2810                                           "LFE Playback Volume",
2811                                           HDA_COMPOSE_AMP_VAL(dac, 2, 0, HDA_OUTPUT));
2812                         if (err < 0)
2813                                 return err;
2814                         err = add_control(spec, AD_CTL_BIND_MUTE,
2815                                           "Center Playback Switch",
2816                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT));
2817                         if (err < 0)
2818                                 return err;
2819                         err = add_control(spec, AD_CTL_BIND_MUTE,
2820                                           "LFE Playback Switch",
2821                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT));
2822                         if (err < 0)
2823                                 return err;
2824                 } else {
2825                         sprintf(name, "%s Playback Volume", chname[i]);
2826                         err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2827                                           HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT));
2828                         if (err < 0)
2829                                 return err;
2830                         sprintf(name, "%s Playback Switch", chname[i]);
2831                         err = add_control(spec, AD_CTL_BIND_MUTE, name,
2832                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
2833                         if (err < 0)
2834                                 return err;
2835                 }
2836         }
2837         return 0;
2838 }
2839
2840 /* add playback controls for speaker and HP outputs */
2841 static int ad1988_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
2842                                         const char *pfx)
2843 {
2844         struct ad198x_spec *spec = codec->spec;
2845         hda_nid_t nid;
2846         int i, idx, err;
2847         char name[32];
2848
2849         if (! pin)
2850                 return 0;
2851
2852         idx = ad1988_pin_idx(pin);
2853         nid = ad1988_idx_to_dac(codec, idx);
2854         /* check whether the corresponding DAC was already taken */
2855         for (i = 0; i < spec->autocfg.line_outs; i++) {
2856                 hda_nid_t pin = spec->autocfg.line_out_pins[i];
2857                 hda_nid_t dac = ad1988_idx_to_dac(codec, ad1988_pin_idx(pin));
2858                 if (dac == nid)
2859                         break;
2860         }
2861         if (i >= spec->autocfg.line_outs) {
2862                 /* specify the DAC as the extra output */
2863                 if (!spec->multiout.hp_nid)
2864                         spec->multiout.hp_nid = nid;
2865                 else
2866                         spec->multiout.extra_out_nid[0] = nid;
2867                 /* control HP volume/switch on the output mixer amp */
2868                 sprintf(name, "%s Playback Volume", pfx);
2869                 err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2870                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
2871                 if (err < 0)
2872                         return err;
2873         }
2874         nid = ad1988_mixer_nids[idx];
2875         sprintf(name, "%s Playback Switch", pfx);
2876         if ((err = add_control(spec, AD_CTL_BIND_MUTE, name,
2877                                HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
2878                 return err;
2879         return 0;
2880 }
2881
2882 /* create input playback/capture controls for the given pin */
2883 static int new_analog_input(struct ad198x_spec *spec, hda_nid_t pin,
2884                             const char *ctlname, int boost)
2885 {
2886         char name[32];
2887         int err, idx;
2888
2889         sprintf(name, "%s Playback Volume", ctlname);
2890         idx = ad1988_pin_to_loopback_idx(pin);
2891         if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2892                                HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2893                 return err;
2894         sprintf(name, "%s Playback Switch", ctlname);
2895         if ((err = add_control(spec, AD_CTL_WIDGET_MUTE, name,
2896                                HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2897                 return err;
2898         if (boost) {
2899                 hda_nid_t bnid;
2900                 idx = ad1988_pin_idx(pin);
2901                 bnid = ad1988_boost_nids[idx];
2902                 if (bnid) {
2903                         sprintf(name, "%s Boost", ctlname);
2904                         return add_control(spec, AD_CTL_WIDGET_VOL, name,
2905                                            HDA_COMPOSE_AMP_VAL(bnid, 3, idx, HDA_OUTPUT));
2906
2907                 }
2908         }
2909         return 0;
2910 }
2911
2912 /* create playback/capture controls for input pins */
2913 static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec,
2914                                                 const struct auto_pin_cfg *cfg)
2915 {
2916         struct hda_input_mux *imux = &spec->private_imux;
2917         int i, err;
2918
2919         for (i = 0; i < AUTO_PIN_LAST; i++) {
2920                 err = new_analog_input(spec, cfg->input_pins[i],
2921                                        auto_pin_cfg_labels[i],
2922                                        i <= AUTO_PIN_FRONT_MIC);
2923                 if (err < 0)
2924                         return err;
2925                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2926                 imux->items[imux->num_items].index = ad1988_pin_to_adc_idx(cfg->input_pins[i]);
2927                 imux->num_items++;
2928         }
2929         imux->items[imux->num_items].label = "Mix";
2930         imux->items[imux->num_items].index = 9;
2931         imux->num_items++;
2932
2933         if ((err = add_control(spec, AD_CTL_WIDGET_VOL,
2934                                "Analog Mix Playback Volume",
2935                                HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2936                 return err;
2937         if ((err = add_control(spec, AD_CTL_WIDGET_MUTE,
2938                                "Analog Mix Playback Switch",
2939                                HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2940                 return err;
2941
2942         return 0;
2943 }
2944
2945 static void ad1988_auto_set_output_and_unmute(struct hda_codec *codec,
2946                                               hda_nid_t nid, int pin_type,
2947                                               int dac_idx)
2948 {
2949         /* set as output */
2950         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2951         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
2952         switch (nid) {
2953         case 0x11: /* port-A - DAC 04 */
2954                 snd_hda_codec_write(codec, 0x37, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2955                 break;
2956         case 0x14: /* port-B - DAC 06 */
2957                 snd_hda_codec_write(codec, 0x30, 0, AC_VERB_SET_CONNECT_SEL, 0x02);
2958                 break;
2959         case 0x15: /* port-C - DAC 05 */
2960                 snd_hda_codec_write(codec, 0x31, 0, AC_VERB_SET_CONNECT_SEL, 0x00);
2961                 break;
2962         case 0x17: /* port-E - DAC 0a */
2963                 snd_hda_codec_write(codec, 0x32, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2964                 break;
2965         case 0x13: /* mono - DAC 04 */
2966                 snd_hda_codec_write(codec, 0x36, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2967                 break;
2968         }
2969 }
2970
2971 static void ad1988_auto_init_multi_out(struct hda_codec *codec)
2972 {
2973         struct ad198x_spec *spec = codec->spec;
2974         int i;
2975
2976         for (i = 0; i < spec->autocfg.line_outs; i++) {
2977                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2978                 ad1988_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
2979         }
2980 }
2981
2982 static void ad1988_auto_init_extra_out(struct hda_codec *codec)
2983 {
2984         struct ad198x_spec *spec = codec->spec;
2985         hda_nid_t pin;
2986
2987         pin = spec->autocfg.speaker_pins[0];
2988         if (pin) /* connect to front */
2989                 ad1988_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
2990         pin = spec->autocfg.hp_pins[0];
2991         if (pin) /* connect to front */
2992                 ad1988_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
2993 }
2994
2995 static void ad1988_auto_init_analog_input(struct hda_codec *codec)
2996 {
2997         struct ad198x_spec *spec = codec->spec;
2998         int i, idx;
2999
3000         for (i = 0; i < AUTO_PIN_LAST; i++) {
3001                 hda_nid_t nid = spec->autocfg.input_pins[i];
3002                 if (! nid)
3003                         continue;
3004                 switch (nid) {
3005                 case 0x15: /* port-C */
3006                         snd_hda_codec_write(codec, 0x33, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
3007                         break;
3008                 case 0x17: /* port-E */
3009                         snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
3010                         break;
3011                 }
3012                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3013                                     i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
3014                 if (nid != AD1988_PIN_CD_NID)
3015                         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3016                                             AMP_OUT_MUTE);
3017                 idx = ad1988_pin_idx(nid);
3018                 if (ad1988_boost_nids[idx])
3019                         snd_hda_codec_write(codec, ad1988_boost_nids[idx], 0,
3020                                             AC_VERB_SET_AMP_GAIN_MUTE,
3021                                             AMP_OUT_ZERO);
3022         }
3023 }
3024
3025 /* parse the BIOS configuration and set up the alc_spec */
3026 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
3027 static int ad1988_parse_auto_config(struct hda_codec *codec)
3028 {
3029         struct ad198x_spec *spec = codec->spec;
3030         int err;
3031
3032         if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3033                 return err;
3034         if ((err = ad1988_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
3035                 return err;
3036         if (! spec->autocfg.line_outs)
3037                 return 0; /* can't find valid BIOS pin config */
3038         if ((err = ad1988_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
3039             (err = ad1988_auto_create_extra_out(codec,
3040                                                 spec->autocfg.speaker_pins[0],
3041                                                 "Speaker")) < 0 ||
3042             (err = ad1988_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
3043                                                 "Headphone")) < 0 ||
3044             (err = ad1988_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
3045                 return err;
3046
3047         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3048
3049         if (spec->autocfg.dig_outs)
3050                 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3051         if (spec->autocfg.dig_in_pin)
3052                 spec->dig_in_nid = AD1988_SPDIF_IN;
3053
3054         if (spec->kctls.list)
3055                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3056
3057         spec->init_verbs[spec->num_init_verbs++] = ad1988_6stack_init_verbs;
3058
3059         spec->input_mux = &spec->private_imux;
3060
3061         return 1;
3062 }
3063
3064 /* init callback for auto-configuration model -- overriding the default init */
3065 static int ad1988_auto_init(struct hda_codec *codec)
3066 {
3067         ad198x_init(codec);
3068         ad1988_auto_init_multi_out(codec);
3069         ad1988_auto_init_extra_out(codec);
3070         ad1988_auto_init_analog_input(codec);
3071         return 0;
3072 }
3073
3074
3075 /*
3076  */
3077
3078 static const char *ad1988_models[AD1988_MODEL_LAST] = {
3079         [AD1988_6STACK]         = "6stack",
3080         [AD1988_6STACK_DIG]     = "6stack-dig",
3081         [AD1988_3STACK]         = "3stack",
3082         [AD1988_3STACK_DIG]     = "3stack-dig",
3083         [AD1988_LAPTOP]         = "laptop",
3084         [AD1988_LAPTOP_DIG]     = "laptop-dig",
3085         [AD1988_AUTO]           = "auto",
3086 };
3087
3088 static struct snd_pci_quirk ad1988_cfg_tbl[] = {
3089         SND_PCI_QUIRK(0x1043, 0x81ec, "Asus P5B-DLX", AD1988_6STACK_DIG),
3090         SND_PCI_QUIRK(0x1043, 0x81f6, "Asus M2N-SLI", AD1988_6STACK_DIG),
3091         SND_PCI_QUIRK(0x1043, 0x8277, "Asus P5K-E/WIFI-AP", AD1988_6STACK_DIG),
3092         SND_PCI_QUIRK(0x1043, 0x8311, "Asus P5Q-Premium/Pro", AD1988_6STACK_DIG),
3093         {}
3094 };
3095
3096 static int patch_ad1988(struct hda_codec *codec)
3097 {
3098         struct ad198x_spec *spec;
3099         int err, board_config;
3100
3101         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3102         if (spec == NULL)
3103                 return -ENOMEM;
3104
3105         codec->spec = spec;
3106
3107         if (is_rev2(codec))
3108                 snd_printk(KERN_INFO "patch_analog: AD1988A rev.2 is detected, enable workarounds\n");
3109
3110         board_config = snd_hda_check_board_config(codec, AD1988_MODEL_LAST,
3111                                                   ad1988_models, ad1988_cfg_tbl);
3112         if (board_config < 0) {
3113                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
3114                        codec->chip_name);
3115                 board_config = AD1988_AUTO;
3116         }
3117
3118         if (board_config == AD1988_AUTO) {
3119                 /* automatic parse from the BIOS config */
3120                 err = ad1988_parse_auto_config(codec);
3121                 if (err < 0) {
3122                         ad198x_free(codec);
3123                         return err;
3124                 } else if (! err) {
3125                         printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using 6-stack mode...\n");
3126                         board_config = AD1988_6STACK;
3127                 }
3128         }
3129
3130         err = snd_hda_attach_beep_device(codec, 0x10);
3131         if (err < 0) {
3132                 ad198x_free(codec);
3133                 return err;
3134         }
3135         set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
3136
3137         switch (board_config) {
3138         case AD1988_6STACK:
3139         case AD1988_6STACK_DIG:
3140                 spec->multiout.max_channels = 8;
3141                 spec->multiout.num_dacs = 4;
3142                 if (is_rev2(codec))
3143                         spec->multiout.dac_nids = ad1988_6stack_dac_nids_rev2;
3144                 else
3145                         spec->multiout.dac_nids = ad1988_6stack_dac_nids;
3146                 spec->input_mux = &ad1988_6stack_capture_source;
3147                 spec->num_mixers = 2;
3148                 if (is_rev2(codec))
3149                         spec->mixers[0] = ad1988_6stack_mixers1_rev2;
3150                 else
3151                         spec->mixers[0] = ad1988_6stack_mixers1;
3152                 spec->mixers[1] = ad1988_6stack_mixers2;
3153                 spec->num_init_verbs = 1;
3154                 spec->init_verbs[0] = ad1988_6stack_init_verbs;
3155                 if (board_config == AD1988_6STACK_DIG) {
3156                         spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3157                         spec->dig_in_nid = AD1988_SPDIF_IN;
3158                 }
3159                 break;
3160         case AD1988_3STACK:
3161         case AD1988_3STACK_DIG:
3162                 spec->multiout.max_channels = 6;
3163                 spec->multiout.num_dacs = 3;
3164                 if (is_rev2(codec))
3165                         spec->multiout.dac_nids = ad1988_3stack_dac_nids_rev2;
3166                 else
3167                         spec->multiout.dac_nids = ad1988_3stack_dac_nids;
3168                 spec->input_mux = &ad1988_6stack_capture_source;
3169                 spec->channel_mode = ad1988_3stack_modes;
3170                 spec->num_channel_mode = ARRAY_SIZE(ad1988_3stack_modes);
3171                 spec->num_mixers = 2;
3172                 if (is_rev2(codec))
3173                         spec->mixers[0] = ad1988_3stack_mixers1_rev2;
3174                 else
3175                         spec->mixers[0] = ad1988_3stack_mixers1;
3176                 spec->mixers[1] = ad1988_3stack_mixers2;
3177                 spec->num_init_verbs = 1;
3178                 spec->init_verbs[0] = ad1988_3stack_init_verbs;
3179                 if (board_config == AD1988_3STACK_DIG)
3180                         spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3181                 break;
3182         case AD1988_LAPTOP:
3183         case AD1988_LAPTOP_DIG:
3184                 spec->multiout.max_channels = 2;
3185                 spec->multiout.num_dacs = 1;
3186                 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
3187                 spec->input_mux = &ad1988_laptop_capture_source;
3188                 spec->num_mixers = 1;
3189                 spec->mixers[0] = ad1988_laptop_mixers;
3190                 spec->inv_eapd = 1; /* inverted EAPD */
3191                 spec->num_init_verbs = 1;
3192                 spec->init_verbs[0] = ad1988_laptop_init_verbs;
3193                 if (board_config == AD1988_LAPTOP_DIG)
3194                         spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3195                 break;
3196         }
3197
3198         spec->num_adc_nids = ARRAY_SIZE(ad1988_adc_nids);
3199         spec->adc_nids = ad1988_adc_nids;
3200         spec->capsrc_nids = ad1988_capsrc_nids;
3201         spec->mixers[spec->num_mixers++] = ad1988_capture_mixers;
3202         spec->init_verbs[spec->num_init_verbs++] = ad1988_capture_init_verbs;
3203         if (spec->multiout.dig_out_nid) {
3204                 if (codec->vendor_id >= 0x11d4989a) {
3205                         spec->mixers[spec->num_mixers++] =
3206                                 ad1989_spdif_out_mixers;
3207                         spec->init_verbs[spec->num_init_verbs++] =
3208                                 ad1989_spdif_init_verbs;
3209                         codec->slave_dig_outs = ad1989b_slave_dig_outs;
3210                 } else {
3211                         spec->mixers[spec->num_mixers++] =
3212                                 ad1988_spdif_out_mixers;
3213                         spec->init_verbs[spec->num_init_verbs++] =
3214                                 ad1988_spdif_init_verbs;
3215                 }
3216         }
3217         if (spec->dig_in_nid && codec->vendor_id < 0x11d4989a) {
3218                 spec->mixers[spec->num_mixers++] = ad1988_spdif_in_mixers;
3219                 spec->init_verbs[spec->num_init_verbs++] =
3220                         ad1988_spdif_in_init_verbs;
3221         }
3222
3223         codec->patch_ops = ad198x_patch_ops;
3224         switch (board_config) {
3225         case AD1988_AUTO:
3226                 codec->patch_ops.init = ad1988_auto_init;
3227                 break;
3228         case AD1988_LAPTOP:
3229         case AD1988_LAPTOP_DIG:
3230                 codec->patch_ops.unsol_event = ad1988_laptop_unsol_event;
3231                 break;
3232         }
3233 #ifdef CONFIG_SND_HDA_POWER_SAVE
3234         spec->loopback.amplist = ad1988_loopbacks;
3235 #endif
3236         spec->vmaster_nid = 0x04;
3237
3238         codec->no_trigger_sense = 1;
3239
3240         return 0;
3241 }
3242
3243
3244 /*
3245  * AD1884 / AD1984
3246  *
3247  * port-B - front line/mic-in
3248  * port-E - aux in/out
3249  * port-F - aux in/out
3250  * port-C - rear line/mic-in
3251  * port-D - rear line/hp-out
3252  * port-A - front line/hp-out
3253  *
3254  * AD1984 = AD1884 + two digital mic-ins
3255  *
3256  * FIXME:
3257  * For simplicity, we share the single DAC for both HP and line-outs
3258  * right now.  The inidividual playbacks could be easily implemented,
3259  * but no build-up framework is given, so far.
3260  */
3261
3262 static hda_nid_t ad1884_dac_nids[1] = {
3263         0x04,
3264 };
3265
3266 static hda_nid_t ad1884_adc_nids[2] = {
3267         0x08, 0x09,
3268 };
3269
3270 static hda_nid_t ad1884_capsrc_nids[2] = {
3271         0x0c, 0x0d,
3272 };
3273
3274 #define AD1884_SPDIF_OUT        0x02
3275
3276 static struct hda_input_mux ad1884_capture_source = {
3277         .num_items = 4,
3278         .items = {
3279                 { "Front Mic", 0x0 },
3280                 { "Mic", 0x1 },
3281                 { "CD", 0x2 },
3282                 { "Mix", 0x3 },
3283         },
3284 };
3285
3286 static struct snd_kcontrol_new ad1884_base_mixers[] = {
3287         HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3288         /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3289         HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3290         HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3291         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3292         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3293         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3294         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3295         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3296         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3297         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
3298         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
3299         HDA_CODEC_VOLUME("Mic Boost", 0x15, 0x0, HDA_INPUT),
3300         HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3301         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3302         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3303         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3304         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3305         {
3306                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3307                 /* The multiple "Capture Source" controls confuse alsamixer
3308                  * So call somewhat different..
3309                  */
3310                 /* .name = "Capture Source", */
3311                 .name = "Input Source",
3312                 .count = 2,
3313                 .info = ad198x_mux_enum_info,
3314                 .get = ad198x_mux_enum_get,
3315                 .put = ad198x_mux_enum_put,
3316         },
3317         /* SPDIF controls */
3318         HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3319         {
3320                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3321                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3322                 /* identical with ad1983 */
3323                 .info = ad1983_spdif_route_info,
3324                 .get = ad1983_spdif_route_get,
3325                 .put = ad1983_spdif_route_put,
3326         },
3327         { } /* end */
3328 };
3329
3330 static struct snd_kcontrol_new ad1984_dmic_mixers[] = {
3331         HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x05, 0x0, HDA_INPUT),
3332         HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x05, 0x0, HDA_INPUT),
3333         HDA_CODEC_VOLUME_IDX("Digital Mic Capture Volume", 1, 0x06, 0x0,
3334                              HDA_INPUT),
3335         HDA_CODEC_MUTE_IDX("Digital Mic Capture Switch", 1, 0x06, 0x0,
3336                            HDA_INPUT),
3337         { } /* end */
3338 };
3339
3340 /*
3341  * initialization verbs
3342  */
3343 static struct hda_verb ad1884_init_verbs[] = {
3344         /* DACs; mute as default */
3345         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3346         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3347         /* Port-A (HP) mixer */
3348         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3349         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3350         /* Port-A pin */
3351         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3352         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3353         /* HP selector - select DAC2 */
3354         {0x22, AC_VERB_SET_CONNECT_SEL, 0x1},
3355         /* Port-D (Line-out) mixer */
3356         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3357         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3358         /* Port-D pin */
3359         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3360         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3361         /* Mono-out mixer */
3362         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3363         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3364         /* Mono-out pin */
3365         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3366         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3367         /* Mono selector */
3368         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
3369         /* Port-B (front mic) pin */
3370         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3371         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3372         /* Port-C (rear mic) pin */
3373         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3374         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3375         /* Analog mixer; mute as default */
3376         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3377         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3378         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3379         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3380         /* Analog Mix output amp */
3381         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
3382         /* SPDIF output selector */
3383         {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
3384         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3385         { } /* end */
3386 };
3387
3388 #ifdef CONFIG_SND_HDA_POWER_SAVE
3389 static struct hda_amp_list ad1884_loopbacks[] = {
3390         { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3391         { 0x20, HDA_INPUT, 1 }, /* Mic */
3392         { 0x20, HDA_INPUT, 2 }, /* CD */
3393         { 0x20, HDA_INPUT, 4 }, /* Docking */
3394         { } /* end */
3395 };
3396 #endif
3397
3398 static const char *ad1884_slave_vols[] = {
3399         "PCM Playback Volume",
3400         "Mic Playback Volume",
3401         "Mono Playback Volume",
3402         "Front Mic Playback Volume",
3403         "Mic Playback Volume",
3404         "CD Playback Volume",
3405         "Internal Mic Playback Volume",
3406         "Docking Mic Playback Volume",
3407         /* "Beep Playback Volume", */
3408         "IEC958 Playback Volume",
3409         NULL
3410 };
3411
3412 static int patch_ad1884(struct hda_codec *codec)
3413 {
3414         struct ad198x_spec *spec;
3415         int err;
3416
3417         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3418         if (spec == NULL)
3419                 return -ENOMEM;
3420
3421         codec->spec = spec;
3422
3423         err = snd_hda_attach_beep_device(codec, 0x10);
3424         if (err < 0) {
3425                 ad198x_free(codec);
3426                 return err;
3427         }
3428         set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
3429
3430         spec->multiout.max_channels = 2;
3431         spec->multiout.num_dacs = ARRAY_SIZE(ad1884_dac_nids);
3432         spec->multiout.dac_nids = ad1884_dac_nids;
3433         spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3434         spec->num_adc_nids = ARRAY_SIZE(ad1884_adc_nids);
3435         spec->adc_nids = ad1884_adc_nids;
3436         spec->capsrc_nids = ad1884_capsrc_nids;
3437         spec->input_mux = &ad1884_capture_source;
3438         spec->num_mixers = 1;
3439         spec->mixers[0] = ad1884_base_mixers;
3440         spec->num_init_verbs = 1;
3441         spec->init_verbs[0] = ad1884_init_verbs;
3442         spec->spdif_route = 0;
3443 #ifdef CONFIG_SND_HDA_POWER_SAVE
3444         spec->loopback.amplist = ad1884_loopbacks;
3445 #endif
3446         spec->vmaster_nid = 0x04;
3447         /* we need to cover all playback volumes */
3448         spec->slave_vols = ad1884_slave_vols;
3449
3450         codec->patch_ops = ad198x_patch_ops;
3451
3452         codec->no_trigger_sense = 1;
3453
3454         return 0;
3455 }
3456
3457 /*
3458  * Lenovo Thinkpad T61/X61
3459  */
3460 static struct hda_input_mux ad1984_thinkpad_capture_source = {
3461         .num_items = 4,
3462         .items = {
3463                 { "Mic", 0x0 },
3464                 { "Internal Mic", 0x1 },
3465                 { "Mix", 0x3 },
3466                 { "Docking-Station", 0x4 },
3467         },
3468 };
3469
3470
3471 /*
3472  * Dell Precision T3400
3473  */
3474 static struct hda_input_mux ad1984_dell_desktop_capture_source = {
3475         .num_items = 3,
3476         .items = {
3477                 { "Front Mic", 0x0 },
3478                 { "Line-In", 0x1 },
3479                 { "Mix", 0x3 },
3480         },
3481 };
3482
3483
3484 static struct snd_kcontrol_new ad1984_thinkpad_mixers[] = {
3485         HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3486         /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3487         HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3488         HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3489         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3490         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3491         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3492         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3493         HDA_CODEC_VOLUME("Docking Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3494         HDA_CODEC_MUTE("Docking Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3495         HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
3496         HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT),
3497         HDA_CODEC_VOLUME("Docking Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3498         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3499         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3500         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3501         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3502         {
3503                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3504                 /* The multiple "Capture Source" controls confuse alsamixer
3505                  * So call somewhat different..
3506                  */
3507                 /* .name = "Capture Source", */
3508                 .name = "Input Source",
3509                 .count = 2,
3510                 .info = ad198x_mux_enum_info,
3511                 .get = ad198x_mux_enum_get,
3512                 .put = ad198x_mux_enum_put,
3513         },
3514         /* SPDIF controls */
3515         HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3516         {
3517                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3518                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3519                 /* identical with ad1983 */
3520                 .info = ad1983_spdif_route_info,
3521                 .get = ad1983_spdif_route_get,
3522                 .put = ad1983_spdif_route_put,
3523         },
3524         { } /* end */
3525 };
3526
3527 /* additional verbs */
3528 static struct hda_verb ad1984_thinkpad_init_verbs[] = {
3529         /* Port-E (docking station mic) pin */
3530         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3531         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3532         /* docking mic boost */
3533         {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3534         /* Analog mixer - docking mic; mute as default */
3535         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3536         /* enable EAPD bit */
3537         {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
3538         { } /* end */
3539 };
3540
3541 /*
3542  * Dell Precision T3400
3543  */
3544 static struct snd_kcontrol_new ad1984_dell_desktop_mixers[] = {
3545         HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3546         HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3547         HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3548         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3549         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3550         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3551         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3552         HDA_CODEC_VOLUME("Line-In Playback Volume", 0x20, 0x01, HDA_INPUT),
3553         HDA_CODEC_MUTE("Line-In Playback Switch", 0x20, 0x01, HDA_INPUT),
3554         HDA_CODEC_VOLUME("Line-In Boost", 0x15, 0x0, HDA_INPUT),
3555         HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3556         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3557         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3558         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3559         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3560         {
3561                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3562                 /* The multiple "Capture Source" controls confuse alsamixer
3563                  * So call somewhat different..
3564                  */
3565                 /* .name = "Capture Source", */
3566                 .name = "Input Source",
3567                 .count = 2,
3568                 .info = ad198x_mux_enum_info,
3569                 .get = ad198x_mux_enum_get,
3570                 .put = ad198x_mux_enum_put,
3571         },
3572         { } /* end */
3573 };
3574
3575 /* Digial MIC ADC NID 0x05 + 0x06 */
3576 static int ad1984_pcm_dmic_prepare(struct hda_pcm_stream *hinfo,
3577                                    struct hda_codec *codec,
3578                                    unsigned int stream_tag,
3579                                    unsigned int format,
3580                                    struct snd_pcm_substream *substream)
3581 {
3582         snd_hda_codec_setup_stream(codec, 0x05 + substream->number,
3583                                    stream_tag, 0, format);
3584         return 0;
3585 }
3586
3587 static int ad1984_pcm_dmic_cleanup(struct hda_pcm_stream *hinfo,
3588                                    struct hda_codec *codec,
3589                                    struct snd_pcm_substream *substream)
3590 {
3591         snd_hda_codec_cleanup_stream(codec, 0x05 + substream->number);
3592         return 0;
3593 }
3594
3595 static struct hda_pcm_stream ad1984_pcm_dmic_capture = {
3596         .substreams = 2,
3597         .channels_min = 2,
3598         .channels_max = 2,
3599         .nid = 0x05,
3600         .ops = {
3601                 .prepare = ad1984_pcm_dmic_prepare,
3602                 .cleanup = ad1984_pcm_dmic_cleanup
3603         },
3604 };
3605
3606 static int ad1984_build_pcms(struct hda_codec *codec)
3607 {
3608         struct ad198x_spec *spec = codec->spec;
3609         struct hda_pcm *info;
3610         int err;
3611
3612         err = ad198x_build_pcms(codec);
3613         if (err < 0)
3614                 return err;
3615
3616         info = spec->pcm_rec + codec->num_pcms;
3617         codec->num_pcms++;
3618         info->name = "AD1984 Digital Mic";
3619         info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad1984_pcm_dmic_capture;
3620         return 0;
3621 }
3622
3623 /* models */
3624 enum {
3625         AD1984_BASIC,
3626         AD1984_THINKPAD,
3627         AD1984_DELL_DESKTOP,
3628         AD1984_MODELS
3629 };
3630
3631 static const char *ad1984_models[AD1984_MODELS] = {
3632         [AD1984_BASIC]          = "basic",
3633         [AD1984_THINKPAD]       = "thinkpad",
3634         [AD1984_DELL_DESKTOP]   = "dell_desktop",
3635 };
3636
3637 static struct snd_pci_quirk ad1984_cfg_tbl[] = {
3638         /* Lenovo Thinkpad T61/X61 */
3639         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1984_THINKPAD),
3640         SND_PCI_QUIRK(0x1028, 0x0214, "Dell T3400", AD1984_DELL_DESKTOP),
3641         {}
3642 };
3643
3644 static int patch_ad1984(struct hda_codec *codec)
3645 {
3646         struct ad198x_spec *spec;
3647         int board_config, err;
3648
3649         err = patch_ad1884(codec);
3650         if (err < 0)
3651                 return err;
3652         spec = codec->spec;
3653         board_config = snd_hda_check_board_config(codec, AD1984_MODELS,
3654                                                   ad1984_models, ad1984_cfg_tbl);
3655         switch (board_config) {
3656         case AD1984_BASIC:
3657                 /* additional digital mics */
3658                 spec->mixers[spec->num_mixers++] = ad1984_dmic_mixers;
3659                 codec->patch_ops.build_pcms = ad1984_build_pcms;
3660                 break;
3661         case AD1984_THINKPAD:
3662                 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3663                 spec->input_mux = &ad1984_thinkpad_capture_source;
3664                 spec->mixers[0] = ad1984_thinkpad_mixers;
3665                 spec->init_verbs[spec->num_init_verbs++] = ad1984_thinkpad_init_verbs;
3666                 break;
3667         case AD1984_DELL_DESKTOP:
3668                 spec->multiout.dig_out_nid = 0;
3669                 spec->input_mux = &ad1984_dell_desktop_capture_source;
3670                 spec->mixers[0] = ad1984_dell_desktop_mixers;
3671                 break;
3672         }
3673         return 0;
3674 }
3675
3676
3677 /*
3678  * AD1883 / AD1884A / AD1984A / AD1984B
3679  *
3680  * port-B (0x14) - front mic-in
3681  * port-E (0x1c) - rear mic-in
3682  * port-F (0x16) - CD / ext out
3683  * port-C (0x15) - rear line-in
3684  * port-D (0x12) - rear line-out
3685  * port-A (0x11) - front hp-out
3686  *
3687  * AD1984A = AD1884A + digital-mic
3688  * AD1883 = equivalent with AD1984A
3689  * AD1984B = AD1984A + extra SPDIF-out
3690  *
3691  * FIXME:
3692  * We share the single DAC for both HP and line-outs (see AD1884/1984).
3693  */
3694
3695 static hda_nid_t ad1884a_dac_nids[1] = {
3696         0x03,
3697 };
3698
3699 #define ad1884a_adc_nids        ad1884_adc_nids
3700 #define ad1884a_capsrc_nids     ad1884_capsrc_nids
3701
3702 #define AD1884A_SPDIF_OUT       0x02
3703
3704 static struct hda_input_mux ad1884a_capture_source = {
3705         .num_items = 5,
3706         .items = {
3707                 { "Front Mic", 0x0 },
3708                 { "Mic", 0x4 },
3709                 { "Line", 0x1 },
3710                 { "CD", 0x2 },
3711                 { "Mix", 0x3 },
3712         },
3713 };
3714
3715 static struct snd_kcontrol_new ad1884a_base_mixers[] = {
3716         HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3717         HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
3718         HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3719         HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3720         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3721         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3722         HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3723         HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3724         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3725         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3726         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x01, HDA_INPUT),
3727         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x01, HDA_INPUT),
3728         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3729         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3730         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
3731         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
3732         HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3733         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x0, HDA_INPUT),
3734         HDA_CODEC_VOLUME("Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3735         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3736         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3737         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3738         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3739         {
3740                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3741                 /* The multiple "Capture Source" controls confuse alsamixer
3742                  * So call somewhat different..
3743                  */
3744                 /* .name = "Capture Source", */
3745                 .name = "Input Source",
3746                 .count = 2,
3747                 .info = ad198x_mux_enum_info,
3748                 .get = ad198x_mux_enum_get,
3749                 .put = ad198x_mux_enum_put,
3750         },
3751         /* SPDIF controls */
3752         HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3753         {
3754                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3755                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3756                 /* identical with ad1983 */
3757                 .info = ad1983_spdif_route_info,
3758                 .get = ad1983_spdif_route_get,
3759                 .put = ad1983_spdif_route_put,
3760         },
3761         { } /* end */
3762 };
3763
3764 /*
3765  * initialization verbs
3766  */
3767 static struct hda_verb ad1884a_init_verbs[] = {
3768         /* DACs; unmute as default */
3769         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
3770         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
3771         /* Port-A (HP) mixer - route only from analog mixer */
3772         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3773         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3774         /* Port-A pin */
3775         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3776         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3777         /* Port-D (Line-out) mixer - route only from analog mixer */
3778         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3779         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3780         /* Port-D pin */
3781         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3782         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3783         /* Mono-out mixer - route only from analog mixer */
3784         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3785         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3786         /* Mono-out pin */
3787         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3788         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3789         /* Port-B (front mic) pin */
3790         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3791         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3792         /* Port-C (rear line-in) pin */
3793         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3794         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3795         /* Port-E (rear mic) pin */
3796         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3797         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3798         {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* no boost */
3799         /* Port-F (CD) pin */
3800         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3801         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3802         /* Analog mixer; mute as default */
3803         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3804         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3805         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3806         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3807         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, /* aux */
3808         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
3809         /* Analog Mix output amp */
3810         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3811         /* capture sources */
3812         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
3813         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3814         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
3815         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3816         /* SPDIF output amp */
3817         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3818         { } /* end */
3819 };
3820
3821 #ifdef CONFIG_SND_HDA_POWER_SAVE
3822 static struct hda_amp_list ad1884a_loopbacks[] = {
3823         { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3824         { 0x20, HDA_INPUT, 1 }, /* Mic */
3825         { 0x20, HDA_INPUT, 2 }, /* CD */
3826         { 0x20, HDA_INPUT, 4 }, /* Docking */
3827         { } /* end */
3828 };
3829 #endif
3830
3831 /*
3832  * Laptop model
3833  *
3834  * Port A: Headphone jack
3835  * Port B: MIC jack
3836  * Port C: Internal MIC
3837  * Port D: Dock Line Out (if enabled)
3838  * Port E: Dock Line In (if enabled)
3839  * Port F: Internal speakers
3840  */
3841
3842 static int ad1884a_mobile_master_sw_put(struct snd_kcontrol *kcontrol,
3843                                         struct snd_ctl_elem_value *ucontrol)
3844 {
3845         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3846         int ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3847         int mute = (!ucontrol->value.integer.value[0] &&
3848                     !ucontrol->value.integer.value[1]);
3849         /* toggle GPIO1 according to the mute state */
3850         snd_hda_codec_write_cache(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
3851                             mute ? 0x02 : 0x0);
3852         return ret;
3853 }
3854
3855 static struct snd_kcontrol_new ad1884a_laptop_mixers[] = {
3856         HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3857         {
3858                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3859                 .name = "Master Playback Switch",
3860                 .subdevice = HDA_SUBDEV_AMP_FLAG,
3861                 .info = snd_hda_mixer_amp_switch_info,
3862                 .get = snd_hda_mixer_amp_switch_get,
3863                 .put = ad1884a_mobile_master_sw_put,
3864                 .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
3865         },
3866         HDA_CODEC_MUTE("Dock Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3867         HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3868         HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3869         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3870         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3871         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3872         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3873         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3874         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3875         HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
3876         HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT),
3877         HDA_CODEC_VOLUME("Dock Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3878         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3879         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3880         { } /* end */
3881 };
3882
3883 static struct snd_kcontrol_new ad1884a_mobile_mixers[] = {
3884         HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3885         /*HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),*/
3886         {
3887                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3888                 .name = "Master Playback Switch",
3889                 .subdevice = HDA_SUBDEV_AMP_FLAG,
3890                 .info = snd_hda_mixer_amp_switch_info,
3891                 .get = snd_hda_mixer_amp_switch_get,
3892                 .put = ad1884a_mobile_master_sw_put,
3893                 .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
3894         },
3895         HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3896         HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3897         HDA_CODEC_VOLUME("Mic Capture Volume", 0x14, 0x0, HDA_INPUT),
3898         HDA_CODEC_VOLUME("Internal Mic Capture Volume", 0x15, 0x0, HDA_INPUT),
3899         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3900         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3901         { } /* end */
3902 };
3903
3904 /* mute internal speaker if HP is plugged */
3905 static void ad1884a_hp_automute(struct hda_codec *codec)
3906 {
3907         unsigned int present;
3908
3909         present = snd_hda_jack_detect(codec, 0x11);
3910         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
3911                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
3912         snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE,
3913                             present ? 0x00 : 0x02);
3914 }
3915
3916 /* switch to external mic if plugged */
3917 static void ad1884a_hp_automic(struct hda_codec *codec)
3918 {
3919         unsigned int present;
3920
3921         present = snd_hda_jack_detect(codec, 0x14);
3922         snd_hda_codec_write(codec, 0x0c, 0, AC_VERB_SET_CONNECT_SEL,
3923                             present ? 0 : 1);
3924 }
3925
3926 #define AD1884A_HP_EVENT                0x37
3927 #define AD1884A_MIC_EVENT               0x36
3928
3929 /* unsolicited event for HP jack sensing */
3930 static void ad1884a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
3931 {
3932         switch (res >> 26) {
3933         case AD1884A_HP_EVENT:
3934                 ad1884a_hp_automute(codec);
3935                 break;
3936         case AD1884A_MIC_EVENT:
3937                 ad1884a_hp_automic(codec);
3938                 break;
3939         }
3940 }
3941
3942 /* initialize jack-sensing, too */
3943 static int ad1884a_hp_init(struct hda_codec *codec)
3944 {
3945         ad198x_init(codec);
3946         ad1884a_hp_automute(codec);
3947         ad1884a_hp_automic(codec);
3948         return 0;
3949 }
3950
3951 /* mute internal speaker if HP or docking HP is plugged */
3952 static void ad1884a_laptop_automute(struct hda_codec *codec)
3953 {
3954         unsigned int present;
3955
3956         present = snd_hda_jack_detect(codec, 0x11);
3957         if (!present)
3958                 present = snd_hda_jack_detect(codec, 0x12);
3959         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
3960                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
3961         snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE,
3962                             present ? 0x00 : 0x02);
3963 }
3964
3965 /* switch to external mic if plugged */
3966 static void ad1884a_laptop_automic(struct hda_codec *codec)
3967 {
3968         unsigned int idx;
3969
3970         if (snd_hda_jack_detect(codec, 0x14))
3971                 idx = 0;
3972         else if (snd_hda_jack_detect(codec, 0x1c))
3973                 idx = 4;
3974         else
3975                 idx = 1;
3976         snd_hda_codec_write(codec, 0x0c, 0, AC_VERB_SET_CONNECT_SEL, idx);
3977 }
3978
3979 /* unsolicited event for HP jack sensing */
3980 static void ad1884a_laptop_unsol_event(struct hda_codec *codec,
3981                                        unsigned int res)
3982 {
3983         switch (res >> 26) {
3984         case AD1884A_HP_EVENT:
3985                 ad1884a_laptop_automute(codec);
3986                 break;
3987         case AD1884A_MIC_EVENT:
3988                 ad1884a_laptop_automic(codec);
3989                 break;
3990         }
3991 }
3992
3993 /* initialize jack-sensing, too */
3994 static int ad1884a_laptop_init(struct hda_codec *codec)
3995 {
3996         ad198x_init(codec);
3997         ad1884a_laptop_automute(codec);
3998         ad1884a_laptop_automic(codec);
3999         return 0;
4000 }
4001
4002 /* additional verbs for laptop model */
4003 static struct hda_verb ad1884a_laptop_verbs[] = {
4004         /* Port-A (HP) pin - always unmuted */
4005         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4006         /* Port-F (int speaker) mixer - route only from analog mixer */
4007         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4008         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4009         /* Port-F (int speaker) pin */
4010         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4011         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4012         /* required for compaq 6530s/6531s speaker output */
4013         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4014         /* Port-C pin - internal mic-in */
4015         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4016         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
4017         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
4018         /* Port-D (docking line-out) pin - default unmuted */
4019         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4020         /* analog mix */
4021         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4022         /* unsolicited event for pin-sense */
4023         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4024         {0x12, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4025         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
4026         {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
4027         /* allow to touch GPIO1 (for mute control) */
4028         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
4029         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
4030         {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */
4031         { } /* end */
4032 };
4033
4034 static struct hda_verb ad1884a_mobile_verbs[] = {
4035         /* DACs; unmute as default */
4036         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4037         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4038         /* Port-A (HP) mixer - route only from analog mixer */
4039         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4040         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4041         /* Port-A pin */
4042         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4043         /* Port-A (HP) pin - always unmuted */
4044         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4045         /* Port-B (mic jack) pin */
4046         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4047         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
4048         /* Port-C (int mic) pin */
4049         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4050         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
4051         /* Port-F (int speaker) mixer - route only from analog mixer */
4052         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4053         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4054         /* Port-F pin */
4055         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4056         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4057         /* Analog mixer; mute as default */
4058         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4059         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4060         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4061         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4062         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4063         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
4064         /* Analog Mix output amp */
4065         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4066         /* capture sources */
4067         /* {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0}, */ /* set via unsol */
4068         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4069         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
4070         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4071         /* unsolicited event for pin-sense */
4072         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4073         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
4074         /* allow to touch GPIO1 (for mute control) */
4075         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
4076         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
4077         {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */
4078         { } /* end */
4079 };
4080
4081 /*
4082  * Thinkpad X300
4083  * 0x11 - HP
4084  * 0x12 - speaker
4085  * 0x14 - mic-in
4086  * 0x17 - built-in mic
4087  */
4088
4089 static struct hda_verb ad1984a_thinkpad_verbs[] = {
4090         /* HP unmute */
4091         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4092         /* analog mix */
4093         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4094         /* turn on EAPD */
4095         {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4096         /* unsolicited event for pin-sense */
4097         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4098         /* internal mic - dmic */
4099         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4100         /* set magic COEFs for dmic */
4101         {0x01, AC_VERB_SET_COEF_INDEX, 0x13f7},
4102         {0x01, AC_VERB_SET_PROC_COEF, 0x08},
4103         { } /* end */
4104 };
4105
4106 static struct snd_kcontrol_new ad1984a_thinkpad_mixers[] = {
4107         HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
4108         HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
4109         HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
4110         HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
4111         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4112         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4113         HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
4114         HDA_CODEC_VOLUME("Internal Mic Boost", 0x17, 0x0, HDA_INPUT),
4115         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4116         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4117         {
4118                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4119                 .name = "Capture Source",
4120                 .info = ad198x_mux_enum_info,
4121                 .get = ad198x_mux_enum_get,
4122                 .put = ad198x_mux_enum_put,
4123         },
4124         { } /* end */
4125 };
4126
4127 static struct hda_input_mux ad1984a_thinkpad_capture_source = {
4128         .num_items = 3,
4129         .items = {
4130                 { "Mic", 0x0 },
4131                 { "Internal Mic", 0x5 },
4132                 { "Mix", 0x3 },
4133         },
4134 };
4135
4136 /* mute internal speaker if HP is plugged */
4137 static void ad1984a_thinkpad_automute(struct hda_codec *codec)
4138 {
4139         unsigned int present;
4140
4141         present = snd_hda_jack_detect(codec, 0x11);
4142         snd_hda_codec_amp_stereo(codec, 0x12, HDA_OUTPUT, 0,
4143                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
4144 }
4145
4146 /* unsolicited event for HP jack sensing */
4147 static void ad1984a_thinkpad_unsol_event(struct hda_codec *codec,
4148                                          unsigned int res)
4149 {
4150         if ((res >> 26) != AD1884A_HP_EVENT)
4151                 return;
4152         ad1984a_thinkpad_automute(codec);
4153 }
4154
4155 /* initialize jack-sensing, too */
4156 static int ad1984a_thinkpad_init(struct hda_codec *codec)
4157 {
4158         ad198x_init(codec);
4159         ad1984a_thinkpad_automute(codec);
4160         return 0;
4161 }
4162
4163 /*
4164  * HP Touchsmart
4165  * port-A (0x11)      - front hp-out
4166  * port-B (0x14)      - unused
4167  * port-C (0x15)      - unused
4168  * port-D (0x12)      - rear line out
4169  * port-E (0x1c)      - front mic-in
4170  * port-F (0x16)      - Internal speakers
4171  * digital-mic (0x17) - Internal mic
4172  */
4173
4174 static struct hda_verb ad1984a_touchsmart_verbs[] = {
4175         /* DACs; unmute as default */
4176         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4177         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4178         /* Port-A (HP) mixer - route only from analog mixer */
4179         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4180         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4181         /* Port-A pin */
4182         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4183         /* Port-A (HP) pin - always unmuted */
4184         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4185         /* Port-E (int speaker) mixer - route only from analog mixer */
4186         {0x25, AC_VERB_SET_AMP_GAIN_MUTE, 0x03},
4187         /* Port-E pin */
4188         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4189         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4190         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4191         /* Port-F (int speaker) mixer - route only from analog mixer */
4192         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4193         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4194         /* Port-F pin */
4195         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4196         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4197         /* Analog mixer; mute as default */
4198         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4199         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4200         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4201         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4202         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4203         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
4204         /* Analog Mix output amp */
4205         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4206         /* capture sources */
4207         /* {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0}, */ /* set via unsol */
4208         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4209         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
4210         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4211         /* unsolicited event for pin-sense */
4212         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4213         {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
4214         /* allow to touch GPIO1 (for mute control) */
4215         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
4216         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
4217         {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */
4218         /* internal mic - dmic */
4219         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4220         /* set magic COEFs for dmic */
4221         {0x01, AC_VERB_SET_COEF_INDEX, 0x13f7},
4222         {0x01, AC_VERB_SET_PROC_COEF, 0x08},
4223         { } /* end */
4224 };
4225
4226 static struct snd_kcontrol_new ad1984a_touchsmart_mixers[] = {
4227         HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
4228 /*      HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),*/
4229         {
4230                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4231                 .subdevice = HDA_SUBDEV_AMP_FLAG,
4232                 .name = "Master Playback Switch",
4233                 .info = snd_hda_mixer_amp_switch_info,
4234                 .get = snd_hda_mixer_amp_switch_get,
4235                 .put = ad1884a_mobile_master_sw_put,
4236                 .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
4237         },
4238         HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
4239         HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
4240         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4241         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4242         HDA_CODEC_VOLUME("Mic Boost", 0x25, 0x0, HDA_OUTPUT),
4243         HDA_CODEC_VOLUME("Internal Mic Boost", 0x17, 0x0, HDA_INPUT),
4244         { } /* end */
4245 };
4246
4247 /* switch to external mic if plugged */
4248 static void ad1984a_touchsmart_automic(struct hda_codec *codec)
4249 {
4250         if (snd_hda_jack_detect(codec, 0x1c))
4251                 snd_hda_codec_write(codec, 0x0c, 0,
4252                                      AC_VERB_SET_CONNECT_SEL, 0x4);
4253         else
4254                 snd_hda_codec_write(codec, 0x0c, 0,
4255                                      AC_VERB_SET_CONNECT_SEL, 0x5);
4256 }
4257
4258
4259 /* unsolicited event for HP jack sensing */
4260 static void ad1984a_touchsmart_unsol_event(struct hda_codec *codec,
4261         unsigned int res)
4262 {
4263         switch (res >> 26) {
4264         case AD1884A_HP_EVENT:
4265                 ad1884a_hp_automute(codec);
4266                 break;
4267         case AD1884A_MIC_EVENT:
4268                 ad1984a_touchsmart_automic(codec);
4269                 break;
4270         }
4271 }
4272
4273 /* initialize jack-sensing, too */
4274 static int ad1984a_touchsmart_init(struct hda_codec *codec)
4275 {
4276         ad198x_init(codec);
4277         ad1884a_hp_automute(codec);
4278         ad1984a_touchsmart_automic(codec);
4279         return 0;
4280 }
4281
4282
4283 /*
4284  */
4285
4286 enum {
4287         AD1884A_DESKTOP,
4288         AD1884A_LAPTOP,
4289         AD1884A_MOBILE,
4290         AD1884A_THINKPAD,
4291         AD1984A_TOUCHSMART,
4292         AD1884A_MODELS
4293 };
4294
4295 static const char *ad1884a_models[AD1884A_MODELS] = {
4296         [AD1884A_DESKTOP]       = "desktop",
4297         [AD1884A_LAPTOP]        = "laptop",
4298         [AD1884A_MOBILE]        = "mobile",
4299         [AD1884A_THINKPAD]      = "thinkpad",
4300         [AD1984A_TOUCHSMART]    = "touchsmart",
4301 };
4302
4303 static struct snd_pci_quirk ad1884a_cfg_tbl[] = {
4304         SND_PCI_QUIRK(0x103c, 0x3030, "HP", AD1884A_MOBILE),
4305         SND_PCI_QUIRK(0x103c, 0x3037, "HP 2230s", AD1884A_LAPTOP),
4306         SND_PCI_QUIRK(0x103c, 0x3056, "HP", AD1884A_MOBILE),
4307         SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x3070, "HP", AD1884A_MOBILE),
4308         SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x30d0, "HP laptop", AD1884A_LAPTOP),
4309         SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x30e0, "HP laptop", AD1884A_LAPTOP),
4310         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3600, "HP laptop", AD1884A_LAPTOP),
4311         SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x7010, "HP laptop", AD1884A_MOBILE),
4312         SND_PCI_QUIRK(0x17aa, 0x20ac, "Thinkpad X300", AD1884A_THINKPAD),
4313         SND_PCI_QUIRK(0x103c, 0x2a82, "Touchsmart", AD1984A_TOUCHSMART),
4314         {}
4315 };
4316
4317 static int patch_ad1884a(struct hda_codec *codec)
4318 {
4319         struct ad198x_spec *spec;
4320         int err, board_config;
4321
4322         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4323         if (spec == NULL)
4324                 return -ENOMEM;
4325
4326         codec->spec = spec;
4327
4328         err = snd_hda_attach_beep_device(codec, 0x10);
4329         if (err < 0) {
4330                 ad198x_free(codec);
4331                 return err;
4332         }
4333         set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
4334
4335         spec->multiout.max_channels = 2;
4336         spec->multiout.num_dacs = ARRAY_SIZE(ad1884a_dac_nids);
4337         spec->multiout.dac_nids = ad1884a_dac_nids;
4338         spec->multiout.dig_out_nid = AD1884A_SPDIF_OUT;
4339         spec->num_adc_nids = ARRAY_SIZE(ad1884a_adc_nids);
4340         spec->adc_nids = ad1884a_adc_nids;
4341         spec->capsrc_nids = ad1884a_capsrc_nids;
4342         spec->input_mux = &ad1884a_capture_source;
4343         spec->num_mixers = 1;
4344         spec->mixers[0] = ad1884a_base_mixers;
4345         spec->num_init_verbs = 1;
4346         spec->init_verbs[0] = ad1884a_init_verbs;
4347         spec->spdif_route = 0;
4348 #ifdef CONFIG_SND_HDA_POWER_SAVE
4349         spec->loopback.amplist = ad1884a_loopbacks;
4350 #endif
4351         codec->patch_ops = ad198x_patch_ops;
4352
4353         /* override some parameters */
4354         board_config = snd_hda_check_board_config(codec, AD1884A_MODELS,
4355                                                   ad1884a_models,
4356                                                   ad1884a_cfg_tbl);
4357         switch (board_config) {
4358         case AD1884A_LAPTOP:
4359                 spec->mixers[0] = ad1884a_laptop_mixers;
4360                 spec->init_verbs[spec->num_init_verbs++] = ad1884a_laptop_verbs;
4361                 spec->multiout.dig_out_nid = 0;
4362                 codec->patch_ops.unsol_event = ad1884a_laptop_unsol_event;
4363                 codec->patch_ops.init = ad1884a_laptop_init;
4364                 /* set the upper-limit for mixer amp to 0dB for avoiding the
4365                  * possible damage by overloading
4366                  */
4367                 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
4368                                           (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
4369                                           (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4370                                           (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4371                                           (1 << AC_AMPCAP_MUTE_SHIFT));
4372                 break;
4373         case AD1884A_MOBILE:
4374                 spec->mixers[0] = ad1884a_mobile_mixers;
4375                 spec->init_verbs[0] = ad1884a_mobile_verbs;
4376                 spec->multiout.dig_out_nid = 0;
4377                 codec->patch_ops.unsol_event = ad1884a_hp_unsol_event;
4378                 codec->patch_ops.init = ad1884a_hp_init;
4379                 /* set the upper-limit for mixer amp to 0dB for avoiding the
4380                  * possible damage by overloading
4381                  */
4382                 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
4383                                           (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
4384                                           (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4385                                           (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4386                                           (1 << AC_AMPCAP_MUTE_SHIFT));
4387                 break;
4388         case AD1884A_THINKPAD:
4389                 spec->mixers[0] = ad1984a_thinkpad_mixers;
4390                 spec->init_verbs[spec->num_init_verbs++] =
4391                         ad1984a_thinkpad_verbs;
4392                 spec->multiout.dig_out_nid = 0;
4393                 spec->input_mux = &ad1984a_thinkpad_capture_source;
4394                 codec->patch_ops.unsol_event = ad1984a_thinkpad_unsol_event;
4395                 codec->patch_ops.init = ad1984a_thinkpad_init;
4396                 break;
4397         case AD1984A_TOUCHSMART:
4398                 spec->mixers[0] = ad1984a_touchsmart_mixers;
4399                 spec->init_verbs[0] = ad1984a_touchsmart_verbs;
4400                 spec->multiout.dig_out_nid = 0;
4401                 codec->patch_ops.unsol_event = ad1984a_touchsmart_unsol_event;
4402                 codec->patch_ops.init = ad1984a_touchsmart_init;
4403                 /* set the upper-limit for mixer amp to 0dB for avoiding the
4404                  * possible damage by overloading
4405                  */
4406                 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
4407                                           (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
4408                                           (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4409                                           (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4410                                           (1 << AC_AMPCAP_MUTE_SHIFT));
4411                 break;
4412         }
4413
4414         codec->no_trigger_sense = 1;
4415
4416         return 0;
4417 }
4418
4419
4420 /*
4421  * AD1882 / AD1882A
4422  *
4423  * port-A - front hp-out
4424  * port-B - front mic-in
4425  * port-C - rear line-in, shared surr-out (3stack)
4426  * port-D - rear line-out
4427  * port-E - rear mic-in, shared clfe-out (3stack)
4428  * port-F - rear surr-out (6stack)
4429  * port-G - rear clfe-out (6stack)
4430  */
4431
4432 static hda_nid_t ad1882_dac_nids[3] = {
4433         0x04, 0x03, 0x05
4434 };
4435
4436 static hda_nid_t ad1882_adc_nids[2] = {
4437         0x08, 0x09,
4438 };
4439
4440 static hda_nid_t ad1882_capsrc_nids[2] = {
4441         0x0c, 0x0d,
4442 };
4443
4444 #define AD1882_SPDIF_OUT        0x02
4445
4446 /* list: 0x11, 0x39, 0x3a, 0x18, 0x3c, 0x3b, 0x12, 0x20 */
4447 static struct hda_input_mux ad1882_capture_source = {
4448         .num_items = 5,
4449         .items = {
4450                 { "Front Mic", 0x1 },
4451                 { "Mic", 0x4 },
4452                 { "Line", 0x2 },
4453                 { "CD", 0x3 },
4454                 { "Mix", 0x7 },
4455         },
4456 };
4457
4458 /* list: 0x11, 0x39, 0x3a, 0x3c, 0x18, 0x1f, 0x12, 0x20 */
4459 static struct hda_input_mux ad1882a_capture_source = {
4460         .num_items = 5,
4461         .items = {
4462                 { "Front Mic", 0x1 },
4463                 { "Mic", 0x4},
4464                 { "Line", 0x2 },
4465                 { "Digital Mic", 0x06 },
4466                 { "Mix", 0x7 },
4467         },
4468 };
4469
4470 static struct snd_kcontrol_new ad1882_base_mixers[] = {
4471         HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
4472         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
4473         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
4474         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
4475         HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
4476         HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
4477         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
4478         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
4479
4480         HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
4481         HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
4482         HDA_CODEC_VOLUME("Line-In Boost", 0x3a, 0x0, HDA_OUTPUT),
4483         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4484         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4485         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
4486         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
4487         {
4488                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4489                 /* The multiple "Capture Source" controls confuse alsamixer
4490                  * So call somewhat different..
4491                  */
4492                 /* .name = "Capture Source", */
4493                 .name = "Input Source",
4494                 .count = 2,
4495                 .info = ad198x_mux_enum_info,
4496                 .get = ad198x_mux_enum_get,
4497                 .put = ad198x_mux_enum_put,
4498         },
4499         /* SPDIF controls */
4500         HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
4501         {
4502                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4503                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
4504                 /* identical with ad1983 */
4505                 .info = ad1983_spdif_route_info,
4506                 .get = ad1983_spdif_route_get,
4507                 .put = ad1983_spdif_route_put,
4508         },
4509         { } /* end */
4510 };
4511
4512 static struct snd_kcontrol_new ad1882_loopback_mixers[] = {
4513         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4514         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4515         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
4516         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
4517         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x04, HDA_INPUT),
4518         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x04, HDA_INPUT),
4519         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
4520         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
4521         { } /* end */
4522 };
4523
4524 static struct snd_kcontrol_new ad1882a_loopback_mixers[] = {
4525         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4526         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4527         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
4528         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
4529         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x01, HDA_INPUT),
4530         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x01, HDA_INPUT),
4531         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
4532         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
4533         HDA_CODEC_VOLUME("Digital Mic Boost", 0x1f, 0x0, HDA_INPUT),
4534         { } /* end */
4535 };
4536
4537 static struct snd_kcontrol_new ad1882_3stack_mixers[] = {
4538         HDA_CODEC_MUTE("Surround Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4539         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x17, 1, 0x0, HDA_OUTPUT),
4540         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x17, 2, 0x0, HDA_OUTPUT),
4541         {
4542                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4543                 .name = "Channel Mode",
4544                 .info = ad198x_ch_mode_info,
4545                 .get = ad198x_ch_mode_get,
4546                 .put = ad198x_ch_mode_put,
4547         },
4548         { } /* end */
4549 };
4550
4551 static struct snd_kcontrol_new ad1882_6stack_mixers[] = {
4552         HDA_CODEC_MUTE("Surround Playback Switch", 0x16, 0x0, HDA_OUTPUT),
4553         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x24, 1, 0x0, HDA_OUTPUT),
4554         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x24, 2, 0x0, HDA_OUTPUT),
4555         { } /* end */
4556 };
4557
4558 static struct hda_verb ad1882_ch2_init[] = {
4559         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4560         {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4561         {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4562         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4563         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4564         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4565         { } /* end */
4566 };
4567
4568 static struct hda_verb ad1882_ch4_init[] = {
4569         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4570         {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4571         {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4572         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4573         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4574         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4575         { } /* end */
4576 };
4577
4578 static struct hda_verb ad1882_ch6_init[] = {
4579         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4580         {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4581         {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4582         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4583         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4584         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4585         { } /* end */
4586 };
4587
4588 static struct hda_channel_mode ad1882_modes[3] = {
4589         { 2, ad1882_ch2_init },
4590         { 4, ad1882_ch4_init },
4591         { 6, ad1882_ch6_init },
4592 };
4593
4594 /*
4595  * initialization verbs
4596  */
4597 static struct hda_verb ad1882_init_verbs[] = {
4598         /* DACs; mute as default */
4599         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4600         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4601         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4602         /* Port-A (HP) mixer */
4603         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4604         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4605         /* Port-A pin */
4606         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4607         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4608         /* HP selector - select DAC2 */
4609         {0x37, AC_VERB_SET_CONNECT_SEL, 0x1},
4610         /* Port-D (Line-out) mixer */
4611         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4612         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4613         /* Port-D pin */
4614         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4615         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4616         /* Mono-out mixer */
4617         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4618         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4619         /* Mono-out pin */
4620         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4621         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4622         /* Port-B (front mic) pin */
4623         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4624         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4625         {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
4626         /* Port-C (line-in) pin */
4627         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4628         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4629         {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
4630         /* Port-C mixer - mute as input */
4631         {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4632         {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4633         /* Port-E (mic-in) pin */
4634         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4635         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4636         {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
4637         /* Port-E mixer - mute as input */
4638         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4639         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4640         /* Port-F (surround) */
4641         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4642         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4643         /* Port-G (CLFE) */
4644         {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4645         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4646         /* Analog mixer; mute as default */
4647         /* list: 0x39, 0x3a, 0x11, 0x12, 0x3c, 0x3b, 0x18, 0x1a */
4648         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4649         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4650         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4651         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4652         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4653         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
4654         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
4655         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
4656         /* Analog Mix output amp */
4657         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
4658         /* SPDIF output selector */
4659         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
4660         {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
4661         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
4662         { } /* end */
4663 };
4664
4665 #ifdef CONFIG_SND_HDA_POWER_SAVE
4666 static struct hda_amp_list ad1882_loopbacks[] = {
4667         { 0x20, HDA_INPUT, 0 }, /* Front Mic */
4668         { 0x20, HDA_INPUT, 1 }, /* Mic */
4669         { 0x20, HDA_INPUT, 4 }, /* Line */
4670         { 0x20, HDA_INPUT, 6 }, /* CD */
4671         { } /* end */
4672 };
4673 #endif
4674
4675 /* models */
4676 enum {
4677         AD1882_3STACK,
4678         AD1882_6STACK,
4679         AD1882_MODELS
4680 };
4681
4682 static const char *ad1882_models[AD1986A_MODELS] = {
4683         [AD1882_3STACK]         = "3stack",
4684         [AD1882_6STACK]         = "6stack",
4685 };
4686
4687
4688 static int patch_ad1882(struct hda_codec *codec)
4689 {
4690         struct ad198x_spec *spec;
4691         int err, board_config;
4692
4693         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4694         if (spec == NULL)
4695                 return -ENOMEM;
4696
4697         codec->spec = spec;
4698
4699         err = snd_hda_attach_beep_device(codec, 0x10);
4700         if (err < 0) {
4701                 ad198x_free(codec);
4702                 return err;
4703         }
4704         set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
4705
4706         spec->multiout.max_channels = 6;
4707         spec->multiout.num_dacs = 3;
4708         spec->multiout.dac_nids = ad1882_dac_nids;
4709         spec->multiout.dig_out_nid = AD1882_SPDIF_OUT;
4710         spec->num_adc_nids = ARRAY_SIZE(ad1882_adc_nids);
4711         spec->adc_nids = ad1882_adc_nids;
4712         spec->capsrc_nids = ad1882_capsrc_nids;
4713         if (codec->vendor_id == 0x11d41882)
4714                 spec->input_mux = &ad1882_capture_source;
4715         else
4716                 spec->input_mux = &ad1882a_capture_source;
4717         spec->num_mixers = 2;
4718         spec->mixers[0] = ad1882_base_mixers;
4719         if (codec->vendor_id == 0x11d41882)
4720                 spec->mixers[1] = ad1882_loopback_mixers;
4721         else
4722                 spec->mixers[1] = ad1882a_loopback_mixers;
4723         spec->num_init_verbs = 1;
4724         spec->init_verbs[0] = ad1882_init_verbs;
4725         spec->spdif_route = 0;
4726 #ifdef CONFIG_SND_HDA_POWER_SAVE
4727         spec->loopback.amplist = ad1882_loopbacks;
4728 #endif
4729         spec->vmaster_nid = 0x04;
4730
4731         codec->patch_ops = ad198x_patch_ops;
4732
4733         /* override some parameters */
4734         board_config = snd_hda_check_board_config(codec, AD1882_MODELS,
4735                                                   ad1882_models, NULL);
4736         switch (board_config) {
4737         default:
4738         case AD1882_3STACK:
4739                 spec->num_mixers = 3;
4740                 spec->mixers[2] = ad1882_3stack_mixers;
4741                 spec->channel_mode = ad1882_modes;
4742                 spec->num_channel_mode = ARRAY_SIZE(ad1882_modes);
4743                 spec->need_dac_fix = 1;
4744                 spec->multiout.max_channels = 2;
4745                 spec->multiout.num_dacs = 1;
4746                 break;
4747         case AD1882_6STACK:
4748                 spec->num_mixers = 3;
4749                 spec->mixers[2] = ad1882_6stack_mixers;
4750                 break;
4751         }
4752
4753         codec->no_trigger_sense = 1;
4754
4755         return 0;
4756 }
4757
4758
4759 /*
4760  * patch entries
4761  */
4762 static struct hda_codec_preset snd_hda_preset_analog[] = {
4763         { .id = 0x11d4184a, .name = "AD1884A", .patch = patch_ad1884a },
4764         { .id = 0x11d41882, .name = "AD1882", .patch = patch_ad1882 },
4765         { .id = 0x11d41883, .name = "AD1883", .patch = patch_ad1884a },
4766         { .id = 0x11d41884, .name = "AD1884", .patch = patch_ad1884 },
4767         { .id = 0x11d4194a, .name = "AD1984A", .patch = patch_ad1884a },
4768         { .id = 0x11d4194b, .name = "AD1984B", .patch = patch_ad1884a },
4769         { .id = 0x11d41981, .name = "AD1981", .patch = patch_ad1981 },
4770         { .id = 0x11d41983, .name = "AD1983", .patch = patch_ad1983 },
4771         { .id = 0x11d41984, .name = "AD1984", .patch = patch_ad1984 },
4772         { .id = 0x11d41986, .name = "AD1986A", .patch = patch_ad1986a },
4773         { .id = 0x11d41988, .name = "AD1988", .patch = patch_ad1988 },
4774         { .id = 0x11d4198b, .name = "AD1988B", .patch = patch_ad1988 },
4775         { .id = 0x11d4882a, .name = "AD1882A", .patch = patch_ad1882 },
4776         { .id = 0x11d4989a, .name = "AD1989A", .patch = patch_ad1988 },
4777         { .id = 0x11d4989b, .name = "AD1989B", .patch = patch_ad1988 },
4778         {} /* terminator */
4779 };
4780
4781 MODULE_ALIAS("snd-hda-codec-id:11d4*");
4782
4783 MODULE_LICENSE("GPL");
4784 MODULE_DESCRIPTION("Analog Devices HD-audio codec");
4785
4786 static struct hda_codec_preset_list analog_list = {
4787         .preset = snd_hda_preset_analog,
4788         .owner = THIS_MODULE,
4789 };
4790
4791 static int __init patch_analog_init(void)
4792 {
4793         return snd_hda_add_codec_preset(&analog_list);
4794 }
4795
4796 static void __exit patch_analog_exit(void)
4797 {
4798         snd_hda_delete_codec_preset(&analog_list);
4799 }
4800
4801 module_init(patch_analog_init)
4802 module_exit(patch_analog_exit)