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