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