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