sound/pci/hda/alc_quirks.c - kernel/mindspeed - Git at Google

 /*
  * Common codes for Realtek codec quirks
  * included by patch_realtek.c
  */

 /*
  * configuration template - to be copied to the spec instance
  */
 struct alc_config_preset {
 	const struct snd_kcontrol_new *mixers[5]; /* should be identical size
 					     * with spec
 					     */
 	const struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 	const struct hda_verb *init_verbs[5];
 	unsigned int num_dacs;
 	const hda_nid_t *dac_nids;
 	hda_nid_t dig_out_nid;		/* optional */
 	hda_nid_t hp_nid;		/* optional */
 	const hda_nid_t *slave_dig_outs;
 	unsigned int num_adc_nids;
 	const hda_nid_t *adc_nids;
 	const hda_nid_t *capsrc_nids;
 	hda_nid_t dig_in_nid;
 	unsigned int num_channel_mode;
 	const struct hda_channel_mode *channel_mode;
 	int need_dac_fix;
 	int const_channel_count;
 	unsigned int num_mux_defs;
 	const struct hda_input_mux *input_mux;
 	void (*unsol_event)(struct hda_codec *, unsigned int);
 	void (*setup)(struct hda_codec *);
 	void (*init_hook)(struct hda_codec *);
 #ifdef CONFIG_SND_HDA_POWER_SAVE
 	const struct hda_amp_list *loopbacks;
 	void (*power_hook)(struct hda_codec *codec);
 #endif
 };

 /*
  * channel mode setting
  */
 static int alc_ch_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;
 	return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 				    spec->num_channel_mode);
 }

 static int alc_ch_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;
 	return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 				   spec->num_channel_mode,
 				   spec->ext_channel_count);
 }

 static int alc_ch_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;
 	int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 				      spec->num_channel_mode,
 				      &spec->ext_channel_count);
 	if (err >= 0 && !spec->const_channel_count) {
 		spec->multiout.max_channels = spec->ext_channel_count;
 		if (spec->need_dac_fix)
 			spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 	}
 	return err;
 }

 /*
  * Control the mode of pin widget settings via the mixer.  "pc" is used
  * instead of "%" to avoid consequences of accidentally treating the % as
  * being part of a format specifier.  Maximum allowed length of a value is
  * 63 characters plus NULL terminator.
  *
  * Note: some retasking pin complexes seem to ignore requests for input
  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
  * are requested.  Therefore order this list so that this behaviour will not
  * cause problems when mixer clients move through the enum sequentially.
  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
  * March 2006.
  */
 static const char * const alc_pin_mode_names[] = {
 	"Mic 50pc bias", "Mic 80pc bias",
 	"Line in", "Line out", "Headphone out",
 };
 static const unsigned char alc_pin_mode_values[] = {
 	PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 };
 /* The control can present all 5 options, or it can limit the options based
  * in the pin being assumed to be exclusively an input or an output pin.  In
  * addition, "input" pins may or may not process the mic bias option
  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
  * accept requests for bias as of chip versions up to March 2006) and/or
  * wiring in the computer.
  */
 #define ALC_PIN_DIR_IN              0x00
 #define ALC_PIN_DIR_OUT             0x01
 #define ALC_PIN_DIR_INOUT           0x02
 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04

 /* Info about the pin modes supported by the different pin direction modes.
  * For each direction the minimum and maximum values are given.
  */
 static const signed char alc_pin_mode_dir_info[5][2] = {
 	{ 0, 2 },    /* ALC_PIN_DIR_IN */
 	{ 3, 4 },    /* ALC_PIN_DIR_OUT */
 	{ 0, 4 },    /* ALC_PIN_DIR_INOUT */
 	{ 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 	{ 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 };
 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 #define alc_pin_mode_n_items(_dir) \
 	(alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)

 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 			     struct snd_ctl_elem_info *uinfo)
 {
 	unsigned int item_num = uinfo->value.enumerated.item;
 	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;

 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 	uinfo->count = 1;
 	uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);

 	if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 		item_num = alc_pin_mode_min(dir);
 	strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 	return 0;
 }

 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 			    struct snd_ctl_elem_value *ucontrol)
 {
 	unsigned int i;
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	hda_nid_t nid = kcontrol->private_value & 0xffff;
 	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 	long *valp = ucontrol->value.integer.value;
 	unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 						 AC_VERB_GET_PIN_WIDGET_CONTROL,
 						 0x00);

 	/* Find enumerated value for current pinctl setting */
 	i = alc_pin_mode_min(dir);
 	while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
 		i++;
 	*valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 	return 0;
 }

 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 			    struct snd_ctl_elem_value *ucontrol)
 {
 	signed int change;
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	hda_nid_t nid = kcontrol->private_value & 0xffff;
 	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 	long val = *ucontrol->value.integer.value;
 	unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 						 AC_VERB_GET_PIN_WIDGET_CONTROL,
 						 0x00);

 	if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 		val = alc_pin_mode_min(dir);

 	change = pinctl != alc_pin_mode_values[val];
 	if (change) {
 		/* Set pin mode to that requested */
 		snd_hda_codec_write_cache(codec, nid, 0,
 					  AC_VERB_SET_PIN_WIDGET_CONTROL,
 					  alc_pin_mode_values[val]);

 		/* Also enable the retasking pin's input/output as required
 		 * for the requested pin mode.  Enum values of 2 or less are
 		 * input modes.
 		 *
 		 * Dynamically switching the input/output buffers probably
 		 * reduces noise slightly (particularly on input) so we'll
 		 * do it.  However, having both input and output buffers
 		 * enabled simultaneously doesn't seem to be problematic if
 		 * this turns out to be necessary in the future.
 		 */
 		if (val <= 2) {
 			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 						 HDA_AMP_MUTE, HDA_AMP_MUTE);
 			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 						 HDA_AMP_MUTE, 0);
 		} else {
 			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 						 HDA_AMP_MUTE, HDA_AMP_MUTE);
 			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 						 HDA_AMP_MUTE, 0);
 		}
 	}
 	return change;
 }

 #define ALC_PIN_MODE(xname, nid, dir) \
 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 	  .info = alc_pin_mode_info, \
 	  .get = alc_pin_mode_get, \
 	  .put = alc_pin_mode_put, \
 	  .private_value = nid | (dir<<16) }

 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
  * together using a mask with more than one bit set.  This control is
  * currently used only by the ALC260 test model.  At this stage they are not
  * needed for any "production" models.
  */
 #ifdef CONFIG_SND_DEBUG
 #define alc_gpio_data_info	snd_ctl_boolean_mono_info

 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 			     struct snd_ctl_elem_value *ucontrol)
 {
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	hda_nid_t nid = kcontrol->private_value & 0xffff;
 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 	long *valp = ucontrol->value.integer.value;
 	unsigned int val = snd_hda_codec_read(codec, nid, 0,
 					      AC_VERB_GET_GPIO_DATA, 0x00);

 	*valp = (val & mask) != 0;
 	return 0;
 }
 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 			     struct snd_ctl_elem_value *ucontrol)
 {
 	signed int change;
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	hda_nid_t nid = kcontrol->private_value & 0xffff;
 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 	long val = *ucontrol->value.integer.value;
 	unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 						    AC_VERB_GET_GPIO_DATA,
 						    0x00);

 	/* Set/unset the masked GPIO bit(s) as needed */
 	change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 	if (val == 0)
 		gpio_data &= ~mask;
 	else
 		gpio_data |= mask;
 	snd_hda_codec_write_cache(codec, nid, 0,
 				  AC_VERB_SET_GPIO_DATA, gpio_data);

 	return change;
 }
 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 	  .info = alc_gpio_data_info, \
 	  .get = alc_gpio_data_get, \
 	  .put = alc_gpio_data_put, \
 	  .private_value = nid | (mask<<16) }
 #endif   /* CONFIG_SND_DEBUG */

 /* A switch control to allow the enabling of the digital IO pins on the
  * ALC260.  This is incredibly simplistic; the intention of this control is
  * to provide something in the test model allowing digital outputs to be
  * identified if present.  If models are found which can utilise these
  * outputs a more complete mixer control can be devised for those models if
  * necessary.
  */
 #ifdef CONFIG_SND_DEBUG
 #define alc_spdif_ctrl_info	snd_ctl_boolean_mono_info

 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 			      struct snd_ctl_elem_value *ucontrol)
 {
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	hda_nid_t nid = kcontrol->private_value & 0xffff;
 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 	long *valp = ucontrol->value.integer.value;
 	unsigned int val = snd_hda_codec_read(codec, nid, 0,
 					      AC_VERB_GET_DIGI_CONVERT_1, 0x00);

 	*valp = (val & mask) != 0;
 	return 0;
 }
 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 			      struct snd_ctl_elem_value *ucontrol)
 {
 	signed int change;
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	hda_nid_t nid = kcontrol->private_value & 0xffff;
 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 	long val = *ucontrol->value.integer.value;
 	unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 						    AC_VERB_GET_DIGI_CONVERT_1,
 						    0x00);

 	/* Set/unset the masked control bit(s) as needed */
 	change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 	if (val==0)
 		ctrl_data &= ~mask;
 	else
 		ctrl_data |= mask;
 	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 				  ctrl_data);

 	return change;
 }
 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 	  .info = alc_spdif_ctrl_info, \
 	  .get = alc_spdif_ctrl_get, \
 	  .put = alc_spdif_ctrl_put, \
 	  .private_value = nid | (mask<<16) }
 #endif   /* CONFIG_SND_DEBUG */

 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
  * Again, this is only used in the ALC26x test models to help identify when
  * the EAPD line must be asserted for features to work.
  */
 #ifdef CONFIG_SND_DEBUG
 #define alc_eapd_ctrl_info	snd_ctl_boolean_mono_info

 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 			      struct snd_ctl_elem_value *ucontrol)
 {
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	hda_nid_t nid = kcontrol->private_value & 0xffff;
 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 	long *valp = ucontrol->value.integer.value;
 	unsigned int val = snd_hda_codec_read(codec, nid, 0,
 					      AC_VERB_GET_EAPD_BTLENABLE, 0x00);

 	*valp = (val & mask) != 0;
 	return 0;
 }

 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 			      struct snd_ctl_elem_value *ucontrol)
 {
 	int change;
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	hda_nid_t nid = kcontrol->private_value & 0xffff;
 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 	long val = *ucontrol->value.integer.value;
 	unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 						    AC_VERB_GET_EAPD_BTLENABLE,
 						    0x00);

 	/* Set/unset the masked control bit(s) as needed */
 	change = (!val ? 0 : mask) != (ctrl_data & mask);
 	if (!val)
 		ctrl_data &= ~mask;
 	else
 		ctrl_data |= mask;
 	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 				  ctrl_data);

 	return change;
 }

 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 	  .info = alc_eapd_ctrl_info, \
 	  .get = alc_eapd_ctrl_get, \
 	  .put = alc_eapd_ctrl_put, \
 	  .private_value = nid | (mask<<16) }
 #endif   /* CONFIG_SND_DEBUG */

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

 	if (!cfg->line_outs) {
 		while (cfg->line_outs < AUTO_CFG_MAX_OUTS &&
 		       cfg->line_out_pins[cfg->line_outs])
 			cfg->line_outs++;
 	}
 	if (!cfg->speaker_outs) {
 		while (cfg->speaker_outs < AUTO_CFG_MAX_OUTS &&
 		       cfg->speaker_pins[cfg->speaker_outs])
 			cfg->speaker_outs++;
 	}
 	if (!cfg->hp_outs) {
 		while (cfg->hp_outs < AUTO_CFG_MAX_OUTS &&
 		       cfg->hp_pins[cfg->hp_outs])
 			cfg->hp_outs++;
 	}
 }

 /*
  * set up from the preset table
  */
 static void setup_preset(struct hda_codec *codec,
 			 const struct alc_config_preset *preset)
 {
 	struct alc_spec *spec = codec->spec;
 	int i;

 	for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 		add_mixer(spec, preset->mixers[i]);
 	spec->cap_mixer = preset->cap_mixer;
 	for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 	     i++)
 		add_verb(spec, preset->init_verbs[i]);

 	spec->channel_mode = preset->channel_mode;
 	spec->num_channel_mode = preset->num_channel_mode;
 	spec->need_dac_fix = preset->need_dac_fix;
 	spec->const_channel_count = preset->const_channel_count;

 	if (preset->const_channel_count)
 		spec->multiout.max_channels = preset->const_channel_count;
 	else
 		spec->multiout.max_channels = spec->channel_mode[0].channels;
 	spec->ext_channel_count = spec->channel_mode[0].channels;

 	spec->multiout.num_dacs = preset->num_dacs;
 	spec->multiout.dac_nids = preset->dac_nids;
 	spec->multiout.dig_out_nid = preset->dig_out_nid;
 	spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 	spec->multiout.hp_nid = preset->hp_nid;

 	spec->num_mux_defs = preset->num_mux_defs;
 	if (!spec->num_mux_defs)
 		spec->num_mux_defs = 1;
 	spec->input_mux = preset->input_mux;

 	spec->num_adc_nids = preset->num_adc_nids;
 	spec->adc_nids = preset->adc_nids;
 	spec->capsrc_nids = preset->capsrc_nids;
 	spec->dig_in_nid = preset->dig_in_nid;

 	spec->unsol_event = preset->unsol_event;
 	spec->init_hook = preset->init_hook;
 #ifdef CONFIG_SND_HDA_POWER_SAVE
 	spec->power_hook = preset->power_hook;
 	spec->loopback.amplist = preset->loopbacks;
 #endif

 	if (preset->setup)
 		preset->setup(codec);

 	alc_fixup_autocfg_pin_nums(codec);
 }

 static void alc_simple_setup_automute(struct alc_spec *spec, int mode)
 {
 	int lo_pin = spec->autocfg.line_out_pins[0];

 	if (lo_pin == spec->autocfg.speaker_pins[0] ||
 		lo_pin == spec->autocfg.hp_pins[0])
 		lo_pin = 0;
 	spec->automute_mode = mode;
 	spec->detect_hp = !!spec->autocfg.hp_pins[0];
 	spec->detect_lo = !!lo_pin;
 	spec->automute_lo = spec->automute_lo_possible = !!lo_pin;
 	spec->automute_speaker = spec->automute_speaker_possible = !!spec->autocfg.speaker_pins[0];
 }

 /* auto-toggle front mic */
 static void alc88x_simple_mic_automute(struct hda_codec *codec)
 {
  	unsigned int present;
 	unsigned char bits;

 	present = snd_hda_jack_detect(codec, 0x18);
 	bits = present ? HDA_AMP_MUTE : 0;
 	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
 }
	/*
	* Common codes for Realtek codec quirks
	* included by patch_realtek.c
	*/

	/*
	* configuration template - to be copied to the spec instance
	*/
	struct alc_config_preset {
	const struct snd_kcontrol_new mixers[5]; / should be identical size
	* with spec
	*/
	const struct snd_kcontrol_new cap_mixer; / capture mixer */
	const struct hda_verb *init_verbs[5];
	unsigned int num_dacs;
	const hda_nid_t *dac_nids;
	hda_nid_t dig_out_nid; /* optional */
	hda_nid_t hp_nid; /* optional */
	const hda_nid_t *slave_dig_outs;
	unsigned int num_adc_nids;
	const hda_nid_t *adc_nids;
	const hda_nid_t *capsrc_nids;
	hda_nid_t dig_in_nid;
	unsigned int num_channel_mode;
	const struct hda_channel_mode *channel_mode;
	int need_dac_fix;
	int const_channel_count;
	unsigned int num_mux_defs;
	const struct hda_input_mux *input_mux;
	void (unsol_event)(struct hda_codec , unsigned int);
	void (setup)(struct hda_codec );
	void (init_hook)(struct hda_codec );
	#ifdef CONFIG_SND_HDA_POWER_SAVE
	const struct hda_amp_list *loopbacks;
	void (power_hook)(struct hda_codec codec);
	#endif
	};

	/*
	* channel mode setting
	*/
	static int alc_ch_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;
	return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
	spec->num_channel_mode);
	}

	static int alc_ch_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;
	return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
	spec->num_channel_mode,
	spec->ext_channel_count);
	}

	static int alc_ch_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;
	int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
	spec->num_channel_mode,
	&spec->ext_channel_count);
	if (err >= 0 && !spec->const_channel_count) {
	spec->multiout.max_channels = spec->ext_channel_count;
	if (spec->need_dac_fix)
	spec->multiout.num_dacs = spec->multiout.max_channels / 2;
	}
	return err;
	}

	/*
	* Control the mode of pin widget settings via the mixer. "pc" is used
	* instead of "%" to avoid consequences of accidentally treating the % as
	* being part of a format specifier. Maximum allowed length of a value is
	* 63 characters plus NULL terminator.
	*
	* Note: some retasking pin complexes seem to ignore requests for input
	* states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
	* are requested. Therefore order this list so that this behaviour will not
	* cause problems when mixer clients move through the enum sequentially.
	* NIDs 0x0f and 0x10 have been observed to have this behaviour as of
	* March 2006.
	*/
	static const char * const alc_pin_mode_names[] = {
	"Mic 50pc bias", "Mic 80pc bias",
	"Line in", "Line out", "Headphone out",
	};
	static const unsigned char alc_pin_mode_values[] = {
	PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
	};
	/* The control can present all 5 options, or it can limit the options based
	* in the pin being assumed to be exclusively an input or an output pin. In
	* addition, "input" pins may or may not process the mic bias option
	* depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
	* accept requests for bias as of chip versions up to March 2006) and/or
	* wiring in the computer.
	*/
	#define ALC_PIN_DIR_IN 0x00
	#define ALC_PIN_DIR_OUT 0x01
	#define ALC_PIN_DIR_INOUT 0x02
	#define ALC_PIN_DIR_IN_NOMICBIAS 0x03
	#define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04

	/* Info about the pin modes supported by the different pin direction modes.
	* For each direction the minimum and maximum values are given.
	*/
	static const signed char alc_pin_mode_dir_info[5][2] = {
	{ 0, 2 }, /* ALC_PIN_DIR_IN */
	{ 3, 4 }, /* ALC_PIN_DIR_OUT */
	{ 0, 4 }, /* ALC_PIN_DIR_INOUT */
	{ 2, 2 }, /* ALC_PIN_DIR_IN_NOMICBIAS */
	{ 2, 4 }, /* ALC_PIN_DIR_INOUT_NOMICBIAS */
	};
	#define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
	#define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
	#define alc_pin_mode_n_items(_dir) \
	(alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)

	static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_info *uinfo)
	{
	unsigned int item_num = uinfo->value.enumerated.item;
	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;

	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
	uinfo->count = 1;
	uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);

	if (item_num<alc_pin_mode_min(dir) \|\| item_num>alc_pin_mode_max(dir))
	item_num = alc_pin_mode_min(dir);
	strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
	return 0;
	}

	static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
	{
	unsigned int i;
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	hda_nid_t nid = kcontrol->private_value & 0xffff;
	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
	long *valp = ucontrol->value.integer.value;
	unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
	AC_VERB_GET_PIN_WIDGET_CONTROL,
	0x00);

	/* Find enumerated value for current pinctl setting */
	i = alc_pin_mode_min(dir);
	while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
	i++;
	*valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
	return 0;
	}

	static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
	{
	signed int change;
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	hda_nid_t nid = kcontrol->private_value & 0xffff;
	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
	long val = *ucontrol->value.integer.value;
	unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
	AC_VERB_GET_PIN_WIDGET_CONTROL,
	0x00);

	if (val < alc_pin_mode_min(dir) \|\| val > alc_pin_mode_max(dir))
	val = alc_pin_mode_min(dir);

	change = pinctl != alc_pin_mode_values[val];
	if (change) {
	/* Set pin mode to that requested */
	snd_hda_codec_write_cache(codec, nid, 0,
	AC_VERB_SET_PIN_WIDGET_CONTROL,
	alc_pin_mode_values[val]);

	/* Also enable the retasking pin's input/output as required
	* for the requested pin mode. Enum values of 2 or less are
	* input modes.
	*
	* Dynamically switching the input/output buffers probably
	* reduces noise slightly (particularly on input) so we'll
	* do it. However, having both input and output buffers
	* enabled simultaneously doesn't seem to be problematic if
	* this turns out to be necessary in the future.
	*/
	if (val <= 2) {
	snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
	HDA_AMP_MUTE, HDA_AMP_MUTE);
	snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
	HDA_AMP_MUTE, 0);
	} else {
	snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
	HDA_AMP_MUTE, HDA_AMP_MUTE);
	snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
	HDA_AMP_MUTE, 0);
	}
	}
	return change;
	}

	#define ALC_PIN_MODE(xname, nid, dir) \
	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
	.subdevice = HDA_SUBDEV_NID_FLAG \| nid, \
	.info = alc_pin_mode_info, \
	.get = alc_pin_mode_get, \
	.put = alc_pin_mode_put, \
	.private_value = nid \| (dir<<16) }

	/* A switch control for ALC260 GPIO pins. Multiple GPIOs can be ganged
	* together using a mask with more than one bit set. This control is
	* currently used only by the ALC260 test model. At this stage they are not
	* needed for any "production" models.
	*/
	#ifdef CONFIG_SND_DEBUG
	#define alc_gpio_data_info snd_ctl_boolean_mono_info

	static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
	{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	hda_nid_t nid = kcontrol->private_value & 0xffff;
	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
	long *valp = ucontrol->value.integer.value;
	unsigned int val = snd_hda_codec_read(codec, nid, 0,
	AC_VERB_GET_GPIO_DATA, 0x00);

	*valp = (val & mask) != 0;
	return 0;
	}
	static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
	{
	signed int change;
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	hda_nid_t nid = kcontrol->private_value & 0xffff;
	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
	long val = *ucontrol->value.integer.value;
	unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
	AC_VERB_GET_GPIO_DATA,
	0x00);

	/* Set/unset the masked GPIO bit(s) as needed */
	change = (val == 0 ? 0 : mask) != (gpio_data & mask);
	if (val == 0)
	gpio_data &= ~mask;
	else
	gpio_data \|= mask;
	snd_hda_codec_write_cache(codec, nid, 0,
	AC_VERB_SET_GPIO_DATA, gpio_data);

	return change;
	}
	#define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
	.subdevice = HDA_SUBDEV_NID_FLAG \| nid, \
	.info = alc_gpio_data_info, \
	.get = alc_gpio_data_get, \
	.put = alc_gpio_data_put, \
	.private_value = nid \| (mask<<16) }
	#endif /* CONFIG_SND_DEBUG */

	/* A switch control to allow the enabling of the digital IO pins on the
	* ALC260. This is incredibly simplistic; the intention of this control is
	* to provide something in the test model allowing digital outputs to be
	* identified if present. If models are found which can utilise these
	* outputs a more complete mixer control can be devised for those models if
	* necessary.
	*/
	#ifdef CONFIG_SND_DEBUG
	#define alc_spdif_ctrl_info snd_ctl_boolean_mono_info

	static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
	{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	hda_nid_t nid = kcontrol->private_value & 0xffff;
	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
	long *valp = ucontrol->value.integer.value;
	unsigned int val = snd_hda_codec_read(codec, nid, 0,
	AC_VERB_GET_DIGI_CONVERT_1, 0x00);

	*valp = (val & mask) != 0;
	return 0;
	}
	static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
	{
	signed int change;
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	hda_nid_t nid = kcontrol->private_value & 0xffff;
	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
	long val = *ucontrol->value.integer.value;
	unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
	AC_VERB_GET_DIGI_CONVERT_1,
	0x00);

	/* Set/unset the masked control bit(s) as needed */
	change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
	if (val==0)
	ctrl_data &= ~mask;
	else
	ctrl_data \|= mask;
	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
	ctrl_data);

	return change;
	}
	#define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
	.subdevice = HDA_SUBDEV_NID_FLAG \| nid, \
	.info = alc_spdif_ctrl_info, \
	.get = alc_spdif_ctrl_get, \
	.put = alc_spdif_ctrl_put, \
	.private_value = nid \| (mask<<16) }
	#endif /* CONFIG_SND_DEBUG */

	/* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
	* Again, this is only used in the ALC26x test models to help identify when
	* the EAPD line must be asserted for features to work.
	*/
	#ifdef CONFIG_SND_DEBUG
	#define alc_eapd_ctrl_info snd_ctl_boolean_mono_info

	static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
	{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	hda_nid_t nid = kcontrol->private_value & 0xffff;
	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
	long *valp = ucontrol->value.integer.value;
	unsigned int val = snd_hda_codec_read(codec, nid, 0,
	AC_VERB_GET_EAPD_BTLENABLE, 0x00);

	*valp = (val & mask) != 0;
	return 0;
	}

	static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
	{
	int change;
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	hda_nid_t nid = kcontrol->private_value & 0xffff;
	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
	long val = *ucontrol->value.integer.value;
	unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
	AC_VERB_GET_EAPD_BTLENABLE,
	0x00);

	/* Set/unset the masked control bit(s) as needed */
	change = (!val ? 0 : mask) != (ctrl_data & mask);
	if (!val)
	ctrl_data &= ~mask;
	else
	ctrl_data \|= mask;
	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
	ctrl_data);

	return change;
	}

	#define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
	.subdevice = HDA_SUBDEV_NID_FLAG \| nid, \
	.info = alc_eapd_ctrl_info, \
	.get = alc_eapd_ctrl_get, \
	.put = alc_eapd_ctrl_put, \
	.private_value = nid \| (mask<<16) }
	#endif /* CONFIG_SND_DEBUG */

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

	if (!cfg->line_outs) {
	while (cfg->line_outs < AUTO_CFG_MAX_OUTS &&
	cfg->line_out_pins[cfg->line_outs])
	cfg->line_outs++;
	}
	if (!cfg->speaker_outs) {
	while (cfg->speaker_outs < AUTO_CFG_MAX_OUTS &&
	cfg->speaker_pins[cfg->speaker_outs])
	cfg->speaker_outs++;
	}
	if (!cfg->hp_outs) {
	while (cfg->hp_outs < AUTO_CFG_MAX_OUTS &&
	cfg->hp_pins[cfg->hp_outs])
	cfg->hp_outs++;
	}
	}

	/*
	* set up from the preset table
	*/
	static void setup_preset(struct hda_codec *codec,
	const struct alc_config_preset *preset)
	{
	struct alc_spec *spec = codec->spec;
	int i;

	for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
	add_mixer(spec, preset->mixers[i]);
	spec->cap_mixer = preset->cap_mixer;
	for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
	i++)
	add_verb(spec, preset->init_verbs[i]);

	spec->channel_mode = preset->channel_mode;
	spec->num_channel_mode = preset->num_channel_mode;
	spec->need_dac_fix = preset->need_dac_fix;
	spec->const_channel_count = preset->const_channel_count;

	if (preset->const_channel_count)
	spec->multiout.max_channels = preset->const_channel_count;
	else
	spec->multiout.max_channels = spec->channel_mode[0].channels;
	spec->ext_channel_count = spec->channel_mode[0].channels;

	spec->multiout.num_dacs = preset->num_dacs;
	spec->multiout.dac_nids = preset->dac_nids;
	spec->multiout.dig_out_nid = preset->dig_out_nid;
	spec->multiout.slave_dig_outs = preset->slave_dig_outs;
	spec->multiout.hp_nid = preset->hp_nid;

	spec->num_mux_defs = preset->num_mux_defs;
	if (!spec->num_mux_defs)
	spec->num_mux_defs = 1;
	spec->input_mux = preset->input_mux;

	spec->num_adc_nids = preset->num_adc_nids;
	spec->adc_nids = preset->adc_nids;
	spec->capsrc_nids = preset->capsrc_nids;
	spec->dig_in_nid = preset->dig_in_nid;

	spec->unsol_event = preset->unsol_event;
	spec->init_hook = preset->init_hook;
	#ifdef CONFIG_SND_HDA_POWER_SAVE
	spec->power_hook = preset->power_hook;
	spec->loopback.amplist = preset->loopbacks;
	#endif

	if (preset->setup)
	preset->setup(codec);

	alc_fixup_autocfg_pin_nums(codec);
	}

	static void alc_simple_setup_automute(struct alc_spec *spec, int mode)
	{
	int lo_pin = spec->autocfg.line_out_pins[0];

	if (lo_pin == spec->autocfg.speaker_pins[0] \|\|
	lo_pin == spec->autocfg.hp_pins[0])
	lo_pin = 0;
	spec->automute_mode = mode;
	spec->detect_hp = !!spec->autocfg.hp_pins[0];
	spec->detect_lo = !!lo_pin;
	spec->automute_lo = spec->automute_lo_possible = !!lo_pin;
	spec->automute_speaker = spec->automute_speaker_possible = !!spec->autocfg.speaker_pins[0];
	}

	/* auto-toggle front mic */
	static void alc88x_simple_mic_automute(struct hda_codec *codec)
	{
	unsigned int present;
	unsigned char bits;

	present = snd_hda_jack_detect(codec, 0x18);
	bits = present ? HDA_AMP_MUTE : 0;
	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
	}