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