sound/pci/hda/patch_analog.c

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