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