/*

   * HD audio interface patch for AD1882, AD1884, AD1981HD, AD1983, AD1984,
   *   AD1986A, AD1988

   *

   * Copyright (c) 2005-2007 Takashi Iwai <tiwai@suse.de>

   *
   *  This driver is free software; you can redistribute it and/or modify
   *  it under the terms of the GNU General Public License as published by
   *  the Free Software Foundation; either version 2 of the License, or
   *  (at your option) any later version.
   *
   *  This driver is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *  GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *  along with this program; if not, write to the Free Software
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
   */

  #include <linux/init.h>
  #include <linux/delay.h>
  #include <linux/slab.h>
  #include <linux/pci.h>

  #include <linux/module.h>

  #include <sound/core.h>
  #include "hda_codec.h"
  #include "hda_local.h"

  #include "hda_beep.h"

  #include "hda_jack.h"

  struct ad198x_spec {

  	const struct snd_kcontrol_new *mixers[6];

  	int num_mixers;

  	unsigned int beep_amp;	/* beep amp value, set via set_beep_amp() */

  	const struct hda_verb *init_verbs[6];	/* initialization verbs

  						 * don't forget NULL termination!
  						 */
  	unsigned int num_init_verbs;
  
  	/* playback */
  	struct hda_multi_out multiout;	/* playback set-up
  					 * max_channels, dacs must be set
  					 * dig_out_nid and hp_nid are optional
  					 */

  	unsigned int cur_eapd;

  	unsigned int need_dac_fix;

  	const hda_nid_t *alt_dac_nid;
  	const struct hda_pcm_stream *stream_analog_alt_playback;

  	int independent_hp;
  	int num_active_streams;

  	/* capture */
  	unsigned int num_adc_nids;

  	const hda_nid_t *adc_nids;

  	hda_nid_t dig_in_nid;		/* digital-in NID; optional */
  
  	/* capture source */

  	const struct hda_input_mux *input_mux;

  	const hda_nid_t *capsrc_nids;

  	unsigned int cur_mux[3];
  
  	/* channel model */

  	const struct hda_channel_mode *channel_mode;

  	int num_channel_mode;
  
  	/* PCM information */

  	struct hda_pcm pcm_rec[3];	/* used in alc_build_pcms() */

  	unsigned int spdif_route;

  
  	/* dynamic controls, init_verbs and input_mux */
  	struct auto_pin_cfg autocfg;

  	struct snd_array kctls;

  	struct hda_input_mux private_imux;

  	hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];

  	unsigned int jack_present: 1;
  	unsigned int inv_jack_detect: 1;/* inverted jack-detection */
  	unsigned int inv_eapd: 1;	/* inverted EAPD implementation */
  	unsigned int analog_beep: 1;	/* analog beep input present */

  #ifdef CONFIG_SND_HDA_POWER_SAVE
  	struct hda_loopback_check loopback;
  #endif

  	/* for virtual master */
  	hda_nid_t vmaster_nid;

  	const char * const *slave_vols;
  	const char * const *slave_sws;

  };

  /*
   * input MUX handling (common part)
   */

  static int ad198x_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)

  {
  	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  	struct ad198x_spec *spec = codec->spec;
  
  	return snd_hda_input_mux_info(spec->input_mux, uinfo);
  }

  static int ad198x_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)

  {
  	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  	struct ad198x_spec *spec = codec->spec;

  	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);

  	ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];

  	return 0;
  }

  static int ad198x_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)

  {
  	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  	struct ad198x_spec *spec = codec->spec;

  	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);

  
  	return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,

  				     spec->capsrc_nids[adc_idx],
  				     &spec->cur_mux[adc_idx]);

  }
  
  /*
   * initialization (common callbacks)
   */
  static int ad198x_init(struct hda_codec *codec)
  {
  	struct ad198x_spec *spec = codec->spec;

  	int i;
  
  	for (i = 0; i < spec->num_init_verbs; i++)
  		snd_hda_sequence_write(codec, spec->init_verbs[i]);

  	return 0;
  }

  static const char * const ad_slave_vols[] = {

  	"Front Playback Volume",
  	"Surround Playback Volume",
  	"Center Playback Volume",
  	"LFE Playback Volume",
  	"Side Playback Volume",
  	"Headphone Playback Volume",
  	"Mono Playback Volume",

  	"Speaker Playback Volume",

  	"IEC958 Playback Volume",

  	NULL
  };

  static const char * const ad_slave_sws[] = {

  	"Front Playback Switch",
  	"Surround Playback Switch",
  	"Center Playback Switch",
  	"LFE Playback Switch",
  	"Side Playback Switch",
  	"Headphone Playback Switch",
  	"Mono Playback Switch",

  	"Speaker Playback Switch",

  	"IEC958 Playback Switch",

  	NULL
  };

  static const char * const ad1988_6stack_fp_slave_vols[] = {

  	"Front Playback Volume",
  	"Surround Playback Volume",
  	"Center Playback Volume",
  	"LFE Playback Volume",
  	"Side Playback Volume",
  	"IEC958 Playback Volume",
  	NULL
  };

  static const char * const ad1988_6stack_fp_slave_sws[] = {

  	"Front Playback Switch",
  	"Surround Playback Switch",
  	"Center Playback Switch",
  	"LFE Playback Switch",
  	"Side Playback Switch",
  	"IEC958 Playback Switch",
  	NULL
  };

  static void ad198x_free_kctls(struct hda_codec *codec);

  #ifdef CONFIG_SND_HDA_INPUT_BEEP

  /* additional beep mixers; the actual parameters are overwritten at build */

  static const struct snd_kcontrol_new ad_beep_mixer[] = {

  	HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_OUTPUT),

  	HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_OUTPUT),

  	{ } /* end */
  };

  static const struct snd_kcontrol_new ad_beep2_mixer[] = {

  	HDA_CODEC_VOLUME("Digital Beep Playback Volume", 0, 0, HDA_OUTPUT),
  	HDA_CODEC_MUTE_BEEP("Digital Beep Playback Switch", 0, 0, HDA_OUTPUT),
  	{ } /* end */
  };

  #define set_beep_amp(spec, nid, idx, dir) \
  	((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir)) /* mono */

  #else
  #define set_beep_amp(spec, nid, idx, dir) /* NOP */
  #endif

  static int ad198x_build_controls(struct hda_codec *codec)
  {
  	struct ad198x_spec *spec = codec->spec;

  	struct snd_kcontrol *kctl;

  	unsigned int i;

  	int err;

  	for (i = 0; i < spec->num_mixers; i++) {
  		err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
  		if (err < 0)
  			return err;
  	}
  	if (spec->multiout.dig_out_nid) {

  		err = snd_hda_create_spdif_out_ctls(codec,
  						    spec->multiout.dig_out_nid,
  						    spec->multiout.dig_out_nid);

  		if (err < 0)
  			return err;

  		err = snd_hda_create_spdif_share_sw(codec,
  						    &spec->multiout);
  		if (err < 0)
  			return err;
  		spec->multiout.share_spdif = 1;

  	} 
  	if (spec->dig_in_nid) {
  		err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
  		if (err < 0)
  			return err;
  	}

  	/* create beep controls if needed */

  #ifdef CONFIG_SND_HDA_INPUT_BEEP

  	if (spec->beep_amp) {

  		const struct snd_kcontrol_new *knew;

  		knew = spec->analog_beep ? ad_beep2_mixer : ad_beep_mixer;
  		for ( ; knew->name; knew++) {

  			struct snd_kcontrol *kctl;
  			kctl = snd_ctl_new1(knew, codec);
  			if (!kctl)
  				return -ENOMEM;
  			kctl->private_value = spec->beep_amp;

  			err = snd_hda_ctl_add(codec, 0, kctl);

  			if (err < 0)
  				return err;
  		}
  	}

  #endif

  	/* if we have no master control, let's create it */
  	if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {

  		unsigned int vmaster_tlv[4];

  		snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,

  					HDA_OUTPUT, vmaster_tlv);

  		err = snd_hda_add_vmaster(codec, "Master Playback Volume",

  					  vmaster_tlv,

  					  (spec->slave_vols ?
  					   spec->slave_vols : ad_slave_vols));
  		if (err < 0)
  			return err;
  	}
  	if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
  		err = snd_hda_add_vmaster(codec, "Master Playback Switch",
  					  NULL,
  					  (spec->slave_sws ?
  					   spec->slave_sws : ad_slave_sws));
  		if (err < 0)
  			return err;
  	}

  	ad198x_free_kctls(codec); /* no longer needed */

  
  	/* assign Capture Source enums to NID */
  	kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
  	if (!kctl)
  		kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
  	for (i = 0; kctl && i < kctl->count; i++) {

  		err = snd_hda_add_nid(codec, kctl, i, spec->capsrc_nids[i]);

  		if (err < 0)
  			return err;
  	}
  
  	/* assign IEC958 enums to NID */
  	kctl = snd_hda_find_mixer_ctl(codec,
  			SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source");
  	if (kctl) {
  		err = snd_hda_add_nid(codec, kctl, 0,
  				      spec->multiout.dig_out_nid);
  		if (err < 0)
  			return err;
  	}

  	return 0;
  }

  #ifdef CONFIG_SND_HDA_POWER_SAVE
  static int ad198x_check_power_status(struct hda_codec *codec, hda_nid_t nid)
  {
  	struct ad198x_spec *spec = codec->spec;
  	return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
  }
  #endif

  static void activate_ctl(struct hda_codec *codec, const char *name, int active)
  {
  	struct snd_kcontrol *ctl = snd_hda_find_mixer_ctl(codec, name);
  	if (ctl) {
  		ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
  		ctl->vd[0].access |= active ? 0 :
  			SNDRV_CTL_ELEM_ACCESS_INACTIVE;
  		ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_WRITE;
  		ctl->vd[0].access |= active ?
  			SNDRV_CTL_ELEM_ACCESS_WRITE : 0;
  		snd_ctl_notify(codec->bus->card,
  			       SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
  	}
  }
  
  static void set_stream_active(struct hda_codec *codec, bool active)
  {
  	struct ad198x_spec *spec = codec->spec;
  	if (active)
  		spec->num_active_streams++;
  	else
  		spec->num_active_streams--;
  	activate_ctl(codec, "Independent HP", spec->num_active_streams == 0);
  }
  
  static int ad1988_independent_hp_info(struct snd_kcontrol *kcontrol,
  				   struct snd_ctl_elem_info *uinfo)
  {
  	static const char * const texts[] = { "OFF", "ON", NULL};
  	int index;
  	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
  	uinfo->count = 1;
  	uinfo->value.enumerated.items = 2;
  	index = uinfo->value.enumerated.item;
  	if (index >= 2)
  		index = 1;
  	strcpy(uinfo->value.enumerated.name, texts[index]);
  	return 0;
  }
  
  static int ad1988_independent_hp_get(struct snd_kcontrol *kcontrol,
  				  struct snd_ctl_elem_value *ucontrol)
  {
  	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  	struct ad198x_spec *spec = codec->spec;
  	ucontrol->value.enumerated.item[0] = spec->independent_hp;
  	return 0;
  }
  
  static int ad1988_independent_hp_put(struct snd_kcontrol *kcontrol,
  				  struct snd_ctl_elem_value *ucontrol)
  {
  	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  	struct ad198x_spec *spec = codec->spec;
  	unsigned int select = ucontrol->value.enumerated.item[0];
  	if (spec->independent_hp != select) {
  		spec->independent_hp = select;
  		if (spec->independent_hp)
  			spec->multiout.hp_nid = 0;
  		else
  			spec->multiout.hp_nid = spec->alt_dac_nid[0];
  		return 1;
  	}
  	return 0;
  }

  /*
   * Analog playback callbacks
   */
  static int ad198x_playback_pcm_open(struct hda_pcm_stream *hinfo,
  				    struct hda_codec *codec,

  				    struct snd_pcm_substream *substream)

  {
  	struct ad198x_spec *spec = codec->spec;

  	int err;
  	set_stream_active(codec, true);
  	err = snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,

  					     hinfo);

  	if (err < 0) {
  		set_stream_active(codec, false);
  		return err;
  	}
  	return 0;

  }
  
  static int ad198x_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
  				       struct hda_codec *codec,
  				       unsigned int stream_tag,
  				       unsigned int format,

  				       struct snd_pcm_substream *substream)

  {
  	struct ad198x_spec *spec = codec->spec;
  	return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
  						format, substream);
  }
  
  static int ad198x_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
  				       struct hda_codec *codec,

  				       struct snd_pcm_substream *substream)

  {
  	struct ad198x_spec *spec = codec->spec;
  	return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
  }

  static int ad198x_playback_pcm_close(struct hda_pcm_stream *hinfo,
  				 struct hda_codec *codec,
  				 struct snd_pcm_substream *substream)
  {
  	set_stream_active(codec, false);
  	return 0;
  }
  
  static int ad1988_alt_playback_pcm_open(struct hda_pcm_stream *hinfo,
  				 struct hda_codec *codec,
  				 struct snd_pcm_substream *substream)
  {
  	struct ad198x_spec *spec = codec->spec;
  	if (!spec->independent_hp)
  		return -EBUSY;
  	set_stream_active(codec, true);
  	return 0;
  }
  
  static int ad1988_alt_playback_pcm_close(struct hda_pcm_stream *hinfo,
  				 struct hda_codec *codec,
  				 struct snd_pcm_substream *substream)
  {
  	set_stream_active(codec, false);
  	return 0;
  }

  static const struct hda_pcm_stream ad198x_pcm_analog_alt_playback = {

  	.substreams = 1,
  	.channels_min = 2,
  	.channels_max = 2,

  	.ops = {
  		.open  = ad1988_alt_playback_pcm_open,
  		.close = ad1988_alt_playback_pcm_close
  	},

  };

  /*
   * Digital out
   */
  static int ad198x_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
  					struct hda_codec *codec,

  					struct snd_pcm_substream *substream)

  {
  	struct ad198x_spec *spec = codec->spec;
  	return snd_hda_multi_out_dig_open(codec, &spec->multiout);
  }
  
  static int ad198x_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
  					 struct hda_codec *codec,

  					 struct snd_pcm_substream *substream)

  {
  	struct ad198x_spec *spec = codec->spec;
  	return snd_hda_multi_out_dig_close(codec, &spec->multiout);
  }

  static int ad198x_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
  					   struct hda_codec *codec,
  					   unsigned int stream_tag,
  					   unsigned int format,
  					   struct snd_pcm_substream *substream)
  {
  	struct ad198x_spec *spec = codec->spec;
  	return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
  					     format, substream);
  }

  static int ad198x_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
  					   struct hda_codec *codec,
  					   struct snd_pcm_substream *substream)
  {
  	struct ad198x_spec *spec = codec->spec;
  	return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
  }

  /*
   * Analog capture
   */
  static int ad198x_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
  				      struct hda_codec *codec,
  				      unsigned int stream_tag,
  				      unsigned int format,

  				      struct snd_pcm_substream *substream)

  {
  	struct ad198x_spec *spec = codec->spec;

  	snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
  				   stream_tag, 0, format);

  	return 0;
  }
  
  static int ad198x_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
  				      struct hda_codec *codec,

  				      struct snd_pcm_substream *substream)

  {
  	struct ad198x_spec *spec = codec->spec;

  	snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);

  	return 0;
  }

  /*
   */

  static const struct hda_pcm_stream ad198x_pcm_analog_playback = {

  	.substreams = 1,
  	.channels_min = 2,

  	.channels_max = 6, /* changed later */

  	.nid = 0, /* fill later */
  	.ops = {
  		.open = ad198x_playback_pcm_open,
  		.prepare = ad198x_playback_pcm_prepare,

  		.cleanup = ad198x_playback_pcm_cleanup,
  		.close = ad198x_playback_pcm_close

  	},
  };

  static const struct hda_pcm_stream ad198x_pcm_analog_capture = {

  	.substreams = 1,

  	.channels_min = 2,
  	.channels_max = 2,
  	.nid = 0, /* fill later */
  	.ops = {
  		.prepare = ad198x_capture_pcm_prepare,
  		.cleanup = ad198x_capture_pcm_cleanup
  	},
  };

  static const struct hda_pcm_stream ad198x_pcm_digital_playback = {

  	.substreams = 1,
  	.channels_min = 2,
  	.channels_max = 2,
  	.nid = 0, /* fill later */
  	.ops = {
  		.open = ad198x_dig_playback_pcm_open,

  		.close = ad198x_dig_playback_pcm_close,

  		.prepare = ad198x_dig_playback_pcm_prepare,
  		.cleanup = ad198x_dig_playback_pcm_cleanup

  	},
  };

  static const struct hda_pcm_stream ad198x_pcm_digital_capture = {

  	.substreams = 1,
  	.channels_min = 2,
  	.channels_max = 2,
  	/* NID is set in alc_build_pcms */
  };

  static int ad198x_build_pcms(struct hda_codec *codec)
  {
  	struct ad198x_spec *spec = codec->spec;
  	struct hda_pcm *info = spec->pcm_rec;
  
  	codec->num_pcms = 1;
  	codec->pcm_info = info;
  
  	info->name = "AD198x Analog";
  	info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_analog_playback;
  	info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->multiout.max_channels;
  	info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
  	info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_analog_capture;

  	info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adc_nids;
  	info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];

  
  	if (spec->multiout.dig_out_nid) {
  		info++;
  		codec->num_pcms++;
  		info->name = "AD198x Digital";

  		info->pcm_type = HDA_PCM_TYPE_SPDIF;

  		info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_digital_playback;
  		info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;

  		if (spec->dig_in_nid) {
  			info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_digital_capture;
  			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
  		}

  	}

  	if (spec->alt_dac_nid && spec->stream_analog_alt_playback) {
  		codec->num_pcms++;
  		info = spec->pcm_rec + 2;
  		info->name = "AD198x Headphone";
  		info->pcm_type = HDA_PCM_TYPE_AUDIO;
  		info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
  			*spec->stream_analog_alt_playback;
  		info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
  			spec->alt_dac_nid[0];
  	}

  	return 0;
  }

  static void ad198x_free_kctls(struct hda_codec *codec)

  {

  	struct ad198x_spec *spec = codec->spec;

  	if (spec->kctls.list) {
  		struct snd_kcontrol_new *kctl = spec->kctls.list;
  		int i;
  		for (i = 0; i < spec->kctls.used; i++)
  			kfree(kctl[i].name);

  	}

  	snd_array_free(&spec->kctls);
  }

  static void ad198x_power_eapd_write(struct hda_codec *codec, hda_nid_t front,
  				hda_nid_t hp)
  {
  	struct ad198x_spec *spec = codec->spec;

  	if (snd_hda_query_pin_caps(codec, front) & AC_PINCAP_EAPD)
  		snd_hda_codec_write(codec, front, 0, AC_VERB_SET_EAPD_BTLENABLE,

  			    !spec->inv_eapd ? 0x00 : 0x02);

  	if (snd_hda_query_pin_caps(codec, hp) & AC_PINCAP_EAPD)
  		snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_EAPD_BTLENABLE,

  			    !spec->inv_eapd ? 0x00 : 0x02);
  }
  
  static void ad198x_power_eapd(struct hda_codec *codec)
  {
  	/* We currently only handle front, HP */
  	switch (codec->vendor_id) {
  	case 0x11d41882:
  	case 0x11d4882a:
  	case 0x11d41884:
  	case 0x11d41984:
  	case 0x11d41883:
  	case 0x11d4184a:
  	case 0x11d4194a:
  	case 0x11d4194b:

  	case 0x11d41988:
  	case 0x11d4198b:
  	case 0x11d4989a:
  	case 0x11d4989b:

  		ad198x_power_eapd_write(codec, 0x12, 0x11);
  		break;
  	case 0x11d41981:
  	case 0x11d41983:
  		ad198x_power_eapd_write(codec, 0x05, 0x06);
  		break;
  	case 0x11d41986:
  		ad198x_power_eapd_write(codec, 0x1b, 0x1a);
  		break;

  	}
  }

  static void ad198x_shutup(struct hda_codec *codec)
  {
  	snd_hda_shutup_pins(codec);
  	ad198x_power_eapd(codec);
  }

  static void ad198x_free(struct hda_codec *codec)
  {
  	struct ad198x_spec *spec = codec->spec;
  
  	if (!spec)
  		return;

  	ad198x_shutup(codec);

  	ad198x_free_kctls(codec);

  	kfree(spec);
  	snd_hda_detach_beep_device(codec);

  }

  #ifdef CONFIG_PM

  static int ad198x_suspend(struct hda_codec *codec, pm_message_t state)
  {
  	ad198x_shutup(codec);

  	return 0;
  }

  #endif

  static const struct hda_codec_ops ad198x_patch_ops = {

  	.build_controls = ad198x_build_controls,
  	.build_pcms = ad198x_build_pcms,
  	.init = ad198x_init,
  	.free = ad198x_free,

  #ifdef CONFIG_SND_HDA_POWER_SAVE
  	.check_power_status = ad198x_check_power_status,
  #endif

  #ifdef CONFIG_PM

  	.suspend = ad198x_suspend,

  #endif
  	.reboot_notify = ad198x_shutup,

  };
  
  
  /*

   * EAPD control

   * the private value = nid

   */

  #define ad198x_eapd_info	snd_ctl_boolean_mono_info

  
  static int ad198x_eapd_get(struct snd_kcontrol *kcontrol,
  			   struct snd_ctl_elem_value *ucontrol)
  {
  	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  	struct ad198x_spec *spec = codec->spec;

  	if (spec->inv_eapd)

  		ucontrol->value.integer.value[0] = ! spec->cur_eapd;
  	else
  		ucontrol->value.integer.value[0] = spec->cur_eapd;
  	return 0;
  }
  
  static int ad198x_eapd_put(struct snd_kcontrol *kcontrol,
  			   struct snd_ctl_elem_value *ucontrol)
  {
  	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  	struct ad198x_spec *spec = codec->spec;

  	hda_nid_t nid = kcontrol->private_value & 0xff;
  	unsigned int eapd;

  	eapd = !!ucontrol->value.integer.value[0];

  	if (spec->inv_eapd)

  		eapd = !eapd;

  	if (eapd == spec->cur_eapd)

  		return 0;
  	spec->cur_eapd = eapd;

  	snd_hda_codec_write_cache(codec, nid,
  				  0, AC_VERB_SET_EAPD_BTLENABLE,
  				  eapd ? 0x02 : 0x00);

  	return 1;
  }

  static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
  			       struct snd_ctl_elem_info *uinfo);
  static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
  			      struct snd_ctl_elem_value *ucontrol);
  static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
  			      struct snd_ctl_elem_value *ucontrol);

  /*

   * AD1986A specific
   */

  #define AD1986A_SPDIF_OUT	0x02
  #define AD1986A_FRONT_DAC	0x03
  #define AD1986A_SURR_DAC	0x04
  #define AD1986A_CLFE_DAC	0x05
  #define AD1986A_ADC		0x06

  static const hda_nid_t ad1986a_dac_nids[3] = {

  	AD1986A_FRONT_DAC, AD1986A_SURR_DAC, AD1986A_CLFE_DAC
  };

  static const hda_nid_t ad1986a_adc_nids[1] = { AD1986A_ADC };
  static const hda_nid_t ad1986a_capsrc_nids[1] = { 0x12 };

  static const struct hda_input_mux ad1986a_capture_source = {

  	.num_items = 7,
  	.items = {
  		{ "Mic", 0x0 },
  		{ "CD", 0x1 },
  		{ "Aux", 0x3 },
  		{ "Line", 0x4 },
  		{ "Mix", 0x5 },
  		{ "Mono", 0x6 },
  		{ "Phone", 0x7 },
  	},
  };

  static const struct hda_bind_ctls ad1986a_bind_pcm_vol = {

  	.ops = &snd_hda_bind_vol,
  	.values = {
  		HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
  		HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
  		HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
  		0
  	},
  };

  static const struct hda_bind_ctls ad1986a_bind_pcm_sw = {

  	.ops = &snd_hda_bind_sw,
  	.values = {
  		HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
  		HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
  		HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
  		0
  	},
  };

  
  /*

   * mixers
   */

  static const struct snd_kcontrol_new ad1986a_mixers[] = {

  	/*
  	 * bind volumes/mutes of 3 DACs as a single PCM control for simplicity
  	 */
  	HDA_BIND_VOL("PCM Playback Volume", &ad1986a_bind_pcm_vol),
  	HDA_BIND_SW("PCM Playback Switch", &ad1986a_bind_pcm_sw),

  	HDA_CODEC_VOLUME("Front Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Surround Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Surround Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x1d, 1, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x1d, 2, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x1d, 1, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x1d, 2, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x1a, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),

  	HDA_CODEC_VOLUME("Mic Boost Volume", 0x0f, 0x0, HDA_OUTPUT),

  	HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
  	{
  		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  		.name = "Capture Source",

  		.info = ad198x_mux_enum_info,
  		.get = ad198x_mux_enum_get,
  		.put = ad198x_mux_enum_put,

  	},
  	HDA_CODEC_MUTE("Stereo Downmix Switch", 0x09, 0x0, HDA_OUTPUT),
  	{ } /* end */
  };

  /* additional mixers for 3stack mode */

  static const struct snd_kcontrol_new ad1986a_3st_mixers[] = {

  	{
  		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  		.name = "Channel Mode",
  		.info = ad198x_ch_mode_info,
  		.get = ad198x_ch_mode_get,
  		.put = ad198x_ch_mode_put,
  	},
  	{ } /* end */
  };
  
  /* laptop model - 2ch only */

  static const hda_nid_t ad1986a_laptop_dac_nids[1] = { AD1986A_FRONT_DAC };

  /* master controls both pins 0x1a and 0x1b */

  static const struct hda_bind_ctls ad1986a_laptop_master_vol = {

  	.ops = &snd_hda_bind_vol,
  	.values = {
  		HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
  		HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
  		0,
  	},
  };

  static const struct hda_bind_ctls ad1986a_laptop_master_sw = {

  	.ops = &snd_hda_bind_sw,
  	.values = {
  		HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
  		HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
  		0,
  	},
  };

  static const struct snd_kcontrol_new ad1986a_laptop_mixers[] = {

  	HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),

  	HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
  	HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),

  	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),

  	HDA_CODEC_VOLUME("Mic Boost Volume", 0x0f, 0x0, HDA_OUTPUT),

  	/* 

  	   HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
  	   HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), */
  	HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
  	{
  		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  		.name = "Capture Source",
  		.info = ad198x_mux_enum_info,
  		.get = ad198x_mux_enum_get,
  		.put = ad198x_mux_enum_put,
  	},
  	{ } /* end */
  };

  /* laptop-eapd model - 2ch only */

  static const struct hda_input_mux ad1986a_laptop_eapd_capture_source = {

  	.num_items = 3,
  	.items = {
  		{ "Mic", 0x0 },
  		{ "Internal Mic", 0x4 },
  		{ "Mix", 0x5 },
  	},
  };

  static const struct hda_input_mux ad1986a_automic_capture_source = {

  	.num_items = 2,
  	.items = {
  		{ "Mic", 0x0 },
  		{ "Mix", 0x5 },
  	},
  };

  static const struct snd_kcontrol_new ad1986a_laptop_master_mixers[] = {

  	HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
  	HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),

  	{ } /* end */
  };

  static const struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = {

  	HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),

  	HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),

  	HDA_CODEC_VOLUME("Mic Boost Volume", 0x0f, 0x0, HDA_OUTPUT),

  	HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
  	{
  		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  		.name = "Capture Source",
  		.info = ad198x_mux_enum_info,
  		.get = ad198x_mux_enum_get,
  		.put = ad198x_mux_enum_put,
  	},
  	{
  		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  		.name = "External Amplifier",

  		.subdevice = HDA_SUBDEV_NID_FLAG | 0x1b,

  		.info = ad198x_eapd_info,
  		.get = ad198x_eapd_get,
  		.put = ad198x_eapd_put,

  		.private_value = 0x1b, /* port-D */

  	},
  	{ } /* end */
  };

  static const struct snd_kcontrol_new ad1986a_laptop_intmic_mixers[] = {

  	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0, HDA_OUTPUT),
  	{ } /* end */
  };

  /* re-connect the mic boost input according to the jack sensing */
  static void ad1986a_automic(struct hda_codec *codec)
  {
  	unsigned int present;

  	present = snd_hda_jack_detect(codec, 0x1f);

  	/* 0 = 0x1f, 2 = 0x1d, 4 = mixed */
  	snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_CONNECT_SEL,

  			    present ? 0 : 2);

  }
  
  #define AD1986A_MIC_EVENT		0x36
  
  static void ad1986a_automic_unsol_event(struct hda_codec *codec,
  					    unsigned int res)
  {
  	if ((res >> 26) != AD1986A_MIC_EVENT)
  		return;
  	ad1986a_automic(codec);
  }
  
  static int ad1986a_automic_init(struct hda_codec *codec)
  {
  	ad198x_init(codec);
  	ad1986a_automic(codec);
  	return 0;
  }

  /* laptop-automute - 2ch only */
  
  static void ad1986a_update_hp(struct hda_codec *codec)
  {
  	struct ad198x_spec *spec = codec->spec;
  	unsigned int mute;
  
  	if (spec->jack_present)
  		mute = HDA_AMP_MUTE; /* mute internal speaker */
  	else
  		/* unmute internal speaker if necessary */
  		mute = snd_hda_codec_amp_read(codec, 0x1a, 0, HDA_OUTPUT, 0);
  	snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
  				 HDA_AMP_MUTE, mute);
  }
  
  static void ad1986a_hp_automute(struct hda_codec *codec)
  {
  	struct ad198x_spec *spec = codec->spec;

  	spec->jack_present = snd_hda_jack_detect(codec, 0x1a);

  	if (spec->inv_jack_detect)
  		spec->jack_present = !spec->jack_present;

  	ad1986a_update_hp(codec);
  }
  
  #define AD1986A_HP_EVENT		0x37
  
  static void ad1986a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
  {
  	if ((res >> 26) != AD1986A_HP_EVENT)
  		return;
  	ad1986a_hp_automute(codec);
  }
  
  static int ad1986a_hp_init(struct hda_codec *codec)
  {
  	ad198x_init(codec);
  	ad1986a_hp_automute(codec);
  	return 0;
  }
  
  /* bind hp and internal speaker mute (with plug check) */
  static int ad1986a_hp_master_sw_put(struct snd_kcontrol *kcontrol,
  				    struct snd_ctl_elem_value *ucontrol)
  {
  	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  	long *valp = ucontrol->value.integer.value;
  	int change;
  
  	change = snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_OUTPUT, 0,
  					  HDA_AMP_MUTE,
  					  valp[0] ? 0 : HDA_AMP_MUTE);
  	change |= snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_OUTPUT, 0,
  					   HDA_AMP_MUTE,
  					   valp[1] ? 0 : HDA_AMP_MUTE);
  	if (change)
  		ad1986a_update_hp(codec);
  	return change;
  }

  static const struct snd_kcontrol_new ad1986a_automute_master_mixers[] = {

  	HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
  	{
  		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  		.name = "Master Playback Switch",

  		.subdevice = HDA_SUBDEV_AMP_FLAG,

  		.info = snd_hda_mixer_amp_switch_info,
  		.get = snd_hda_mixer_amp_switch_get,
  		.put = ad1986a_hp_master_sw_put,
  		.private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
  	},

  	{ } /* end */
  };

  /*
   * initialization verbs
   */

  static const struct hda_verb ad1986a_init_verbs[] = {

  	/* Front, Surround, CLFE DAC; mute as default */
  	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	/* Downmix - off */
  	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	/* HP, Line-Out, Surround, CLFE selectors */
  	{0x0a, AC_VERB_SET_CONNECT_SEL, 0x0},
  	{0x0b, AC_VERB_SET_CONNECT_SEL, 0x0},
  	{0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
  	{0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
  	/* Mono selector */
  	{0x0e, AC_VERB_SET_CONNECT_SEL, 0x0},
  	/* Mic selector: Mic 1/2 pin */
  	{0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
  	/* Line-in selector: Line-in */
  	{0x10, AC_VERB_SET_CONNECT_SEL, 0x0},
  	/* Mic 1/2 swap */
  	{0x11, AC_VERB_SET_CONNECT_SEL, 0x0},
  	/* Record selector: mic */
  	{0x12, AC_VERB_SET_CONNECT_SEL, 0x0},
  	/* Mic, Phone, CD, Aux, Line-In amp; mute as default */
  	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	/* PC beep */
  	{0x18, AC_VERB_SET_CONNECT_SEL, 0x0},
  	/* HP, Line-Out, Surround, CLFE, Mono pins; mute as default */
  	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},

  	/* HP Pin */
  	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
  	/* Front, Surround, CLFE Pins */
  	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  	/* Mono Pin */
  	{0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  	/* Mic Pin */
  	{0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
  	/* Line, Aux, CD, Beep-In Pin */
  	{0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
  	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
  	{0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
  	{0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
  	{0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },

  	{ } /* end */
  };

  static const struct hda_verb ad1986a_ch2_init[] = {

  	/* Surround out -> Line In */

  	{ 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
   	/* Line-in selectors */
  	{ 0x10, AC_VERB_SET_CONNECT_SEL, 0x1 },

  	/* CLFE -> Mic in */

  	{ 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
  	/* Mic selector, mix C/LFE (backmic) and Mic (frontmic) */
  	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },

  	{ } /* end */
  };

  static const struct hda_verb ad1986a_ch4_init[] = {

  	/* Surround out -> Surround */

  	{ 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
  	{ 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },

  	/* CLFE -> Mic in */

  	{ 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
  	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },

  	{ } /* end */
  };

  static const struct hda_verb ad1986a_ch6_init[] = {

  	/* Surround out -> Surround out */

  	{ 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
  	{ 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },

  	/* CLFE -> CLFE */

  	{ 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
  	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x0 },

  	{ } /* end */
  };

  static const struct hda_channel_mode ad1986a_modes[3] = {

  	{ 2, ad1986a_ch2_init },
  	{ 4, ad1986a_ch4_init },
  	{ 6, ad1986a_ch6_init },
  };

  /* eapd initialization */

  static const struct hda_verb ad1986a_eapd_init_verbs[] = {

  	{0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },

  	{}
  };

  static const struct hda_verb ad1986a_automic_verbs[] = {

  	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
  	{0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
  	/*{0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},*/
  	{0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
  	{0x1f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_MIC_EVENT},
  	{}
  };

  /* Ultra initialization */

  static const struct hda_verb ad1986a_ultra_init[] = {

  	/* eapd initialization */
  	{ 0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
  	/* CLFE -> Mic in */
  	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2 },
  	{ 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
  	{ 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
  	{ } /* end */
  };

  /* pin sensing on HP jack */

  static const struct hda_verb ad1986a_hp_init_verbs[] = {

  	{0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_HP_EVENT},
  	{}
  };

  static void ad1986a_samsung_p50_unsol_event(struct hda_codec *codec,
  					    unsigned int res)
  {
  	switch (res >> 26) {
  	case AD1986A_HP_EVENT:
  		ad1986a_hp_automute(codec);
  		break;
  	case AD1986A_MIC_EVENT:
  		ad1986a_automic(codec);
  		break;
  	}
  }
  
  static int ad1986a_samsung_p50_init(struct hda_codec *codec)
  {
  	ad198x_init(codec);
  	ad1986a_hp_automute(codec);
  	ad1986a_automic(codec);
  	return 0;
  }

  /* models */

  enum {
  	AD1986A_6STACK,
  	AD1986A_3STACK,
  	AD1986A_LAPTOP,
  	AD1986A_LAPTOP_EAPD,

  	AD1986A_LAPTOP_AUTOMUTE,

  	AD1986A_ULTRA,

  	AD1986A_SAMSUNG,

  	AD1986A_SAMSUNG_P50,

  	AD1986A_MODELS
  };

  static const char * const ad1986a_models[AD1986A_MODELS] = {

  	[AD1986A_6STACK]	= "6stack",
  	[AD1986A_3STACK]	= "3stack",
  	[AD1986A_LAPTOP]	= "laptop",
  	[AD1986A_LAPTOP_EAPD]	= "laptop-eapd",

  	[AD1986A_LAPTOP_AUTOMUTE] = "laptop-automute",

  	[AD1986A_ULTRA]		= "ultra",

  	[AD1986A_SAMSUNG]	= "samsung",

  	[AD1986A_SAMSUNG_P50]	= "samsung-p50",

  };

  static const struct snd_pci_quirk ad1986a_cfg_tbl[] = {

  	SND_PCI_QUIRK(0x103c, 0x30af, "HP B2800", AD1986A_LAPTOP_EAPD),

  	SND_PCI_QUIRK(0x1043, 0x1153, "ASUS M9", AD1986A_LAPTOP_EAPD),

  	SND_PCI_QUIRK(0x1043, 0x11f7, "ASUS U5A", AD1986A_LAPTOP_EAPD),

  	SND_PCI_QUIRK(0x1043, 0x1213, "ASUS A6J", AD1986A_LAPTOP_EAPD),

  	SND_PCI_QUIRK(0x1043, 0x1263, "ASUS U5F", AD1986A_LAPTOP_EAPD),
  	SND_PCI_QUIRK(0x1043, 0x1297, "ASUS Z62F", AD1986A_LAPTOP_EAPD),
  	SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS V1j", AD1986A_LAPTOP_EAPD),
  	SND_PCI_QUIRK(0x1043, 0x1302, "ASUS W3j", AD1986A_LAPTOP_EAPD),

  	SND_PCI_QUIRK(0x1043, 0x1443, "ASUS VX1", AD1986A_LAPTOP),

  	SND_PCI_QUIRK(0x1043, 0x1447, "ASUS A8J", AD1986A_3STACK),

  	SND_PCI_QUIRK(0x1043, 0x817f, "ASUS P5", AD1986A_3STACK),
  	SND_PCI_QUIRK(0x1043, 0x818f, "ASUS P5", AD1986A_LAPTOP),
  	SND_PCI_QUIRK(0x1043, 0x81b3, "ASUS P5", AD1986A_3STACK),
  	SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS M2N", AD1986A_3STACK),
  	SND_PCI_QUIRK(0x1043, 0x8234, "ASUS M2N", AD1986A_3STACK),

  	SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_3STACK),

  	SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba Satellite L40-10Q", AD1986A_3STACK),

  	SND_PCI_QUIRK(0x144d, 0xb03c, "Samsung R55", AD1986A_3STACK),

  	SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_LAPTOP),

  	SND_PCI_QUIRK(0x144d, 0xc024, "Samsung P50", AD1986A_SAMSUNG_P50),

  	SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_ULTRA),

  	SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc000, "Samsung", AD1986A_SAMSUNG),

  	SND_PCI_QUIRK(0x144d, 0xc504, "Samsung Q35", AD1986A_3STACK),

  	SND_PCI_QUIRK(0x17aa, 0x1011, "Lenovo M55", AD1986A_LAPTOP),

  	SND_PCI_QUIRK(0x17aa, 0x1017, "Lenovo A60", AD1986A_3STACK),

  	SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo N100", AD1986A_LAPTOP_AUTOMUTE),

  	SND_PCI_QUIRK(0x17c0, 0x2017, "Samsung M50", AD1986A_LAPTOP),

  	{}
  };

  #ifdef CONFIG_SND_HDA_POWER_SAVE

  static const struct hda_amp_list ad1986a_loopbacks[] = {

  	{ 0x13, HDA_OUTPUT, 0 }, /* Mic */
  	{ 0x14, HDA_OUTPUT, 0 }, /* Phone */
  	{ 0x15, HDA_OUTPUT, 0 }, /* CD */
  	{ 0x16, HDA_OUTPUT, 0 }, /* Aux */
  	{ 0x17, HDA_OUTPUT, 0 }, /* Line */
  	{ } /* end */
  };
  #endif

  static int is_jack_available(struct hda_codec *codec, hda_nid_t nid)
  {

  	unsigned int conf = snd_hda_codec_get_pincfg(codec, nid);

  	return get_defcfg_connect(conf) != AC_JACK_PORT_NONE;
  }

  static int patch_ad1986a(struct hda_codec *codec)

  {

  	struct ad198x_spec *spec;

  	int err, board_config;

  	spec = kzalloc(sizeof(*spec), GFP_KERNEL);

  	if (spec == NULL)
  		return -ENOMEM;

  	codec->spec = spec;

  	err = snd_hda_attach_beep_device(codec, 0x19);
  	if (err < 0) {
  		ad198x_free(codec);
  		return err;
  	}
  	set_beep_amp(spec, 0x18, 0, HDA_OUTPUT);

  	spec->multiout.max_channels = 6;
  	spec->multiout.num_dacs = ARRAY_SIZE(ad1986a_dac_nids);
  	spec->multiout.dac_nids = ad1986a_dac_nids;
  	spec->multiout.dig_out_nid = AD1986A_SPDIF_OUT;

  	spec->num_adc_nids = 1;
  	spec->adc_nids = ad1986a_adc_nids;

  	spec->capsrc_nids = ad1986a_capsrc_nids;

  	spec->input_mux = &ad1986a_capture_source;

  	spec->num_mixers = 1;
  	spec->mixers[0] = ad1986a_mixers;
  	spec->num_init_verbs = 1;
  	spec->init_verbs[0] = ad1986a_init_verbs;

  #ifdef CONFIG_SND_HDA_POWER_SAVE
  	spec->loopback.amplist = ad1986a_loopbacks;
  #endif

  	spec->vmaster_nid = 0x1b;

  	spec->inv_eapd = 1; /* AD1986A has the inverted EAPD implementation */

  
  	codec->patch_ops = ad198x_patch_ops;

  	/* override some parameters */

  	board_config = snd_hda_check_board_config(codec, AD1986A_MODELS,
  						  ad1986a_models,
  						  ad1986a_cfg_tbl);

  	switch (board_config) {
  	case AD1986A_3STACK:
  		spec->num_mixers = 2;
  		spec->mixers[1] = ad1986a_3st_mixers;

  		spec->num_init_verbs = 2;
  		spec->init_verbs[1] = ad1986a_ch2_init;

  		spec->channel_mode = ad1986a_modes;
  		spec->num_channel_mode = ARRAY_SIZE(ad1986a_modes);

  		spec->need_dac_fix = 1;
  		spec->multiout.max_channels = 2;
  		spec->multiout.num_dacs = 1;

  		break;
  	case AD1986A_LAPTOP:
  		spec->mixers[0] = ad1986a_laptop_mixers;
  		spec->multiout.max_channels = 2;
  		spec->multiout.num_dacs = 1;
  		spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
  		break;

  	case AD1986A_LAPTOP_EAPD:

  		spec->num_mixers = 3;
  		spec->mixers[0] = ad1986a_laptop_master_mixers;
  		spec->mixers[1] = ad1986a_laptop_eapd_mixers;
  		spec->mixers[2] = ad1986a_laptop_intmic_mixers;

  		spec->num_init_verbs = 2;
  		spec->init_verbs[1] = ad1986a_eapd_init_verbs;
  		spec->multiout.max_channels = 2;
  		spec->multiout.num_dacs = 1;
  		spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
  		if (!is_jack_available(codec, 0x25))
  			spec->multiout.dig_out_nid = 0;
  		spec->input_mux = &ad1986a_laptop_eapd_capture_source;
  		break;
  	case AD1986A_SAMSUNG:

  		spec->num_mixers = 2;
  		spec->mixers[0] = ad1986a_laptop_master_mixers;
  		spec->mixers[1] = ad1986a_laptop_eapd_mixers;

  		spec->num_init_verbs = 3;

  		spec->init_verbs[1] = ad1986a_eapd_init_verbs;

  		spec->init_verbs[2] = ad1986a_automic_verbs;

  		spec->multiout.max_channels = 2;
  		spec->multiout.num_dacs = 1;
  		spec->multiout.dac_nids = ad1986a_laptop_dac_nids;

  		if (!is_jack_available(codec, 0x25))
  			spec->multiout.dig_out_nid = 0;

  		spec->input_mux = &ad1986a_automic_capture_source;
  		codec->patch_ops.unsol_event = ad1986a_automic_unsol_event;
  		codec->patch_ops.init = ad1986a_automic_init;

  		break;

  	case AD1986A_SAMSUNG_P50:
  		spec->num_mixers = 2;
  		spec->mixers[0] = ad1986a_automute_master_mixers;
  		spec->mixers[1] = ad1986a_laptop_eapd_mixers;
  		spec->num_init_verbs = 4;
  		spec->init_verbs[1] = ad1986a_eapd_init_verbs;
  		spec->init_verbs[2] = ad1986a_automic_verbs;
  		spec->init_verbs[3] = ad1986a_hp_init_verbs;
  		spec->multiout.max_channels = 2;
  		spec->multiout.num_dacs = 1;
  		spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
  		if (!is_jack_available(codec, 0x25))
  			spec->multiout.dig_out_nid = 0;
  		spec->input_mux = &ad1986a_automic_capture_source;
  		codec->patch_ops.unsol_event = ad1986a_samsung_p50_unsol_event;
  		codec->patch_ops.init = ad1986a_samsung_p50_init;
  		break;

  	case AD1986A_LAPTOP_AUTOMUTE:

  		spec->num_mixers = 3;
  		spec->mixers[0] = ad1986a_automute_master_mixers;
  		spec->mixers[1] = ad1986a_laptop_eapd_mixers;
  		spec->mixers[2] = ad1986a_laptop_intmic_mixers;

  		spec->num_init_verbs = 3;
  		spec->init_verbs[1] = ad1986a_eapd_init_verbs;
  		spec->init_verbs[2] = ad1986a_hp_init_verbs;
  		spec->multiout.max_channels = 2;
  		spec->multiout.num_dacs = 1;
  		spec->multiout.dac_nids = ad1986a_laptop_dac_nids;

  		if (!is_jack_available(codec, 0x25))
  			spec->multiout.dig_out_nid = 0;

  		spec->input_mux = &ad1986a_laptop_eapd_capture_source;
  		codec->patch_ops.unsol_event = ad1986a_hp_unsol_event;
  		codec->patch_ops.init = ad1986a_hp_init;

  		/* Lenovo N100 seems to report the reversed bit
  		 * for HP jack-sensing
  		 */
  		spec->inv_jack_detect = 1;

  		break;

  	case AD1986A_ULTRA:
  		spec->mixers[0] = ad1986a_laptop_eapd_mixers;
  		spec->num_init_verbs = 2;
  		spec->init_verbs[1] = ad1986a_ultra_init;
  		spec->multiout.max_channels = 2;
  		spec->multiout.num_dacs = 1;
  		spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
  		spec->multiout.dig_out_nid = 0;
  		break;

  	}

  	/* AD1986A has a hardware problem that it can't share a stream
  	 * with multiple output pins.  The copy of front to surrounds
  	 * causes noisy or silent outputs at a certain timing, e.g.
  	 * changing the volume.
  	 * So, let's disable the shared stream.
  	 */
  	spec->multiout.no_share_stream = 1;

  	codec->no_trigger_sense = 1;

  	codec->no_sticky_stream = 1;

  	return 0;
  }
  
  /*

   * AD1983 specific

   */

  #define AD1983_SPDIF_OUT	0x02
  #define AD1983_DAC		0x03
  #define AD1983_ADC		0x04

  static const hda_nid_t ad1983_dac_nids[1] = { AD1983_DAC };
  static const hda_nid_t ad1983_adc_nids[1] = { AD1983_ADC };
  static const hda_nid_t ad1983_capsrc_nids[1] = { 0x15 };

  static const struct hda_input_mux ad1983_capture_source = {

  	.num_items = 4,
  	.items = {
  		{ "Mic", 0x0 },
  		{ "Line", 0x1 },
  		{ "Mix", 0x2 },
  		{ "Mix Mono", 0x3 },
  	},
  };

  
  /*

   * SPDIF playback route

   */

  static int ad1983_spdif_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)

  {

  	static const char * const texts[] = { "PCM", "ADC" };

  
  	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
  	uinfo->count = 1;
  	uinfo->value.enumerated.items = 2;
  	if (uinfo->value.enumerated.item > 1)
  		uinfo->value.enumerated.item = 1;
  	strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
  	return 0;

  }

  static int ad1983_spdif_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)

  {

  	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  	struct ad198x_spec *spec = codec->spec;

  	ucontrol->value.enumerated.item[0] = spec->spdif_route;

  	return 0;
  }

  static int ad1983_spdif_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)

  {

  	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  	struct ad198x_spec *spec = codec->spec;

  	if (ucontrol->value.enumerated.item[0] > 1)
  		return -EINVAL;

  	if (spec->spdif_route != ucontrol->value.enumerated.item[0]) {
  		spec->spdif_route = ucontrol->value.enumerated.item[0];

  		snd_hda_codec_write_cache(codec, spec->multiout.dig_out_nid, 0,
  					  AC_VERB_SET_CONNECT_SEL,
  					  spec->spdif_route);

  		return 1;
  	}

  	return 0;
  }

  static const struct snd_kcontrol_new ad1983_mixers[] = {

  	HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),

  	HDA_CODEC_VOLUME("Mic Boost Volume", 0x0c, 0x0, HDA_OUTPUT),

  	HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
  	{
  		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  		.name = "Capture Source",
  		.info = ad198x_mux_enum_info,
  		.get = ad198x_mux_enum_get,
  		.put = ad198x_mux_enum_put,

  	},

  	{
  		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,

  		.name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",

  		.info = ad1983_spdif_route_info,
  		.get = ad1983_spdif_route_get,
  		.put = ad1983_spdif_route_put,

  	},

  	{ } /* end */

  };

  static const struct hda_verb ad1983_init_verbs[] = {

  	/* Front, HP, Mono; mute as default */
  	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	/* Beep, PCM, Mic, Line-In: mute */
  	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	/* Front, HP selectors; from Mix */
  	{0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
  	{0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
  	/* Mono selector; from Mix */
  	{0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
  	/* Mic selector; Mic */
  	{0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
  	/* Line-in selector: Line-in */
  	{0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
  	/* Mic boost: 0dB */
  	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
  	/* Record selector: mic */
  	{0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
  	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	/* SPDIF route: PCM */
  	{0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
  	/* Front Pin */
  	{0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  	/* HP Pin */
  	{0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
  	/* Mono Pin */
  	{0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  	/* Mic Pin */
  	{0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
  	/* Line Pin */
  	{0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
  	{ } /* end */

  };

  #ifdef CONFIG_SND_HDA_POWER_SAVE

  static const struct hda_amp_list ad1983_loopbacks[] = {

  	{ 0x12, HDA_OUTPUT, 0 }, /* Mic */
  	{ 0x13, HDA_OUTPUT, 0 }, /* Line */
  	{ } /* end */
  };
  #endif

  static int patch_ad1983(struct hda_codec *codec)

  {

  	struct ad198x_spec *spec;

  	int err;

  	spec = kzalloc(sizeof(*spec), GFP_KERNEL);

  	if (spec == NULL)
  		return -ENOMEM;

  	codec->spec = spec;

  	err = snd_hda_attach_beep_device(codec, 0x10);
  	if (err < 0) {
  		ad198x_free(codec);
  		return err;
  	}
  	set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);

  	spec->multiout.max_channels = 2;
  	spec->multiout.num_dacs = ARRAY_SIZE(ad1983_dac_nids);
  	spec->multiout.dac_nids = ad1983_dac_nids;
  	spec->multiout.dig_out_nid = AD1983_SPDIF_OUT;

  	spec->num_adc_nids = 1;
  	spec->adc_nids = ad1983_adc_nids;

  	spec->capsrc_nids = ad1983_capsrc_nids;

  	spec->input_mux = &ad1983_capture_source;

  	spec->num_mixers = 1;
  	spec->mixers[0] = ad1983_mixers;
  	spec->num_init_verbs = 1;
  	spec->init_verbs[0] = ad1983_init_verbs;

  	spec->spdif_route = 0;

  #ifdef CONFIG_SND_HDA_POWER_SAVE
  	spec->loopback.amplist = ad1983_loopbacks;
  #endif

  	spec->vmaster_nid = 0x05;

  	codec->patch_ops = ad198x_patch_ops;

  	codec->no_trigger_sense = 1;

  	codec->no_sticky_stream = 1;

  	return 0;
  }

  /*
   * AD1981 HD specific
   */

  #define AD1981_SPDIF_OUT	0x02
  #define AD1981_DAC		0x03
  #define AD1981_ADC		0x04

  static const hda_nid_t ad1981_dac_nids[1] = { AD1981_DAC };
  static const hda_nid_t ad1981_adc_nids[1] = { AD1981_ADC };
  static const hda_nid_t ad1981_capsrc_nids[1] = { 0x15 };

  
  /* 0x0c, 0x09, 0x0e, 0x0f, 0x19, 0x05, 0x18, 0x17 */

  static const struct hda_input_mux ad1981_capture_source = {

  	.num_items = 7,
  	.items = {
  		{ "Front Mic", 0x0 },
  		{ "Line", 0x1 },
  		{ "Mix", 0x2 },
  		{ "Mix Mono", 0x3 },
  		{ "CD", 0x4 },
  		{ "Mic", 0x6 },
  		{ "Aux", 0x7 },
  	},

  };

  static const struct snd_kcontrol_new ad1981_mixers[] = {

  	HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Aux Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Aux Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),

  	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x08, 0x0, HDA_INPUT),
  	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x0, HDA_INPUT),

  	HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
  	{
  		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  		.name = "Capture Source",
  		.info = ad198x_mux_enum_info,
  		.get = ad198x_mux_enum_get,
  		.put = ad198x_mux_enum_put,
  	},
  	/* identical with AD1983 */
  	{
  		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,

  		.name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",

  		.info = ad1983_spdif_route_info,
  		.get = ad1983_spdif_route_get,
  		.put = ad1983_spdif_route_put,
  	},
  	{ } /* end */
  };

  static const struct hda_verb ad1981_init_verbs[] = {

  	/* Front, HP, Mono; mute as default */
  	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	/* Beep, PCM, Front Mic, Line, Rear Mic, Aux, CD-In: mute */
  	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	/* Front, HP selectors; from Mix */
  	{0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
  	{0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
  	/* Mono selector; from Mix */
  	{0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
  	/* Mic Mixer; select Front Mic */
  	{0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
  	{0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	/* Mic boost: 0dB */

  	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
  	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},

  	/* Record selector: Front mic */
  	{0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
  	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	/* SPDIF route: PCM */
  	{0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
  	/* Front Pin */
  	{0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  	/* HP Pin */
  	{0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
  	/* Mono Pin */
  	{0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  	/* Front & Rear Mic Pins */
  	{0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
  	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
  	/* Line Pin */
  	{0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
  	/* Digital Beep */
  	{0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
  	/* Line-Out as Input: disabled */
  	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  	{ } /* end */
  };

  #ifdef CONFIG_SND_HDA_POWER_SAVE

  static const struct hda_amp_list ad1981_loopbacks[] = {

  	{ 0x12, HDA_OUTPUT, 0 }, /* Front Mic */
  	{ 0x13, HDA_OUTPUT, 0 }, /* Line */
  	{ 0x1b, HDA_OUTPUT, 0 }, /* Aux */
  	{ 0x1c, HDA_OUTPUT, 0 }, /* Mic */
  	{ 0x1d, HDA_OUTPUT, 0 }, /* CD */
  	{ } /* end */
  };
  #endif

  /*
   * Patch for HP nx6320
   *

   * nx6320 uses EAPD in the reverse way - EAPD-on means the internal

   * speaker output enabled _and_ mute-LED off.
   */
  
  #define AD1981_HP_EVENT		0x37
  #define AD1981_MIC_EVENT	0x38

  static const struct hda_verb ad1981_hp_init_verbs[] = {

  	{0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, /* default off */
  	/* pin sensing on HP and Mic jacks */
  	{0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
  	{0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
  	{}
  };
  
  /* turn on/off EAPD (+ mute HP) as a master switch */
  static int ad1981_hp_master_sw_put(struct snd_kcontrol *kcontrol,
  				   struct snd_ctl_elem_value *ucontrol)
  {
  	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  	struct ad198x_spec *spec = codec->spec;
  
  	if (! ad198x_eapd_put(kcontrol, ucontrol))
  		return 0;

  	/* change speaker pin appropriately */
  	snd_hda_codec_write(codec, 0x05, 0,
  			    AC_VERB_SET_PIN_WIDGET_CONTROL,
  			    spec->cur_eapd ? PIN_OUT : 0);

  	/* toggle HP mute appropriately */

  	snd_hda_codec_amp_stereo(codec, 0x06, HDA_OUTPUT, 0,
  				 HDA_AMP_MUTE,
  				 spec->cur_eapd ? 0 : HDA_AMP_MUTE);

  	return 1;
  }
  
  /* bind volumes of both NID 0x05 and 0x06 */

  static const struct hda_bind_ctls ad1981_hp_bind_master_vol = {

  	.ops = &snd_hda_bind_vol,
  	.values = {
  		HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
  		HDA_COMPOSE_AMP_VAL(0x06, 3, 0, HDA_OUTPUT),
  		0
  	},
  };

  
  /* mute internal speaker if HP is plugged */
  static void ad1981_hp_automute(struct hda_codec *codec)
  {
  	unsigned int present;

  	present = snd_hda_jack_detect(codec, 0x06);

  	snd_hda_codec_amp_stereo(codec, 0x05, HDA_OUTPUT, 0,
  				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);

  }
  
  /* toggle input of built-in and mic jack appropriately */
  static void ad1981_hp_automic(struct hda_codec *codec)
  {

  	static const struct hda_verb mic_jack_on[] = {

  		{0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  		{0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
  		{}
  	};

  	static const struct hda_verb mic_jack_off[] = {

  		{0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  		{0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
  		{}
  	};
  	unsigned int present;

  	present = snd_hda_jack_detect(codec, 0x08);

  	if (present)
  		snd_hda_sequence_write(codec, mic_jack_on);
  	else
  		snd_hda_sequence_write(codec, mic_jack_off);
  }
  
  /* unsolicited event for HP jack sensing */
  static void ad1981_hp_unsol_event(struct hda_codec *codec,
  				  unsigned int res)
  {
  	res >>= 26;
  	switch (res) {
  	case AD1981_HP_EVENT:
  		ad1981_hp_automute(codec);
  		break;
  	case AD1981_MIC_EVENT:
  		ad1981_hp_automic(codec);
  		break;
  	}
  }

  static const struct hda_input_mux ad1981_hp_capture_source = {

  	.num_items = 3,
  	.items = {
  		{ "Mic", 0x0 },
  		{ "Docking-Station", 0x1 },
  		{ "Mix", 0x2 },
  	},
  };

  static const struct snd_kcontrol_new ad1981_hp_mixers[] = {

  	HDA_BIND_VOL("Master Playback Volume", &ad1981_hp_bind_master_vol),

  	{
  		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,

  		.subdevice = HDA_SUBDEV_NID_FLAG | 0x05,

  		.name = "Master Playback Switch",
  		.info = ad198x_eapd_info,
  		.get = ad198x_eapd_get,
  		.put = ad1981_hp_master_sw_put,
  		.private_value = 0x05,
  	},
  	HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
  #if 0
  	/* FIXME: analog mic/line loopback doesn't work with my tests...
  	 *        (although recording is OK)
  	 */
  	HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Docking-Station Playback Volume", 0x13, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Docking-Station Playback Switch", 0x13, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
  	/* FIXME: does this laptop have analog CD connection? */
  	HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
  #endif

  	HDA_CODEC_VOLUME("Mic Boost Volume", 0x08, 0x0, HDA_INPUT),
  	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x18, 0x0, HDA_INPUT),

  	HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
  	{
  		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  		.name = "Capture Source",
  		.info = ad198x_mux_enum_info,
  		.get = ad198x_mux_enum_get,
  		.put = ad198x_mux_enum_put,
  	},
  	{ } /* end */
  };
  
  /* initialize jack-sensing, too */
  static int ad1981_hp_init(struct hda_codec *codec)
  {
  	ad198x_init(codec);
  	ad1981_hp_automute(codec);
  	ad1981_hp_automic(codec);
  	return 0;
  }

  /* configuration for Toshiba Laptops */

  static const struct hda_verb ad1981_toshiba_init_verbs[] = {

  	{0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x01 }, /* default on */
  	/* pin sensing on HP and Mic jacks */
  	{0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
  	{0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
  	{}
  };

  static const struct snd_kcontrol_new ad1981_toshiba_mixers[] = {

  	HDA_CODEC_VOLUME("Amp Volume", 0x1a, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Amp Switch", 0x1a, 0x0, HDA_OUTPUT),
  	{ }
  };

  /* configuration for Lenovo Thinkpad T60 */

  static const struct snd_kcontrol_new ad1981_thinkpad_mixers[] = {

  	HDA_CODEC_VOLUME("Master Playback Volume", 0x05, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Master Playback Switch", 0x05, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
  	HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),

  	HDA_CODEC_VOLUME("Mic Boost Volume", 0x08, 0x0, HDA_INPUT),

  	HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
  	HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
  	{
  		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  		.name = "Capture Source",
  		.info = ad198x_mux_enum_info,
  		.get = ad198x_mux_enum_get,
  		.put = ad198x_mux_enum_put,
  	},

  	/* identical with AD1983 */
  	{
  		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  		.name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
  		.info = ad1983_spdif_route_info,
  		.get = ad1983_spdif_route_get,
  		.put = ad1983_spdif_route_put,
  	},

  	{ } /* end */
  };

  static const struct hda_input_mux ad1981_thinkpad_capture_source = {

  	.num_items = 3,
  	.items = {
  		{ "Mic", 0x0 },
  		{ "Mix", 0x2 },
  		{ "CD", 0x4 },
  	},
  };

  /* models */

  enum {
  	AD1981_BASIC,
  	AD1981_HP,
  	AD1981_THINKPAD,

  	AD1981_TOSHIBA,

  	AD1981_MODELS
  };

  static const char * const ad1981_models[AD1981_MODELS] = {

  	[AD1981_HP]		= "hp",
  	[AD1981_THINKPAD]	= "thinkpad",
  	[AD1981_BASIC]		= "basic",

  	[AD1981_TOSHIBA]	= "toshiba"

  };

  static const struct snd_pci_quirk ad1981_cfg_tbl[] = {

  	SND_PCI_QUIRK(0x1014, 0x0597, "Lenovo Z60", AD1981_THINKPAD),

  	SND_PCI_QUIRK(0x1014, 0x05b7, "Lenovo Z60m", AD1981_THINKPAD),

  	/* All HP models */

  	SND_PCI_QUIRK_VENDOR(0x103c, "HP nx", AD1981_HP),

  	SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba U205", AD1981_TOSHIBA),

  	/* Lenovo Thinkpad T60/X60/Z6xx */

  	SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1981_THINKPAD),

  	/* HP nx6320 (reversed SSID, H/W bug) */
  	SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_HP),

  	{}
  };

  static int patch_ad1981(struct hda_codec *codec)

  {

  	struct ad198x_spec *spec;

  	int err, board_config;

  	spec = kzalloc(sizeof(*spec), GFP_KERNEL);

  	if (spec == NULL)
  		return -ENOMEM;

  	codec->spec = spec;

  	err = snd_hda_attach_beep_device(codec, 0x10);
  	if (err < 0) {
  		ad198x_free(codec);
  		return err;
  	}
  	set_beep_amp(spec, 0x0d, 0, HDA_OUTPUT);

  	spec->multiout.max_channels = 2;
  	spec->multiout.num_dacs = ARRAY_SIZE(ad1981_dac_nids);
  	spec->multiout.dac_nids = ad1981_dac_nids;
  	spec->multiout.dig_out_nid = AD1981_SPDIF_OUT;

  	spec->num_adc_nids = 1;
  	spec->adc_nids = ad1981_adc_nids;

  	spec->capsrc_nids = ad1981_capsrc_nids;

  	spec->input_mux = &ad1981_capture_source;

  	spec->num_mixers = 1;
  	spec->mixers[0] = ad1981_mixers;
  	spec->num_init_verbs = 1;
  	spec->init_verbs[0] = ad1981_init_verbs;

  	spec->spdif_route = 0;

  #ifdef CONFIG_SND_HDA_POWER_SAVE
  	spec->loopback.amplist = ad1981_loopbacks;
  #endif

  	spec->vmaster_nid = 0x05;

  	codec->patch_ops = ad198x_patch_ops;

  	/* override some parameters */

  	board_config = snd_hda_check_board_config(codec, AD1981_MODELS,
  						  ad1981_models,
  						  ad1981_cfg_tbl);

  	switch (board_config) {
  	case AD1981_HP:
  		spec->mixers[0] = ad1981_hp_mixers;
  		spec->num_init_verbs = 2;
  		spec->init_verbs[1] = ad1981_hp_init_verbs;

  		if (!is_jack_available(codec, 0x0a))
  			spec->multiout.dig_out_nid = 0;

  		spec->input_mux = &ad1981_hp_capture_source;
  
  		codec->patch_ops.init = ad1981_hp_init;
  		codec->patch_ops.unsol_event = ad1981_hp_unsol_event;

  		/* set the upper-limit for mixer amp to 0dB for avoiding the
  		 * possible damage by overloading
  		 */
  		snd_hda_override_amp_caps(codec, 0x11, HDA_INPUT,
  					  (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
  					  (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
  					  (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
  					  (1 << AC_AMPCAP_MUTE_SHIFT));

  		break;

  	case AD1981_THINKPAD:
  		spec->mixers[0] = ad1981_thinkpad_mixers;

  		spec->input_mux = &ad1981_thinkpad_capture_source;

  		/* set the upper-limit for mixer amp to 0dB for avoiding the
  		 * possible damage by overloading
  		 */
  		snd_hda_override_amp_caps(codec, 0x11, HDA_INPUT,
  					  (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
  					  (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
  					  (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
  					  (1 << AC_AMPCAP_MUTE_SHIFT));

  		break;

  	case AD1981_TOSHIBA:
  		spec->mixers[0] = ad1981_hp_mixers;
  		spec->mixers[1] = ad1981_toshiba_mixers;
  		spec->num_init_verbs = 2;
  		spec->init_verbs[1] = ad1981_toshiba_init_verbs;
  		spec->multiout.dig_out_nid = 0;
  		spec->input_mux = &ad1981_hp_capture_source;
  		codec->patch_ops.init = ad1981_hp_init;
  		codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
  		break;

  	}

  
  	codec->no_trigger_sense = 1;

  	codec->no_sticky_stream = 1;

  	return 0;
  }

  /*

   * AD1988
   *
   * Output pins and routes
   *

   *        Pin               Mix     Sel     DAC (*)

   * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06
   * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06
   * port-C 0x15 (mute)    <- 0x2c <- 0x31 <- 05/0a
   * port-D 0x12 (mute/hp) <- 0x29         <- 04
   * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a
   * port-F 0x16 (mute)    <- 0x2a         <- 06
   * port-G 0x24 (mute)    <- 0x27         <- 05
   * port-H 0x25 (mute)    <- 0x28         <- 0a
   * mono   0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06
   *

   * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah
   * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug.

   *
   * Input pins and routes
   *
   *        pin     boost   mix input # / adc input #
   * port-A 0x11 -> 0x38 -> mix 2, ADC 0
   * port-B 0x14 -> 0x39 -> mix 0, ADC 1
   * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2
   * port-D 0x12 -> 0x3d -> mix 3, ADC 8
   * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4
   * port-F 0x16 -> 0x3b -> mix 5, ADC 3
   * port-G 0x24 -> N/A  -> 33:1 - mix 1, 34:1 - mix 4, ADC 6
   * port-H 0x25 -> N/A  -> 33:2 - mix 1, 34:2 - mix 4, ADC 7
   *
   *
   * DAC assignment

   *   6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03

   *   3stack - front/surr/CLFE/opt DACs - 04/05/0a/03

   *
   * Inputs of Analog Mix (0x20)
   *   0:Port-B (front mic)
   *   1:Port-C/G/H (line-in)
   *   2:Port-A
   *   3:Port-D (line-in/2)
   *   4:Port-E/G/H (mic-in)
   *   5:Port-F (mic2-in)
   *   6:CD
   *   7:Beep
   *
   * ADC selection
   *   0:Port-A
   *   1:Port-B (front mic-in)
   *   2:Port-C (line-in)
   *   3:Port-F (mic2-in)
   *   4:Port-E (mic-in)
   *   5:CD
   *   6:Port-G
   *   7:Port-H
   *   8:Port-D (line-in/2)
   *   9:Mix
   *
   * Proposed pin assignments by the datasheet
   *
   * 6-stack
   * Port-A front headphone
   *      B front mic-in
   *      C rear line-in
   *      D rear front-out
   *      E rear mic-in
   *      F rear surround
   *      G rear CLFE
   *      H rear side
   *
   * 3-stack
   * Port-A front headphone
   *      B front mic
   *      C rear line-in/surround
   *      D rear front-out
   *      E rear mic-in/CLFE
   *
   * laptop
   * Port-A headphone
   *      B mic-in
   *      C docking station
   *      D internal speaker (with EAPD)
   *      E/F quad mic array
   */
  
  
  /* models */
  enum {
  	AD1988_6STACK,
  	AD1988_6STACK_DIG,
  	AD1988_3STACK,
  	AD1988_3STACK_DIG,
  	AD1988_LAPTOP,
  	AD1988_LAPTOP_DIG,

  	AD1988_AUTO,

  	AD1988_MODEL_LAST,
  };

  /* reivision id to check workarounds */
  #define AD1988A_REV2		0x100200

  #define is_rev2(codec) \
  	((codec)->vendor_id == 0x11d41988 && \
  	 (codec)->revision_id == AD1988A_REV2)

  
  /*
   * mixers
   */

  static const hda_nid_t ad1988_6stack_dac_nids[4] = {

  	0x04, 0x06, 0x05, 0x0a
  };

  static const hda_nid_t ad1988_3stack_dac_nids[3] = {

  	0x04, 0x05, 0x0a

  };
  
  /* for AD1988A revision-2, DAC2-4 are swapped */

  static const hda_nid_t ad1988_6stack_dac_nids_rev2[4] = {

  	0x04, 0x05, 0x0a, 0x06
  };

  static const hda_nid_t ad1988_alt_dac_nid[1] = {

  	0x03
  };

  static const hda_nid_t ad1988_3stack_dac_nids_rev2[3] = {

  	0x04, 0x0a, 0x06

  };

  static const hda_nid_t ad1988_adc_nids[3] = {