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