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