sound/pci/hda/patch_analog.c

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