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