/*
   * Universal Interface for Intel High Definition Audio Codec
   *

   * HD audio interface patch for Realtek ALC codecs

   *

   * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
   *                    PeiSen Hou <pshou@realtek.com.tw>

   *                    Takashi Iwai <tiwai@suse.de>

   *                    Jonathan Woithe <jwoithe@physics.adelaide.edu.au>

   *
   *  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 <sound/jack.h>

  #include "hda_codec.h"
  #include "hda_local.h"

  #include "hda_beep.h"

  #include "hda_jack.h"

  /* unsol event tags */
  #define ALC_FRONT_EVENT		0x01
  #define ALC_DCVOL_EVENT		0x02
  #define ALC_HP_EVENT		0x04
  #define ALC_MIC_EVENT		0x08

  /* for GPIO Poll */
  #define GPIO_MASK	0x03

  /* extra amp-initialization sequence types */
  enum {
  	ALC_INIT_NONE,
  	ALC_INIT_DEFAULT,
  	ALC_INIT_GPIO1,
  	ALC_INIT_GPIO2,
  	ALC_INIT_GPIO3,
  };

  struct alc_customize_define {
  	unsigned int  sku_cfg;
  	unsigned char port_connectivity;
  	unsigned char check_sum;
  	unsigned char customization;
  	unsigned char external_amp;
  	unsigned int  enable_pcbeep:1;
  	unsigned int  platform_type:1;
  	unsigned int  swap:1;
  	unsigned int  override:1;

  	unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */

  };

  struct alc_fixup;

  struct alc_multi_io {
  	hda_nid_t pin;		/* multi-io widget pin NID */
  	hda_nid_t dac;		/* DAC to be connected */
  	unsigned int ctl_in;	/* cached input-pin control value */
  };

  enum {

  	ALC_AUTOMUTE_PIN,	/* change the pin control */
  	ALC_AUTOMUTE_AMP,	/* mute/unmute the pin AMP */
  	ALC_AUTOMUTE_MIXER,	/* mute/unmute mixer widget AMP */

  };

  struct alc_spec {
  	/* codec parameterization */

  	const struct snd_kcontrol_new *mixers[5];	/* mixer arrays */

  	unsigned int num_mixers;

  	const struct snd_kcontrol_new *cap_mixer;	/* capture mixer */

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

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

  						 * don't forget NULL
  						 * termination!

  						 */
  	unsigned int num_init_verbs;

  	char stream_name_analog[32];	/* analog PCM stream */

  	const struct hda_pcm_stream *stream_analog_playback;
  	const struct hda_pcm_stream *stream_analog_capture;
  	const struct hda_pcm_stream *stream_analog_alt_playback;
  	const struct hda_pcm_stream *stream_analog_alt_capture;

  	char stream_name_digital[32];	/* digital PCM stream */

  	const struct hda_pcm_stream *stream_digital_playback;
  	const struct hda_pcm_stream *stream_digital_capture;

  
  	/* playback */

  	struct hda_multi_out multiout;	/* playback set-up
  					 * max_channels, dacs must be set
  					 * dig_out_nid and hp_nid are optional
  					 */

  	hda_nid_t alt_dac_nid;

  	hda_nid_t slave_dig_outs[3];	/* optional - for auto-parsing */

  	int dig_out_type;

  
  	/* capture */
  	unsigned int num_adc_nids;

  	const hda_nid_t *adc_nids;
  	const hda_nid_t *capsrc_nids;

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

  	hda_nid_t mixer_nid;		/* analog-mixer NID */

  	DECLARE_BITMAP(vol_ctls, 0x20 << 1);
  	DECLARE_BITMAP(sw_ctls, 0x20 << 1);

  	/* capture setup for dynamic dual-adc switch */

  	hda_nid_t cur_adc;
  	unsigned int cur_adc_stream_tag;
  	unsigned int cur_adc_format;

  	/* capture source */

  	unsigned int num_mux_defs;

  	const struct hda_input_mux *input_mux;
  	unsigned int cur_mux[3];

  	hda_nid_t ext_mic_pin;
  	hda_nid_t dock_mic_pin;
  	hda_nid_t int_mic_pin;

  
  	/* channel model */

  	const struct hda_channel_mode *channel_mode;

  	int num_channel_mode;

  	int need_dac_fix;

  	int const_channel_count;
  	int ext_channel_count;

  
  	/* PCM information */

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

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

  	struct alc_customize_define cdefine;

  	struct snd_array kctls;

  	struct hda_input_mux private_imux[3];

  	hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];

  	hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
  	hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];

  	hda_nid_t imux_pins[HDA_MAX_NUM_INPUTS];
  	unsigned int dyn_adc_idx[HDA_MAX_NUM_INPUTS];
  	int int_mic_idx, ext_mic_idx, dock_mic_idx; /* for auto-mic */

  	/* hooks */
  	void (*init_hook)(struct hda_codec *codec);
  	void (*unsol_event)(struct hda_codec *codec, unsigned int res);

  #ifdef CONFIG_SND_HDA_POWER_SAVE

  	void (*power_hook)(struct hda_codec *codec);

  #endif

  	void (*shutup)(struct hda_codec *codec);

  	void (*automute_hook)(struct hda_codec *codec);

  	/* for pin sensing */

  	unsigned int hp_jack_present:1;

  	unsigned int line_jack_present:1;

  	unsigned int master_mute:1;

  	unsigned int auto_mic:1;

  	unsigned int auto_mic_valid_imux:1;	/* valid imux for auto-mic */

  	unsigned int automute_speaker:1; /* automute speaker outputs */
  	unsigned int automute_lo:1; /* automute LO outputs */
  	unsigned int detect_hp:1;	/* Headphone detection enabled */
  	unsigned int detect_lo:1;	/* Line-out detection enabled */
  	unsigned int automute_speaker_possible:1; /* there are speakers and either LO or HP */
  	unsigned int automute_lo_possible:1;	  /* there are line outs and HP */

  	/* other flags */
  	unsigned int no_analog :1; /* digital I/O only */

  	unsigned int dyn_adc_switch:1; /* switch ADCs (for ALC275) */

  	unsigned int single_input_src:1;

  	unsigned int vol_in_capsrc:1; /* use capsrc volume (ADC has no vol) */

  	unsigned int parse_flags; /* passed to snd_hda_parse_pin_defcfg() */

  	unsigned int shared_mic_hp:1; /* HP/Mic-in sharing */

  	unsigned int use_jack_tbl:1; /* 1 for model=auto */

  
  	/* auto-mute control */
  	int automute_mode;

  	hda_nid_t automute_mixer_nid[AUTO_CFG_MAX_OUTS];

  	int init_amp;

  	int codec_variant;	/* flag for other variants */

  	/* for virtual master */
  	hda_nid_t vmaster_nid;

  #ifdef CONFIG_SND_HDA_POWER_SAVE
  	struct hda_loopback_check loopback;
  #endif

  
  	/* for PLL fix */
  	hda_nid_t pll_nid;
  	unsigned int pll_coef_idx, pll_coef_bit;

  	unsigned int coef0;

  
  	/* fix-up list */
  	int fixup_id;
  	const struct alc_fixup *fixup_list;
  	const char *fixup_name;

  
  	/* multi-io */
  	int multi_ios;
  	struct alc_multi_io multi_io[4];

  
  	/* bind volumes */
  	struct snd_array bind_ctls;

  };

  #define ALC_MODEL_AUTO		0	/* common for all chips */

  static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
  			   int dir, unsigned int bits)
  {
  	if (!nid)
  		return false;
  	if (get_wcaps(codec, nid) & (1 << (dir + 1)))
  		if (query_amp_caps(codec, nid, dir) & bits)
  			return true;
  	return false;
  }
  
  #define nid_has_mute(codec, nid, dir) \
  	check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
  #define nid_has_volume(codec, nid, dir) \
  	check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)

  /*
   * input MUX handling
   */

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

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

  	unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
  	if (mux_idx >= spec->num_mux_defs)
  		mux_idx = 0;

  	if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
  		mux_idx = 0;

  	return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);

  }

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

  {
  	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  	struct alc_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 bool alc_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
  {
  	struct alc_spec *spec = codec->spec;
  	hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
  
  	if (spec->cur_adc && spec->cur_adc != new_adc) {
  		/* stream is running, let's swap the current ADC */
  		__snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
  		spec->cur_adc = new_adc;
  		snd_hda_codec_setup_stream(codec, new_adc,
  					   spec->cur_adc_stream_tag, 0,
  					   spec->cur_adc_format);
  		return true;
  	}
  	return false;
  }

  static inline hda_nid_t get_capsrc(struct alc_spec *spec, int idx)
  {
  	return spec->capsrc_nids ?
  		spec->capsrc_nids[idx] : spec->adc_nids[idx];
  }

  static void call_update_outputs(struct hda_codec *codec);

  /* select the given imux item; either unmute exclusively or select the route */
  static int alc_mux_select(struct hda_codec *codec, unsigned int adc_idx,
  			  unsigned int idx, bool force)

  {

  	struct alc_spec *spec = codec->spec;

  	const struct hda_input_mux *imux;

  	unsigned int mux_idx;

  	int i, type, num_conns;

  	hda_nid_t nid;

  	mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
  	imux = &spec->input_mux[mux_idx];

  	if (!imux->num_items && mux_idx > 0)
  		imux = &spec->input_mux[0];

  	if (!imux->num_items)
  		return 0;

  	if (idx >= imux->num_items)
  		idx = imux->num_items - 1;
  	if (spec->cur_mux[adc_idx] == idx && !force)
  		return 0;
  	spec->cur_mux[adc_idx] = idx;

  	/* for shared I/O, change the pin-control accordingly */
  	if (spec->shared_mic_hp) {
  		/* NOTE: this assumes that there are only two inputs, the
  		 * first is the real internal mic and the second is HP jack.
  		 */
  		snd_hda_codec_write(codec, spec->autocfg.inputs[1].pin, 0,
  				    AC_VERB_SET_PIN_WIDGET_CONTROL,
  				    spec->cur_mux[adc_idx] ?
  				    PIN_VREF80 : PIN_HP);
  		spec->automute_speaker = !spec->cur_mux[adc_idx];
  		call_update_outputs(codec);
  	}

  	if (spec->dyn_adc_switch) {
  		alc_dyn_adc_pcm_resetup(codec, idx);
  		adc_idx = spec->dyn_adc_idx[idx];
  	}

  	nid = get_capsrc(spec, adc_idx);

  
  	/* no selection? */

  	num_conns = snd_hda_get_conn_list(codec, nid, NULL);
  	if (num_conns <= 1)

  		return 1;

  	type = get_wcaps_type(get_wcaps(codec, nid));

  	if (type == AC_WID_AUD_MIX) {

  		/* Matrix-mixer style (e.g. ALC882) */

  		int active = imux->items[idx].index;
  		for (i = 0; i < num_conns; i++) {
  			unsigned int v = (i == active) ? 0 : HDA_AMP_MUTE;
  			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, i,

  						 HDA_AMP_MUTE, v);
  		}

  	} else {
  		/* MUX style (e.g. ALC880) */

  		snd_hda_codec_write_cache(codec, nid, 0,
  					  AC_VERB_SET_CONNECT_SEL,
  					  imux->items[idx].index);

  	}

  	return 1;
  }
  
  static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
  			    struct snd_ctl_elem_value *ucontrol)
  {
  	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
  	return alc_mux_select(codec, adc_idx,
  			      ucontrol->value.enumerated.item[0], false);

  }

  /*

   * set up the input pin config (depending on the given auto-pin type)
   */
  static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
  			      int auto_pin_type)
  {
  	unsigned int val = PIN_IN;

  	if (auto_pin_type == AUTO_PIN_MIC) {

  		unsigned int pincap;

  		unsigned int oldval;
  		oldval = snd_hda_codec_read(codec, nid, 0,
  					    AC_VERB_GET_PIN_WIDGET_CONTROL, 0);

  		pincap = snd_hda_query_pin_caps(codec, nid);

  		pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;

  		/* if the default pin setup is vref50, we give it priority */
  		if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)

  			val = PIN_VREF80;

  		else if (pincap & AC_PINCAP_VREF_50)
  			val = PIN_VREF50;
  		else if (pincap & AC_PINCAP_VREF_100)
  			val = PIN_VREF100;
  		else if (pincap & AC_PINCAP_VREF_GRD)
  			val = PIN_VREFGRD;

  	}
  	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
  }
  
  /*

   * Append the given mixer and verb elements for the later use
   * The mixer array is referred in build_controls(), and init_verbs are
   * called in init().

   */

  static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)

  {
  	if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
  		return;
  	spec->mixers[spec->num_mixers++] = mix;
  }
  
  static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
  {
  	if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
  		return;
  	spec->init_verbs[spec->num_init_verbs++] = verb;
  }
  
  /*

   * GPIO setup tables, used in initialization

   */

  /* Enable GPIO mask and set output */

  static const struct hda_verb alc_gpio1_init_verbs[] = {

  	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
  	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
  	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
  	{ }
  };

  static const struct hda_verb alc_gpio2_init_verbs[] = {

  	{0x01, AC_VERB_SET_GPIO_MASK, 0x02},
  	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
  	{0x01, AC_VERB_SET_GPIO_DATA, 0x02},
  	{ }
  };

  static const struct hda_verb alc_gpio3_init_verbs[] = {

  	{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
  	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
  	{0x01, AC_VERB_SET_GPIO_DATA, 0x03},
  	{ }
  };

  /*
   * Fix hardware PLL issue
   * On some codecs, the analog PLL gating control must be off while
   * the default value is 1.
   */
  static void alc_fix_pll(struct hda_codec *codec)
  {
  	struct alc_spec *spec = codec->spec;
  	unsigned int val;
  
  	if (!spec->pll_nid)
  		return;
  	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
  			    spec->pll_coef_idx);
  	val = snd_hda_codec_read(codec, spec->pll_nid, 0,
  				 AC_VERB_GET_PROC_COEF, 0);
  	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
  			    spec->pll_coef_idx);
  	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
  			    val & ~(1 << spec->pll_coef_bit));
  }
  
  static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
  			     unsigned int coef_idx, unsigned int coef_bit)
  {
  	struct alc_spec *spec = codec->spec;
  	spec->pll_nid = nid;
  	spec->pll_coef_idx = coef_idx;
  	spec->pll_coef_bit = coef_bit;
  	alc_fix_pll(codec);
  }

  /*

   * Jack detections for HP auto-mute and mic-switch
   */
  
  /* check each pin in the given array; returns true if any of them is plugged */
  static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)

  {

  	int i, present = 0;

  	for (i = 0; i < num_pins; i++) {
  		hda_nid_t nid = pins[i];

  		if (!nid)
  			break;

  		present |= snd_hda_jack_detect(codec, nid);

  	}

  	return present;
  }

  /* standard HP/line-out auto-mute helper */

  static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,

  			bool mute, bool hp_out)

  {
  	struct alc_spec *spec = codec->spec;
  	unsigned int mute_bits = mute ? HDA_AMP_MUTE : 0;

  	unsigned int pin_bits = mute ? 0 : (hp_out ? PIN_HP : PIN_OUT);

  	int i;
  
  	for (i = 0; i < num_pins; i++) {
  		hda_nid_t nid = pins[i];

  		if (!nid)
  			break;

  		switch (spec->automute_mode) {
  		case ALC_AUTOMUTE_PIN:

  			snd_hda_codec_write(codec, nid, 0,

  					    AC_VERB_SET_PIN_WIDGET_CONTROL,
  					    pin_bits);

  			break;
  		case ALC_AUTOMUTE_AMP:

  			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,

  						 HDA_AMP_MUTE, mute_bits);

  			break;
  		case ALC_AUTOMUTE_MIXER:
  			nid = spec->automute_mixer_nid[i];
  			if (!nid)
  				break;
  			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,

  						 HDA_AMP_MUTE, mute_bits);

  			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 1,

  						 HDA_AMP_MUTE, mute_bits);

  			break;

  		}

  	}

  }

  /* Toggle outputs muting */
  static void update_outputs(struct hda_codec *codec)

  {
  	struct alc_spec *spec = codec->spec;

  	int on;

  	/* Control HP pins/amps depending on master_mute state;
  	 * in general, HP pins/amps control should be enabled in all cases,
  	 * but currently set only for master_mute, just to be safe
  	 */

  	if (!spec->shared_mic_hp) /* don't change HP-pin when shared with mic */
  		do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),

  		    spec->autocfg.hp_pins, spec->master_mute, true);

  	if (!spec->automute_speaker)

  		on = 0;
  	else

  		on = spec->hp_jack_present | spec->line_jack_present;

  	on |= spec->master_mute;

  	do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),

  		    spec->autocfg.speaker_pins, on, false);

  
  	/* toggle line-out mutes if needed, too */

  	/* if LO is a copy of either HP or Speaker, don't need to handle it */
  	if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
  	    spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])

  		return;

  	if (!spec->automute_lo)

  		on = 0;
  	else

  		on = spec->hp_jack_present;

  	on |= spec->master_mute;

  	do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),

  		    spec->autocfg.line_out_pins, on, false);

  }

  static void call_update_outputs(struct hda_codec *codec)

  {
  	struct alc_spec *spec = codec->spec;
  	if (spec->automute_hook)
  		spec->automute_hook(codec);
  	else

  		update_outputs(codec);

  }

  /* standard HP-automute helper */

  static void alc_hp_automute(struct hda_codec *codec)
  {
  	struct alc_spec *spec = codec->spec;

  	spec->hp_jack_present =

  		detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
  			     spec->autocfg.hp_pins);

  	if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))

  		return;

  	call_update_outputs(codec);

  }

  /* standard line-out-automute helper */

  static void alc_line_automute(struct hda_codec *codec)
  {
  	struct alc_spec *spec = codec->spec;

  	/* check LO jack only when it's different from HP */
  	if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
  		return;

  	spec->line_jack_present =
  		detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
  			     spec->autocfg.line_out_pins);

  	if (!spec->automute_speaker || !spec->detect_lo)

  		return;

  	call_update_outputs(codec);

  }

  #define get_connection_index(codec, mux, nid) \
  	snd_hda_get_conn_index(codec, mux, nid, 0)

  /* standard mic auto-switch helper */

  static void alc_mic_automute(struct hda_codec *codec)
  {
  	struct alc_spec *spec = codec->spec;

  	hda_nid_t *pins = spec->imux_pins;

  	if (!spec->auto_mic || !spec->auto_mic_valid_imux)

  		return;
  	if (snd_BUG_ON(!spec->adc_nids))
  		return;

  	if (snd_BUG_ON(spec->int_mic_idx < 0 || spec->ext_mic_idx < 0))

  		return;

  	if (snd_hda_jack_detect(codec, pins[spec->ext_mic_idx]))
  		alc_mux_select(codec, 0, spec->ext_mic_idx, false);
  	else if (spec->dock_mic_idx >= 0 &&
  		   snd_hda_jack_detect(codec, pins[spec->dock_mic_idx]))
  		alc_mux_select(codec, 0, spec->dock_mic_idx, false);
  	else
  		alc_mux_select(codec, 0, spec->int_mic_idx, false);

  }

  /* unsolicited event for HP jack sensing */
  static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
  {

  	struct alc_spec *spec = codec->spec;

  	if (codec->vendor_id == 0x10ec0880)
  		res >>= 28;
  	else
  		res >>= 26;

  	if (spec->use_jack_tbl)
  		res = snd_hda_jack_get_action(codec, res);

  	switch (res) {

  	case ALC_HP_EVENT:

  		alc_hp_automute(codec);

  		break;

  	case ALC_FRONT_EVENT:

  		alc_line_automute(codec);
  		break;

  	case ALC_MIC_EVENT:

  		alc_mic_automute(codec);

  		break;
  	}

  	snd_hda_jack_report_sync(codec);

  }

  /* call init functions of standard auto-mute helpers */

  static void alc_inithook(struct hda_codec *codec)
  {

  	alc_hp_automute(codec);

  	alc_line_automute(codec);

  	alc_mic_automute(codec);

  }

  /* additional initialization for ALC888 variants */
  static void alc888_coef_init(struct hda_codec *codec)
  {
  	unsigned int tmp;
  
  	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
  	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
  	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);

  	if ((tmp & 0xf0) == 0x20)

  		/* alc888S-VC */
  		snd_hda_codec_read(codec, 0x20, 0,
  				   AC_VERB_SET_PROC_COEF, 0x830);
  	 else
  		 /* alc888-VB */
  		 snd_hda_codec_read(codec, 0x20, 0,
  				    AC_VERB_SET_PROC_COEF, 0x3030);
  }

  /* additional initialization for ALC889 variants */

  static void alc889_coef_init(struct hda_codec *codec)
  {
  	unsigned int tmp;
  
  	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
  	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
  	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
  	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
  }

  /* turn on/off EAPD control (only if available) */
  static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
  {
  	if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
  		return;
  	if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
  		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
  				    on ? 2 : 0);
  }

  /* turn on/off EAPD controls of the codec */
  static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
  {
  	/* We currently only handle front, HP */

  	static hda_nid_t pins[] = {
  		0x0f, 0x10, 0x14, 0x15, 0
  	};
  	hda_nid_t *p;
  	for (p = pins; *p; p++)
  		set_eapd(codec, *p, on);

  }

  /* generic shutup callback;
   * just turning off EPAD and a little pause for avoiding pop-noise
   */
  static void alc_eapd_shutup(struct hda_codec *codec)
  {
  	alc_auto_setup_eapd(codec, false);
  	msleep(200);
  }

  /* generic EAPD initialization */

  static void alc_auto_init_amp(struct hda_codec *codec, int type)

  {

  	unsigned int tmp;

  	alc_auto_setup_eapd(codec, true);

  	switch (type) {
  	case ALC_INIT_GPIO1:

  		snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
  		break;

  	case ALC_INIT_GPIO2:

  		snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
  		break;

  	case ALC_INIT_GPIO3:

  		snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
  		break;

  	case ALC_INIT_DEFAULT:

  		switch (codec->vendor_id) {
  		case 0x10ec0260:
  			snd_hda_codec_write(codec, 0x1a, 0,
  					    AC_VERB_SET_COEF_INDEX, 7);
  			tmp = snd_hda_codec_read(codec, 0x1a, 0,
  						 AC_VERB_GET_PROC_COEF, 0);
  			snd_hda_codec_write(codec, 0x1a, 0,
  					    AC_VERB_SET_COEF_INDEX, 7);
  			snd_hda_codec_write(codec, 0x1a, 0,
  					    AC_VERB_SET_PROC_COEF,
  					    tmp | 0x2010);
  			break;
  		case 0x10ec0262:
  		case 0x10ec0880:
  		case 0x10ec0882:
  		case 0x10ec0883:
  		case 0x10ec0885:

  		case 0x10ec0887:

  		/*case 0x10ec0889:*/ /* this causes an SPDIF problem */

  			alc889_coef_init(codec);

  			break;

  		case 0x10ec0888:

  			alc888_coef_init(codec);

  			break;

  #if 0 /* XXX: This may cause the silent output on speaker on some machines */

  		case 0x10ec0267:
  		case 0x10ec0268:
  			snd_hda_codec_write(codec, 0x20, 0,
  					    AC_VERB_SET_COEF_INDEX, 7);
  			tmp = snd_hda_codec_read(codec, 0x20, 0,
  						 AC_VERB_GET_PROC_COEF, 0);
  			snd_hda_codec_write(codec, 0x20, 0,

  					    AC_VERB_SET_COEF_INDEX, 7);

  			snd_hda_codec_write(codec, 0x20, 0,
  					    AC_VERB_SET_PROC_COEF,
  					    tmp | 0x3000);
  			break;

  #endif /* XXX */

  		}

  		break;
  	}
  }

  /*
   * Auto-Mute mode mixer enum support
   */

  static int alc_automute_mode_info(struct snd_kcontrol *kcontrol,
  				  struct snd_ctl_elem_info *uinfo)
  {

  	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  	struct alc_spec *spec = codec->spec;
  	static const char * const texts2[] = {
  		"Disabled", "Enabled"
  	};
  	static const char * const texts3[] = {

  		"Disabled", "Speaker Only", "Line-Out+Speaker"
  	};

  	const char * const *texts;

  
  	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
  	uinfo->count = 1;

  	if (spec->automute_speaker_possible && spec->automute_lo_possible) {

  		uinfo->value.enumerated.items = 3;
  		texts = texts3;
  	} else {
  		uinfo->value.enumerated.items = 2;
  		texts = texts2;
  	}
  	if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
  		uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;

  	strcpy(uinfo->value.enumerated.name,
  	       texts[uinfo->value.enumerated.item]);
  	return 0;
  }
  
  static int alc_automute_mode_get(struct snd_kcontrol *kcontrol,
  				 struct snd_ctl_elem_value *ucontrol)
  {
  	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  	struct alc_spec *spec = codec->spec;

  	unsigned int val = 0;
  	if (spec->automute_speaker)
  		val++;
  	if (spec->automute_lo)
  		val++;

  	ucontrol->value.enumerated.item[0] = val;
  	return 0;
  }
  
  static int alc_automute_mode_put(struct snd_kcontrol *kcontrol,
  				 struct snd_ctl_elem_value *ucontrol)
  {
  	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  	struct alc_spec *spec = codec->spec;
  
  	switch (ucontrol->value.enumerated.item[0]) {
  	case 0:

  		if (!spec->automute_speaker && !spec->automute_lo)

  			return 0;

  		spec->automute_speaker = 0;
  		spec->automute_lo = 0;

  		break;
  	case 1:

  		if (spec->automute_speaker_possible) {
  			if (!spec->automute_lo && spec->automute_speaker)
  				return 0;
  			spec->automute_speaker = 1;
  			spec->automute_lo = 0;
  		} else if (spec->automute_lo_possible) {
  			if (spec->automute_lo)
  				return 0;
  			spec->automute_lo = 1;
  		} else
  			return -EINVAL;

  		break;
  	case 2:

  		if (!spec->automute_lo_possible || !spec->automute_speaker_possible)

  			return -EINVAL;

  		if (spec->automute_speaker && spec->automute_lo)

  			return 0;

  		spec->automute_speaker = 1;
  		spec->automute_lo = 1;

  		break;
  	default:
  		return -EINVAL;
  	}

  	call_update_outputs(codec);

  	return 1;
  }

  static const struct snd_kcontrol_new alc_automute_mode_enum = {

  	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  	.name = "Auto-Mute Mode",
  	.info = alc_automute_mode_info,
  	.get = alc_automute_mode_get,
  	.put = alc_automute_mode_put,
  };

  static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec)
  {
  	snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
  	return snd_array_new(&spec->kctls);
  }

  
  static int alc_add_automute_mode_enum(struct hda_codec *codec)
  {
  	struct alc_spec *spec = codec->spec;
  	struct snd_kcontrol_new *knew;
  
  	knew = alc_kcontrol_new(spec);
  	if (!knew)
  		return -ENOMEM;
  	*knew = alc_automute_mode_enum;
  	knew->name = kstrdup("Auto-Mute Mode", GFP_KERNEL);
  	if (!knew->name)
  		return -ENOMEM;
  	return 0;
  }

  /*
   * Check the availability of HP/line-out auto-mute;
   * Set up appropriately if really supported
   */

  static void alc_init_automute(struct hda_codec *codec)

  {
  	struct alc_spec *spec = codec->spec;

  	struct auto_pin_cfg *cfg = &spec->autocfg;

  	int present = 0;

  	int i;

  	if (cfg->hp_pins[0])
  		present++;
  	if (cfg->line_out_pins[0])
  		present++;
  	if (cfg->speaker_pins[0])
  		present++;
  	if (present < 2) /* need two different output types */
  		return;

  	if (!cfg->speaker_pins[0] &&
  	    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {

  		memcpy(cfg->speaker_pins, cfg->line_out_pins,
  		       sizeof(cfg->speaker_pins));
  		cfg->speaker_outs = cfg->line_outs;
  	}

  	if (!cfg->hp_pins[0] &&
  	    cfg->line_out_type == AUTO_PIN_HP_OUT) {

  		memcpy(cfg->hp_pins, cfg->line_out_pins,
  		       sizeof(cfg->hp_pins));
  		cfg->hp_outs = cfg->line_outs;

  	}

  	spec->automute_mode = ALC_AUTOMUTE_PIN;

  	for (i = 0; i < cfg->hp_outs; i++) {

  		hda_nid_t nid = cfg->hp_pins[i];

  		if (!is_jack_detectable(codec, nid))

  			continue;

  		snd_printdd("realtek: Enable HP auto-muting on NID 0x%x
  ",

  			    nid);

  		snd_hda_jack_detect_enable(codec, nid, ALC_HP_EVENT);

  		spec->detect_hp = 1;
  	}
  
  	if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
  		if (cfg->speaker_outs)
  			for (i = 0; i < cfg->line_outs; i++) {
  				hda_nid_t nid = cfg->line_out_pins[i];
  				if (!is_jack_detectable(codec, nid))
  					continue;
  				snd_printdd("realtek: Enable Line-Out "
  					    "auto-muting on NID 0x%x
  ", nid);

  				snd_hda_jack_detect_enable(codec, nid,
  							   ALC_FRONT_EVENT);

  				spec->detect_lo = 1;

  		}

  		spec->automute_lo_possible = spec->detect_hp;

  	}

  	spec->automute_speaker_possible = cfg->speaker_outs &&
  		(spec->detect_hp || spec->detect_lo);
  
  	spec->automute_lo = spec->automute_lo_possible;
  	spec->automute_speaker = spec->automute_speaker_possible;
  
  	if (spec->automute_speaker_possible || spec->automute_lo_possible) {

  		/* create a control for automute mode */
  		alc_add_automute_mode_enum(codec);

  		spec->unsol_event = alc_sku_unsol_event;

  	}

  }

  /* return the position of NID in the list, or -1 if not found */

  static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
  {
  	int i;
  	for (i = 0; i < nums; i++)
  		if (list[i] == nid)
  			return i;
  	return -1;
  }

  /* check whether dynamic ADC-switching is available */
  static bool alc_check_dyn_adc_switch(struct hda_codec *codec)
  {
  	struct alc_spec *spec = codec->spec;
  	struct hda_input_mux *imux = &spec->private_imux[0];
  	int i, n, idx;
  	hda_nid_t cap, pin;
  
  	if (imux != spec->input_mux) /* no dynamic imux? */
  		return false;
  
  	for (n = 0; n < spec->num_adc_nids; n++) {
  		cap = spec->private_capsrc_nids[n];
  		for (i = 0; i < imux->num_items; i++) {
  			pin = spec->imux_pins[i];
  			if (!pin)
  				return false;
  			if (get_connection_index(codec, cap, pin) < 0)
  				break;
  		}
  		if (i >= imux->num_items)

  			return true; /* no ADC-switch is needed */

  	}
  
  	for (i = 0; i < imux->num_items; i++) {
  		pin = spec->imux_pins[i];
  		for (n = 0; n < spec->num_adc_nids; n++) {
  			cap = spec->private_capsrc_nids[n];
  			idx = get_connection_index(codec, cap, pin);
  			if (idx >= 0) {
  				imux->items[i].index = idx;
  				spec->dyn_adc_idx[i] = n;
  				break;
  			}
  		}
  	}
  
  	snd_printdd("realtek: enabling ADC switching
  ");
  	spec->dyn_adc_switch = 1;
  	return true;
  }

  
  /* rebuild imux for matching with the given auto-mic pins (if not yet) */
  static bool alc_rebuild_imux_for_auto_mic(struct hda_codec *codec)
  {
  	struct alc_spec *spec = codec->spec;
  	struct hda_input_mux *imux;
  	static char * const texts[3] = {
  		"Mic", "Internal Mic", "Dock Mic"
  	};
  	int i;
  
  	if (!spec->auto_mic)
  		return false;
  	imux = &spec->private_imux[0];
  	if (spec->input_mux == imux)
  		return true;
  	spec->imux_pins[0] = spec->ext_mic_pin;
  	spec->imux_pins[1] = spec->int_mic_pin;
  	spec->imux_pins[2] = spec->dock_mic_pin;
  	for (i = 0; i < 3; i++) {
  		strcpy(imux->items[i].label, texts[i]);

  		if (spec->imux_pins[i]) {
  			hda_nid_t pin = spec->imux_pins[i];
  			int c;
  			for (c = 0; c < spec->num_adc_nids; c++) {

  				hda_nid_t cap = get_capsrc(spec, c);

  				int idx = get_connection_index(codec, cap, pin);
  				if (idx >= 0) {
  					imux->items[i].index = idx;
  					break;
  				}
  			}

  			imux->num_items = i + 1;

  		}

  	}
  	spec->num_mux_defs = 1;
  	spec->input_mux = imux;
  	return true;
  }
  
  /* check whether all auto-mic pins are valid; setup indices if OK */
  static bool alc_auto_mic_check_imux(struct hda_codec *codec)
  {
  	struct alc_spec *spec = codec->spec;
  	const struct hda_input_mux *imux;
  
  	if (!spec->auto_mic)
  		return false;
  	if (spec->auto_mic_valid_imux)
  		return true; /* already checked */
  
  	/* fill up imux indices */
  	if (!alc_check_dyn_adc_switch(codec)) {
  		spec->auto_mic = 0;
  		return false;
  	}
  
  	imux = spec->input_mux;
  	spec->ext_mic_idx = find_idx_in_nid_list(spec->ext_mic_pin,
  					spec->imux_pins, imux->num_items);
  	spec->int_mic_idx = find_idx_in_nid_list(spec->int_mic_pin,
  					spec->imux_pins, imux->num_items);
  	spec->dock_mic_idx = find_idx_in_nid_list(spec->dock_mic_pin,
  					spec->imux_pins, imux->num_items);
  	if (spec->ext_mic_idx < 0 || spec->int_mic_idx < 0) {
  		spec->auto_mic = 0;
  		return false; /* no corresponding imux */
  	}

  	snd_hda_jack_detect_enable(codec, spec->ext_mic_pin, ALC_MIC_EVENT);

  	if (spec->dock_mic_pin)

  		snd_hda_jack_detect_enable(codec, spec->dock_mic_pin,
  					   ALC_MIC_EVENT);

  
  	spec->auto_mic_valid_imux = 1;
  	spec->auto_mic = 1;
  	return true;
  }

  /*
   * Check the availability of auto-mic switch;
   * Set up if really supported
   */

  static void alc_init_auto_mic(struct hda_codec *codec)
  {
  	struct alc_spec *spec = codec->spec;
  	struct auto_pin_cfg *cfg = &spec->autocfg;

  	hda_nid_t fixed, ext, dock;

  	int i;

  	if (spec->shared_mic_hp)
  		return; /* no auto-mic for the shared I/O */

  	spec->ext_mic_idx = spec->int_mic_idx = spec->dock_mic_idx = -1;

  	fixed = ext = dock = 0;

  	for (i = 0; i < cfg->num_inputs; i++) {
  		hda_nid_t nid = cfg->inputs[i].pin;

  		unsigned int defcfg;

  		defcfg = snd_hda_codec_get_pincfg(codec, nid);

  		switch (snd_hda_get_input_pin_attr(defcfg)) {
  		case INPUT_PIN_ATTR_INT:

  			if (fixed)
  				return; /* already occupied */

  			if (cfg->inputs[i].type != AUTO_PIN_MIC)
  				return; /* invalid type */

  			fixed = nid;
  			break;

  		case INPUT_PIN_ATTR_UNUSED:
  			return; /* invalid entry */

  		case INPUT_PIN_ATTR_DOCK:
  			if (dock)
  				return; /* already occupied */
  			if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
  				return; /* invalid type */
  			dock = nid;
  			break;

  		default:

  			if (ext)
  				return; /* already occupied */

  			if (cfg->inputs[i].type != AUTO_PIN_MIC)
  				return; /* invalid type */

  			ext = nid;
  			break;

  		}
  	}

  	if (!ext && dock) {
  		ext = dock;
  		dock = 0;
  	}

  	if (!ext || !fixed)
  		return;

  	if (!is_jack_detectable(codec, ext))

  		return; /* no unsol support */

  	if (dock && !is_jack_detectable(codec, dock))
  		return; /* no unsol support */

  
  	/* check imux indices */
  	spec->ext_mic_pin = ext;
  	spec->int_mic_pin = fixed;
  	spec->dock_mic_pin = dock;
  
  	spec->auto_mic = 1;
  	if (!alc_auto_mic_check_imux(codec))
  		return;

  	snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x/0x%x
  ",
  		    ext, fixed, dock);

  	spec->unsol_event = alc_sku_unsol_event;
  }

  /* check the availabilities of auto-mute and auto-mic switches */
  static void alc_auto_check_switches(struct hda_codec *codec)
  {

  	alc_init_automute(codec);

  	alc_init_auto_mic(codec);
  }
  
  /*
   * Realtek SSID verification
   */

  /* Could be any non-zero and even value. When used as fixup, tells
   * the driver to ignore any present sku defines.
   */
  #define ALC_FIXUP_SKU_IGNORE (2)

  static int alc_auto_parse_customize_define(struct hda_codec *codec)
  {
  	unsigned int ass, tmp, i;

  	unsigned nid = 0;

  	struct alc_spec *spec = codec->spec;

  	spec->cdefine.enable_pcbeep = 1; /* assume always enabled */

  	if (spec->cdefine.fixup) {
  		ass = spec->cdefine.sku_cfg;
  		if (ass == ALC_FIXUP_SKU_IGNORE)
  			return -1;
  		goto do_sku;
  	}

  	ass = codec->subsystem_id & 0xffff;

  	if (ass != codec->bus->pci->subsystem_device && (ass & 1))

  		goto do_sku;
  
  	nid = 0x1d;
  	if (codec->vendor_id == 0x10ec0260)
  		nid = 0x17;
  	ass = snd_hda_codec_get_pincfg(codec, nid);
  
  	if (!(ass & 1)) {
  		printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x
  ",
  		       codec->chip_name, ass);
  		return -1;
  	}
  
  	/* check sum */
  	tmp = 0;
  	for (i = 1; i < 16; i++) {
  		if ((ass >> i) & 1)
  			tmp++;
  	}
  	if (((ass >> 16) & 0xf) != tmp)
  		return -1;
  
  	spec->cdefine.port_connectivity = ass >> 30;
  	spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
  	spec->cdefine.check_sum = (ass >> 16) & 0xf;
  	spec->cdefine.customization = ass >> 8;
  do_sku:
  	spec->cdefine.sku_cfg = ass;
  	spec->cdefine.external_amp = (ass & 0x38) >> 3;
  	spec->cdefine.platform_type = (ass & 0x4) >> 2;
  	spec->cdefine.swap = (ass & 0x2) >> 1;
  	spec->cdefine.override = ass & 0x1;
  
  	snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x
  ",
  		   nid, spec->cdefine.sku_cfg);
  	snd_printd("SKU: port_connectivity=0x%x
  ",
  		   spec->cdefine.port_connectivity);
  	snd_printd("SKU: enable_pcbeep=0x%x
  ", spec->cdefine.enable_pcbeep);
  	snd_printd("SKU: check_sum=0x%08x
  ", spec->cdefine.check_sum);
  	snd_printd("SKU: customization=0x%08x
  ", spec->cdefine.customization);
  	snd_printd("SKU: external_amp=0x%x
  ", spec->cdefine.external_amp);
  	snd_printd("SKU: platform_type=0x%x
  ", spec->cdefine.platform_type);
  	snd_printd("SKU: swap=0x%x
  ", spec->cdefine.swap);
  	snd_printd("SKU: override=0x%x
  ", spec->cdefine.override);
  
  	return 0;
  }

  /* return true if the given NID is found in the list */

  static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
  {

  	return find_idx_in_nid_list(nid, list, nums) >= 0;

  }

  /* check subsystem ID and set up device-specific initialization;
   * return 1 if initialized, 0 if invalid SSID
   */
  /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
   *	31 ~ 16 :	Manufacture ID
   *	15 ~ 8	:	SKU ID
   *	7  ~ 0	:	Assembly ID
   *	port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
   */
  static int alc_subsystem_id(struct hda_codec *codec,
  			    hda_nid_t porta, hda_nid_t porte,

  			    hda_nid_t portd, hda_nid_t porti)

  {
  	unsigned int ass, tmp, i;
  	unsigned nid;
  	struct alc_spec *spec = codec->spec;

  	if (spec->cdefine.fixup) {
  		ass = spec->cdefine.sku_cfg;
  		if (ass == ALC_FIXUP_SKU_IGNORE)
  			return 0;
  		goto do_sku;
  	}

  	ass = codec->subsystem_id & 0xffff;
  	if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
  		goto do_sku;
  
  	/* invalid SSID, check the special NID pin defcfg instead */
  	/*

  	 * 31~30	: port connectivity

  	 * 29~21	: reserve
  	 * 20		: PCBEEP input
  	 * 19~16	: Check sum (15:1)
  	 * 15~1		: Custom
  	 * 0		: override
  	*/
  	nid = 0x1d;
  	if (codec->vendor_id == 0x10ec0260)
  		nid = 0x17;
  	ass = snd_hda_codec_get_pincfg(codec, nid);
  	snd_printd("realtek: No valid SSID, "
  		   "checking pincfg 0x%08x for NID 0x%x
  ",

  		   ass, nid);

  	if (!(ass & 1))

  		return 0;
  	if ((ass >> 30) != 1)	/* no physical connection */
  		return 0;
  
  	/* check sum */
  	tmp = 0;
  	for (i = 1; i < 16; i++) {
  		if ((ass >> i) & 1)
  			tmp++;
  	}
  	if (((ass >> 16) & 0xf) != tmp)
  		return 0;
  do_sku:
  	snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x
  ",
  		   ass & 0xffff, codec->vendor_id);
  	/*
  	 * 0 : override
  	 * 1 :	Swap Jack
  	 * 2 : 0 --> Desktop, 1 --> Laptop
  	 * 3~5 : External Amplifier control
  	 * 7~6 : Reserved
  	*/
  	tmp = (ass & 0x38) >> 3;	/* external Amp control */
  	switch (tmp) {
  	case 1:
  		spec->init_amp = ALC_INIT_GPIO1;
  		break;
  	case 3:
  		spec->init_amp = ALC_INIT_GPIO2;
  		break;
  	case 7:
  		spec->init_amp = ALC_INIT_GPIO3;
  		break;
  	case 5:

  	default:

  		spec->init_amp = ALC_INIT_DEFAULT;

  		break;
  	}

  	/* is laptop or Desktop and enable the function "Mute internal speaker

  	 * when the external headphone out jack is plugged"
  	 */

  	if (!(ass & 0x8000))

  		return 1;

  	/*
  	 * 10~8 : Jack location
  	 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
  	 * 14~13: Resvered
  	 * 15   : 1 --> enable the function "Mute internal speaker
  	 *	        when the external headphone out jack is plugged"
  	 */

  	if (!spec->autocfg.hp_pins[0] &&
  	    !(spec->autocfg.line_out_pins[0] &&
  	      spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)) {

  		hda_nid_t nid;

  		tmp = (ass >> 11) & 0x3;	/* HP to chassis */
  		if (tmp == 0)

  			nid = porta;

  		else if (tmp == 1)

  			nid = porte;

  		else if (tmp == 2)

  			nid = portd;

  		else if (tmp == 3)
  			nid = porti;

  		else

  			return 1;

  		if (found_in_nid_list(nid, spec->autocfg.line_out_pins,
  				      spec->autocfg.line_outs))
  			return 1;

  		spec->autocfg.hp_pins[0] = nid;

  	}

  	return 1;
  }

  /* Check the validity of ALC subsystem-id
   * ports contains an array of 4 pin NIDs for port-A, E, D and I */
  static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)

  {

  	if (!alc_subsystem_id(codec, ports[0], ports[1], ports[2], ports[3])) {

  		struct alc_spec *spec = codec->spec;
  		snd_printd("realtek: "
  			   "Enable default setup for auto mode as fallback
  ");
  		spec->init_amp = ALC_INIT_DEFAULT;

  	}

  }

  /*

   * Fix-up pin default configurations and add default verbs

   */
  
  struct alc_pincfg {
  	hda_nid_t nid;
  	u32 val;
  };

  struct alc_model_fixup {
  	const int id;
  	const char *name;
  };

  struct alc_fixup {

  	int type;

  	bool chained;
  	int chain_id;

  	union {
  		unsigned int sku;
  		const struct alc_pincfg *pins;
  		const struct hda_verb *verbs;
  		void (*func)(struct hda_codec *codec,
  			     const struct alc_fixup *fix,
  			     int action);
  	} v;

  };

  enum {
  	ALC_FIXUP_INVALID,
  	ALC_FIXUP_SKU,
  	ALC_FIXUP_PINS,
  	ALC_FIXUP_VERBS,
  	ALC_FIXUP_FUNC,
  };
  
  enum {
  	ALC_FIXUP_ACT_PRE_PROBE,
  	ALC_FIXUP_ACT_PROBE,

  	ALC_FIXUP_ACT_INIT,

  };
  
  static void alc_apply_fixup(struct hda_codec *codec, int action)

  {

  	struct alc_spec *spec = codec->spec;
  	int id = spec->fixup_id;

  #ifdef CONFIG_SND_DEBUG_VERBOSE

  	const char *modelname = spec->fixup_name;

  #endif

  	int depth = 0;

  	if (!spec->fixup_list)
  		return;
  
  	while (id >= 0) {
  		const struct alc_fixup *fix = spec->fixup_list + id;
  		const struct alc_pincfg *cfg;
  
  		switch (fix->type) {
  		case ALC_FIXUP_SKU:
  			if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku)

  				break;

  			snd_printdd(KERN_INFO "hda_codec: %s: "
  				    "Apply sku override for %s
  ",
  				    codec->chip_name, modelname);
  			spec->cdefine.sku_cfg = fix->v.sku;
  			spec->cdefine.fixup = 1;
  			break;
  		case ALC_FIXUP_PINS:
  			cfg = fix->v.pins;
  			if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg)
  				break;
  			snd_printdd(KERN_INFO "hda_codec: %s: "
  				    "Apply pincfg for %s
  ",
  				    codec->chip_name, modelname);
  			for (; cfg->nid; cfg++)
  				snd_hda_codec_set_pincfg(codec, cfg->nid,
  							 cfg->val);
  			break;
  		case ALC_FIXUP_VERBS:
  			if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs)
  				break;
  			snd_printdd(KERN_INFO "hda_codec: %s: "
  				    "Apply fix-verbs for %s
  ",
  				    codec->chip_name, modelname);
  			add_verb(codec->spec, fix->v.verbs);
  			break;
  		case ALC_FIXUP_FUNC:
  			if (!fix->v.func)
  				break;
  			snd_printdd(KERN_INFO "hda_codec: %s: "
  				    "Apply fix-func for %s
  ",
  				    codec->chip_name, modelname);
  			fix->v.func(codec, fix, action);
  			break;
  		default:
  			snd_printk(KERN_ERR "hda_codec: %s: "
  				   "Invalid fixup type %d
  ",
  				   codec->chip_name, fix->type);
  			break;
  		}

  		if (!fix->chained)

  			break;
  		if (++depth > 10)
  			break;

  		id = fix->chain_id;

  	}

  }

  static void alc_pick_fixup(struct hda_codec *codec,

  			   const struct alc_model_fixup *models,
  			   const struct snd_pci_quirk *quirk,
  			   const struct alc_fixup *fixlist)

  {

  	struct alc_spec *spec = codec->spec;

  	const struct snd_pci_quirk *q;

  	int id = -1;
  	const char *name = NULL;

  	if (codec->modelname && models) {
  		while (models->name) {
  			if (!strcmp(codec->modelname, models->name)) {

  				id = models->id;
  				name = models->name;

  				break;
  			}
  			models++;
  		}

  	}
  	if (id < 0) {

  		q = snd_pci_quirk_lookup(codec->bus->pci, quirk);
  		if (q) {
  			id = q->value;

  #ifdef CONFIG_SND_DEBUG_VERBOSE

  			name = q->name;

  #endif
  		}
  	}

  	if (id < 0) {
  		for (q = quirk; q->subvendor; q++) {
  			unsigned int vendorid =
  				q->subdevice | (q->subvendor << 16);
  			if (vendorid == codec->subsystem_id) {
  				id = q->value;
  #ifdef CONFIG_SND_DEBUG_VERBOSE
  				name = q->name;
  #endif
  				break;
  			}
  		}
  	}

  
  	spec->fixup_id = id;
  	if (id >= 0) {
  		spec->fixup_list = fixlist;
  		spec->fixup_name = name;

  	}

  }

  /*
   * COEF access helper functions
   */

  static int alc_read_coef_idx(struct hda_codec *codec,
  			unsigned int coef_idx)
  {
  	unsigned int val;
  	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
  		    		coef_idx);
  	val = snd_hda_codec_read(codec, 0x20, 0,
  			 	AC_VERB_GET_PROC_COEF, 0);
  	return val;
  }

  static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
  							unsigned int coef_val)
  {
  	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
  			    coef_idx);
  	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
  			    coef_val);
  }

  /* a special bypass for COEF 0; read the cached value at the second time */
  static unsigned int alc_get_coef0(struct hda_codec *codec)
  {
  	struct alc_spec *spec = codec->spec;
  	if (!spec->coef0)
  		spec->coef0 = alc_read_coef_idx(codec, 0);
  	return spec->coef0;
  }

  /*
   * Digital I/O handling
   */

  /* set right pin controls for digital I/O */
  static void alc_auto_init_digital(struct hda_codec *codec)
  {
  	struct alc_spec *spec = codec->spec;
  	int i;

  	hda_nid_t pin, dac;

  
  	for (i = 0; i < spec->autocfg.dig_outs; i++) {
  		pin = spec->autocfg.dig_out_pins[i];

  		if (!pin)
  			continue;
  		snd_hda_codec_write(codec, pin, 0,
  				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
  		if (!i)
  			dac = spec->multiout.dig_out_nid;
  		else
  			dac = spec->slave_dig_outs[i - 1];
  		if (!dac || !(get_wcaps(codec, dac) & AC_WCAP_OUT_AMP))
  			continue;
  		snd_hda_codec_write(codec, dac, 0,
  				    AC_VERB_SET_AMP_GAIN_MUTE,
  				    AMP_OUT_UNMUTE);

  	}
  	pin = spec->autocfg.dig_in_pin;
  	if (pin)
  		snd_hda_codec_write(codec, pin, 0,
  				    AC_VERB_SET_PIN_WIDGET_CONTROL,
  				    PIN_IN);
  }
  
  /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
  static void alc_auto_parse_digital(struct hda_codec *codec)
  {
  	struct alc_spec *spec = codec->spec;

  	int i, err, nums;

  	hda_nid_t dig_nid;
  
  	/* support multiple SPDIFs; the secondary is set up as a slave */

  	nums = 0;

  	for (i = 0; i < spec->autocfg.dig_outs; i++) {

  		hda_nid_t conn[4];

  		err = snd_hda_get_connections(codec,
  					      spec->autocfg.dig_out_pins[i],

  					      conn, ARRAY_SIZE(conn));

  		if (err <= 0)

  			continue;

  		dig_nid = conn[0]; /* assume the first element is audio-out */

  		if (!nums) {

  			spec->multiout.dig_out_nid = dig_nid;
  			spec->dig_out_type = spec->autocfg.dig_out_type[0];
  		} else {
  			spec->multiout.slave_dig_outs = spec->slave_dig_outs;

  			if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1)

  				break;

  			spec->slave_dig_outs[nums - 1] = dig_nid;

  		}

  		nums++;

  	}
  
  	if (spec->autocfg.dig_in_pin) {

  		dig_nid = codec->start_nid;
  		for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
  			unsigned int wcaps = get_wcaps(codec, dig_nid);
  			if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
  				continue;
  			if (!(wcaps & AC_WCAP_DIGITAL))
  				continue;
  			if (!(wcaps & AC_WCAP_CONN_LIST))
  				continue;
  			err = get_connection_index(codec, dig_nid,
  						   spec->autocfg.dig_in_pin);
  			if (err >= 0) {
  				spec->dig_in_nid = dig_nid;
  				break;
  			}
  		}

  	}
  }

  /*

   * capture mixer elements

   */

  static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
  			    struct snd_ctl_elem_info *uinfo)
  {
  	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  	struct alc_spec *spec = codec->spec;

  	unsigned long val;

  	int err;

  	mutex_lock(&codec->control_mutex);

  	if (spec->vol_in_capsrc)
  		val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
  	else
  		val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
  	kcontrol->private_value = val;

  	err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);

  	mutex_unlock(&codec->control_mutex);

  	return err;
  }
  
  static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
  			   unsigned int size, unsigned int __user *tlv)
  {
  	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  	struct alc_spec *spec = codec->spec;

  	unsigned long val;

  	int err;

  	mutex_lock(&codec->control_mutex);

  	if (spec->vol_in_capsrc)
  		val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
  	else
  		val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
  	kcontrol->private_value = val;

  	err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);

  	mutex_unlock(&codec->control_mutex);

  	return err;
  }
  
  typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
  			     struct snd_ctl_elem_value *ucontrol);
  
  static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
  				 struct snd_ctl_elem_value *ucontrol,

  				 getput_call_t func, bool check_adc_switch)

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

  	int i, err = 0;

  	mutex_lock(&codec->control_mutex);

  	if (check_adc_switch && spec->dyn_adc_switch) {

  		for (i = 0; i < spec->num_adc_nids; i++) {
  			kcontrol->private_value =
  				HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
  						    3, 0, HDA_INPUT);
  			err = func(kcontrol, ucontrol);
  			if (err < 0)
  				goto error;
  		}
  	} else {
  		i = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);

  		if (spec->vol_in_capsrc)
  			kcontrol->private_value =
  				HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[i],
  						    3, 0, HDA_OUTPUT);
  		else
  			kcontrol->private_value =

  				HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
  						    3, 0, HDA_INPUT);

  		err = func(kcontrol, ucontrol);
  	}
   error:

  	mutex_unlock(&codec->control_mutex);

  	return err;
  }
  
  static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
  			   struct snd_ctl_elem_value *ucontrol)
  {
  	return alc_cap_getput_caller(kcontrol, ucontrol,

  				     snd_hda_mixer_amp_volume_get, false);

  }
  
  static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
  			   struct snd_ctl_elem_value *ucontrol)
  {
  	return alc_cap_getput_caller(kcontrol, ucontrol,

  				     snd_hda_mixer_amp_volume_put, true);

  }
  
  /* capture mixer elements */
  #define alc_cap_sw_info		snd_ctl_boolean_stereo_info
  
  static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
  			  struct snd_ctl_elem_value *ucontrol)
  {
  	return alc_cap_getput_caller(kcontrol, ucontrol,

  				     snd_hda_mixer_amp_switch_get, false);

  }
  
  static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
  			  struct snd_ctl_elem_value *ucontrol)
  {
  	return alc_cap_getput_caller(kcontrol, ucontrol,

  				     snd_hda_mixer_amp_switch_put, true);

  }

  #define _DEFINE_CAPMIX(num) \

  	{ \
  		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
  		.name = "Capture Switch", \
  		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
  		.count = num, \
  		.info = alc_cap_sw_info, \
  		.get = alc_cap_sw_get, \
  		.put = alc_cap_sw_put, \
  	}, \
  	{ \
  		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
  		.name = "Capture Volume", \
  		.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
  			   SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
  			   SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
  		.count = num, \
  		.info = alc_cap_vol_info, \
  		.get = alc_cap_vol_get, \
  		.put = alc_cap_vol_put, \
  		.tlv = { .c = alc_cap_vol_tlv }, \

  	}
  
  #define _DEFINE_CAPSRC(num) \

  	{ \
  		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
  		/* .name = "Capture Source", */ \
  		.name = "Input Source", \
  		.count = num, \
  		.info = alc_mux_enum_info, \
  		.get = alc_mux_enum_get, \
  		.put = alc_mux_enum_put, \

  	}
  
  #define DEFINE_CAPMIX(num) \

  static const struct snd_kcontrol_new alc_capture_mixer ## num[] = { \

  	_DEFINE_CAPMIX(num),				      \
  	_DEFINE_CAPSRC(num),				      \
  	{ } /* end */					      \
  }
  
  #define DEFINE_CAPMIX_NOSRC(num) \

  static const struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \

  	_DEFINE_CAPMIX(num),					    \
  	{ } /* end */						    \

  }
  
  /* up to three ADCs */
  DEFINE_CAPMIX(1);
  DEFINE_CAPMIX(2);
  DEFINE_CAPMIX(3);

  DEFINE_CAPMIX_NOSRC(1);
  DEFINE_CAPMIX_NOSRC(2);
  DEFINE_CAPMIX_NOSRC(3);

  
  /*

   * virtual master controls

   */

  /*

   * slave controls for virtual master

   */

  static const char * const alc_slave_vols[] = {
  	"Front Playback Volume",
  	"Surround Playback Volume",
  	"Center Playback Volume",
  	"LFE Playback Volume",
  	"Side Playback Volume",
  	"Headphone Playback Volume",
  	"Speaker Playback Volume",
  	"Mono Playback Volume",
  	"Line-Out Playback Volume",

  	"PCM Playback Volume",

  	NULL,

  };

  static const char * const alc_slave_sws[] = {
  	"Front Playback Switch",
  	"Surround Playback Switch",
  	"Center Playback Switch",
  	"LFE Playback Switch",
  	"Side Playback Switch",
  	"Headphone Playback Switch",
  	"Speaker Playback Switch",
  	"Mono Playback Switch",
  	"IEC958 Playback Switch",
  	"Line-Out Playback Switch",

  	"PCM Playback Switch",

  	NULL,

  };

  /*

   * build control elements

   */

  #define NID_MAPPING		(-1)

  #define SUBDEV_SPEAKER_		(0 << 6)
  #define SUBDEV_HP_		(1 << 6)
  #define SUBDEV_LINE_		(2 << 6)
  #define SUBDEV_SPEAKER(x)	(SUBDEV_SPEAKER_ | ((x) & 0x3f))
  #define SUBDEV_HP(x)		(SUBDEV_HP_ | ((x) & 0x3f))
  #define SUBDEV_LINE(x)		(SUBDEV_LINE_ | ((x) & 0x3f))

  static void alc_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 alc_beep_mixer[] = {
  	HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
  	HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),

  	{ } /* end */
  };

  #endif

  static int alc_build_controls(struct hda_codec *codec)
  {
  	struct alc_spec *spec = codec->spec;
  	struct snd_kcontrol *kctl = NULL;
  	const struct snd_kcontrol_new *knew;
  	int i, j, err;
  	unsigned int u;
  	hda_nid_t nid;

  
  	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->cap_mixer) {
  		err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
  		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;

  		if (!spec->no_analog) {
  			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;
  	}

  #ifdef CONFIG_SND_HDA_INPUT_BEEP

  	/* create beep controls if needed */
  	if (spec->beep_amp) {

  		const struct snd_kcontrol_new *knew;

  		for (knew = alc_beep_mixer; 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);