[linux-2.6-block.git] / sound / pci / oxygen / xonar_dg_mixer.c

/*
 * Mixer controls for the Xonar DG/DGX
 *
 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
 * Copyright (c) Roman Volkov <v1ron@mail.ru>
 *
 *  This driver is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License, version 2.
 *
 *  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 driver; if not, see <http://www.gnu.org/licenses/>.
 */

#include <linux/pci.h>
#include <linux/delay.h>
#include <sound/control.h>
#include <sound/core.h>
#include <sound/info.h>
#include <sound/pcm.h>
#include <sound/tlv.h>
#include "oxygen.h"
#include "xonar_dg.h"
#include "cs4245.h"

/* analog output select */

static int output_select_apply(struct oxygen *chip)
{
	struct dg *data = chip->model_data;

	data->cs4245_shadow[CS4245_SIGNAL_SEL] &= ~CS4245_A_OUT_SEL_MASK;
	if (data->output_sel == PLAYBACK_DST_HP) {
		/* mute FP (aux output) amplifier, switch rear jack to CS4245 */
		oxygen_set_bits8(chip, OXYGEN_GPIO_DATA, GPIO_HP_REAR);
	} else if (data->output_sel == PLAYBACK_DST_HP_FP) {
		/*
		 * Unmute FP amplifier, switch rear jack to CS4361;
		 * I2S channels 2,3,4 should be inactive.
		 */
		oxygen_clear_bits8(chip, OXYGEN_GPIO_DATA, GPIO_HP_REAR);
		data->cs4245_shadow[CS4245_SIGNAL_SEL] |= CS4245_A_OUT_SEL_DAC;
	} else {
		/*
		 * 2.0, 4.0, 5.1: switch to CS4361, mute FP amp.,
		 * and change playback routing.
		 */
		oxygen_clear_bits8(chip, OXYGEN_GPIO_DATA, GPIO_HP_REAR);
	}
	return cs4245_write_spi(chip, CS4245_SIGNAL_SEL);
}

static int output_select_info(struct snd_kcontrol *ctl,
			      struct snd_ctl_elem_info *info)
{
	static const char *const names[3] = {
		"Stereo Headphones",
		"Stereo Headphones FP",
		"Multichannel",
	};

	return snd_ctl_enum_info(info, 1, 3, names);
}

static int output_select_get(struct snd_kcontrol *ctl,
			     struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	struct dg *data = chip->model_data;

	mutex_lock(&chip->mutex);
	value->value.enumerated.item[0] = data->output_sel;
	mutex_unlock(&chip->mutex);
	return 0;
}

static int output_select_put(struct snd_kcontrol *ctl,
			     struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	struct dg *data = chip->model_data;
	unsigned int new = value->value.enumerated.item[0];
	int changed = 0;
	int ret;

	mutex_lock(&chip->mutex);
	if (data->output_sel != new) {
		data->output_sel = new;
		ret = output_select_apply(chip);
		changed = ret >= 0 ? 1 : ret;
		oxygen_update_dac_routing(chip);
	}
	mutex_unlock(&chip->mutex);

	return changed;
}

/* CS4245 Headphone Channels A&B Volume Control */

static int hp_stereo_volume_info(struct snd_kcontrol *ctl,
				struct snd_ctl_elem_info *info)
{
	info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	info->count = 2;
	info->value.integer.min = 0;
	info->value.integer.max = 255;
	return 0;
}

static int hp_stereo_volume_get(struct snd_kcontrol *ctl,
				struct snd_ctl_elem_value *val)
{
	struct oxygen *chip = ctl->private_data;
	struct dg *data = chip->model_data;
	unsigned int tmp;

	mutex_lock(&chip->mutex);
	tmp = (~data->cs4245_shadow[CS4245_DAC_A_CTRL]) & 255;
	val->value.integer.value[0] = tmp;
	tmp = (~data->cs4245_shadow[CS4245_DAC_B_CTRL]) & 255;
	val->value.integer.value[1] = tmp;
	mutex_unlock(&chip->mutex);
	return 0;
}

static int hp_stereo_volume_put(struct snd_kcontrol *ctl,
				struct snd_ctl_elem_value *val)
{
	struct oxygen *chip = ctl->private_data;
	struct dg *data = chip->model_data;
	int ret;
	int changed = 0;
	long new1 = val->value.integer.value[0];
	long new2 = val->value.integer.value[1];

	if ((new1 > 255) || (new1 < 0) || (new2 > 255) || (new2 < 0))
		return -EINVAL;

	mutex_lock(&chip->mutex);
	if ((data->cs4245_shadow[CS4245_DAC_A_CTRL] != ~new1) ||
	    (data->cs4245_shadow[CS4245_DAC_B_CTRL] != ~new2)) {
		data->cs4245_shadow[CS4245_DAC_A_CTRL] = ~new1;
		data->cs4245_shadow[CS4245_DAC_B_CTRL] = ~new2;
		ret = cs4245_write_spi(chip, CS4245_DAC_A_CTRL);
		if (ret >= 0)
			ret = cs4245_write_spi(chip, CS4245_DAC_B_CTRL);
		changed = ret >= 0 ? 1 : ret;
	}
	mutex_unlock(&chip->mutex);

	return changed;
}

/* Headphone Mute */

static int hp_mute_get(struct snd_kcontrol *ctl,
			struct snd_ctl_elem_value *val)
{
	struct oxygen *chip = ctl->private_data;
	struct dg *data = chip->model_data;

	mutex_lock(&chip->mutex);
	val->value.integer.value[0] =
		!(data->cs4245_shadow[CS4245_DAC_CTRL_1] & CS4245_MUTE_DAC);
	mutex_unlock(&chip->mutex);
	return 0;
}

static int hp_mute_put(struct snd_kcontrol *ctl,
			struct snd_ctl_elem_value *val)
{
	struct oxygen *chip = ctl->private_data;
	struct dg *data = chip->model_data;
	int ret;
	int changed;

	if (val->value.integer.value[0] > 1)
		return -EINVAL;
	mutex_lock(&chip->mutex);
	data->cs4245_shadow[CS4245_DAC_CTRL_1] &= ~CS4245_MUTE_DAC;
	data->cs4245_shadow[CS4245_DAC_CTRL_1] |=
		(~val->value.integer.value[0] << 2) & CS4245_MUTE_DAC;
	ret = cs4245_write_spi(chip, CS4245_DAC_CTRL_1);
	changed = ret >= 0 ? 1 : ret;
	mutex_unlock(&chip->mutex);
	return changed;
}

/* capture volume for all sources */

static int input_volume_apply(struct oxygen *chip, char left, char right)
{
	struct dg *data = chip->model_data;
	int ret;

	data->cs4245_shadow[CS4245_PGA_A_CTRL] = left;
	data->cs4245_shadow[CS4245_PGA_B_CTRL] = right;
	ret = cs4245_write_spi(chip, CS4245_PGA_A_CTRL);
	if (ret < 0)
		return ret;
	return cs4245_write_spi(chip, CS4245_PGA_B_CTRL);
}

static int input_vol_info(struct snd_kcontrol *ctl,
			  struct snd_ctl_elem_info *info)
{
	info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	info->count = 2;
	info->value.integer.min = 2 * -12;
	info->value.integer.max = 2 * 12;
	return 0;
}

static int input_vol_get(struct snd_kcontrol *ctl,
			 struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	struct dg *data = chip->model_data;
	unsigned int idx = ctl->private_value;

	mutex_lock(&chip->mutex);
	value->value.integer.value[0] = data->input_vol[idx][0];
	value->value.integer.value[1] = data->input_vol[idx][1];
	mutex_unlock(&chip->mutex);
	return 0;
}

static int input_vol_put(struct snd_kcontrol *ctl,
			 struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	struct dg *data = chip->model_data;
	unsigned int idx = ctl->private_value;
	int changed = 0;
	int ret = 0;

	if (value->value.integer.value[0] < 2 * -12 ||
	    value->value.integer.value[0] > 2 * 12 ||
	    value->value.integer.value[1] < 2 * -12 ||
	    value->value.integer.value[1] > 2 * 12)
		return -EINVAL;
	mutex_lock(&chip->mutex);
	changed = data->input_vol[idx][0] != value->value.integer.value[0] ||
		  data->input_vol[idx][1] != value->value.integer.value[1];
	if (changed) {
		data->input_vol[idx][0] = value->value.integer.value[0];
		data->input_vol[idx][1] = value->value.integer.value[1];
		if (idx == data->input_sel) {
			ret = input_volume_apply(chip,
				data->input_vol[idx][0],
				data->input_vol[idx][1]);
		}
		changed = ret >= 0 ? 1 : ret;
	}
	mutex_unlock(&chip->mutex);
	return changed;
}

/* Capture Source */

static int input_source_apply(struct oxygen *chip)
{
	struct dg *data = chip->model_data;

	data->cs4245_shadow[CS4245_ANALOG_IN] &= ~CS4245_SEL_MASK;
	if (data->input_sel == CAPTURE_SRC_FP_MIC)
		data->cs4245_shadow[CS4245_ANALOG_IN] |= CS4245_SEL_INPUT_2;
	else if (data->input_sel == CAPTURE_SRC_LINE)
		data->cs4245_shadow[CS4245_ANALOG_IN] |= CS4245_SEL_INPUT_4;
	else if (data->input_sel != CAPTURE_SRC_MIC)
		data->cs4245_shadow[CS4245_ANALOG_IN] |= CS4245_SEL_INPUT_1;
	return cs4245_write_spi(chip, CS4245_ANALOG_IN);
}

static int input_sel_info(struct snd_kcontrol *ctl,
			  struct snd_ctl_elem_info *info)
{
	static const char *const names[4] = {
		"Mic", "Front Mic", "Line", "Aux"
	};

	return snd_ctl_enum_info(info, 1, 4, names);
}

static int input_sel_get(struct snd_kcontrol *ctl,
			 struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	struct dg *data = chip->model_data;

	mutex_lock(&chip->mutex);
	value->value.enumerated.item[0] = data->input_sel;
	mutex_unlock(&chip->mutex);
	return 0;
}

static int input_sel_put(struct snd_kcontrol *ctl,
			 struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	struct dg *data = chip->model_data;
	int changed;
	int ret;

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

	mutex_lock(&chip->mutex);
	changed = value->value.enumerated.item[0] != data->input_sel;
	if (changed) {
		data->input_sel = value->value.enumerated.item[0];

		ret = input_source_apply(chip);
		if (ret >= 0)
			ret = input_volume_apply(chip,
				data->input_vol[data->input_sel][0],
				data->input_vol[data->input_sel][1]);
		changed = ret >= 0 ? 1 : ret;
	}
	mutex_unlock(&chip->mutex);
	return changed;
}

/* ADC high-pass filter */

static int hpf_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
{
	static const char *const names[2] = { "Active", "Frozen" };

	return snd_ctl_enum_info(info, 1, 2, names);
}

static int hpf_get(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	struct dg *data = chip->model_data;

	value->value.enumerated.item[0] =
		!!(data->cs4245_shadow[CS4245_ADC_CTRL] & CS4245_HPF_FREEZE);
	return 0;
}

static int hpf_put(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	struct dg *data = chip->model_data;
	u8 reg;
	int changed;

	mutex_lock(&chip->mutex);
	reg = data->cs4245_shadow[CS4245_ADC_CTRL] & ~CS4245_HPF_FREEZE;
	if (value->value.enumerated.item[0])
		reg |= CS4245_HPF_FREEZE;
	changed = reg != data->cs4245_shadow[CS4245_ADC_CTRL];
	if (changed) {
		data->cs4245_shadow[CS4245_ADC_CTRL] = reg;
		cs4245_write_spi(chip, CS4245_ADC_CTRL);
	}
	mutex_unlock(&chip->mutex);
	return changed;
}

#define INPUT_VOLUME(xname, index) { \
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
	.name = xname, \
	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
		  SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
	.info = input_vol_info, \
	.get = input_vol_get, \
	.put = input_vol_put, \
	.tlv = { .p = pga_db_scale }, \
	.private_value = index, \
}
static const DECLARE_TLV_DB_MINMAX(hp_db_scale, -12550, 0);
static const DECLARE_TLV_DB_MINMAX(pga_db_scale, -1200, 1200);
static const struct snd_kcontrol_new dg_controls[] = {
	{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		.name = "Analog Output Playback Enum",
		.info = output_select_info,
		.get = output_select_get,
		.put = output_select_put,
	},
	{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		.name = "Headphone Playback Volume",
		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
			  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
		.info = hp_stereo_volume_info,
		.get = hp_stereo_volume_get,
		.put = hp_stereo_volume_put,
		.tlv = { .p = hp_db_scale, },
	},
	{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		.name = "Headphone Playback Switch",
		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
		.info = snd_ctl_boolean_mono_info,
		.get = hp_mute_get,
		.put = hp_mute_put,
	},
	INPUT_VOLUME("Mic Capture Volume", CAPTURE_SRC_MIC),
	INPUT_VOLUME("Front Mic Capture Volume", CAPTURE_SRC_FP_MIC),
	INPUT_VOLUME("Line Capture Volume", CAPTURE_SRC_LINE),
	INPUT_VOLUME("Aux Capture Volume", CAPTURE_SRC_AUX),
	{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		.name = "Capture Source",
		.info = input_sel_info,
		.get = input_sel_get,
		.put = input_sel_put,
	},
	{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		.name = "ADC High-pass Filter Capture Enum",
		.info = hpf_info,
		.get = hpf_get,
		.put = hpf_put,
	},
};

static int dg_control_filter(struct snd_kcontrol_new *template)
{
	if (!strncmp(template->name, "Master Playback ", 16))
		return 1;
	return 0;
}

static int dg_mixer_init(struct oxygen *chip)
{
	unsigned int i;
	int err;

	output_select_apply(chip);
	input_source_apply(chip);
	oxygen_update_dac_routing(chip);

	for (i = 0; i < ARRAY_SIZE(dg_controls); ++i) {
		err = snd_ctl_add(chip->card,
				  snd_ctl_new1(&dg_controls[i], chip));
		if (err < 0)
			return err;
	}

	return 0;
}

struct oxygen_model model_xonar_dg = {
	.longname = "C-Media Oxygen HD Audio",
	.chip = "CMI8786",
	.init = dg_init,
	.control_filter = dg_control_filter,
	.mixer_init = dg_mixer_init,
	.cleanup = dg_cleanup,
	.suspend = dg_suspend,
	.resume = dg_resume,
	.set_dac_params = set_cs4245_dac_params,
	.set_adc_params = set_cs4245_adc_params,
	.adjust_dac_routing = adjust_dg_dac_routing,
	.dump_registers = dump_cs4245_registers,
	.model_data_size = sizeof(struct dg),
	.device_config = PLAYBACK_0_TO_I2S |
			 PLAYBACK_1_TO_SPDIF |
			 CAPTURE_0_FROM_I2S_1 |
			 CAPTURE_1_FROM_SPDIF,
	.dac_channels_pcm = 6,
	.dac_channels_mixer = 0,
	.function_flags = OXYGEN_FUNCTION_SPI,
	.dac_mclks = OXYGEN_MCLKS(256, 128, 128),
	.adc_mclks = OXYGEN_MCLKS(256, 128, 128),
	.dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
	.adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
};
Commit	Line	Data
041f26b6 RV	1	/*
	2	* Mixer controls for the Xonar DG/DGX
	3	*
	4	* Copyright (c) Clemens Ladisch <clemens@ladisch.de>
	5	* Copyright (c) Roman Volkov <v1ron@mail.ru>
	6	*
	7	* This driver is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License, version 2.
	9	*
	10	* This driver is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this driver; if not, see <http://www.gnu.org/licenses/>.
	17	*/
	18
	19	#include <linux/pci.h>
	20	#include <linux/delay.h>
	21	#include <sound/control.h>
	22	#include <sound/core.h>
	23	#include <sound/info.h>
	24	#include <sound/pcm.h>
	25	#include <sound/tlv.h>
	26	#include "oxygen.h"
	27	#include "xonar_dg.h"
	28	#include "cs4245.h"
	29
2809cb84 RV	30	/* analog output select */
	31
	32	static int output_select_apply(struct oxygen *chip)
	33	{
	34	struct dg *data = chip->model_data;
	35
	36	data->cs4245_shadow[CS4245_SIGNAL_SEL] &= ~CS4245_A_OUT_SEL_MASK;
	37	if (data->output_sel == PLAYBACK_DST_HP) {
	38	/* mute FP (aux output) amplifier, switch rear jack to CS4245 */
	39	oxygen_set_bits8(chip, OXYGEN_GPIO_DATA, GPIO_HP_REAR);
	40	} else if (data->output_sel == PLAYBACK_DST_HP_FP) {
	41	/*
	42	* Unmute FP amplifier, switch rear jack to CS4361;
	43	* I2S channels 2,3,4 should be inactive.
	44	*/
	45	oxygen_clear_bits8(chip, OXYGEN_GPIO_DATA, GPIO_HP_REAR);
	46	data->cs4245_shadow[CS4245_SIGNAL_SEL] \|= CS4245_A_OUT_SEL_DAC;
	47	} else {
	48	/*
	49	* 2.0, 4.0, 5.1: switch to CS4361, mute FP amp.,
	50	* and change playback routing.
	51	*/
	52	oxygen_clear_bits8(chip, OXYGEN_GPIO_DATA, GPIO_HP_REAR);
	53	}
	54	return cs4245_write_spi(chip, CS4245_SIGNAL_SEL);
	55	}
	56
	57	static int output_select_info(struct snd_kcontrol *ctl,
041f26b6 RV	58	struct snd_ctl_elem_info *info)
	59	{
	60	static const char *const names[3] = {
2809cb84 RV	61	"Stereo Headphones",
	62	"Stereo Headphones FP",
	63	"Multichannel",
041f26b6 RV	64	};
	65
	66	return snd_ctl_enum_info(info, 1, 3, names);
	67	}
	68
2809cb84	69	static int output_select_get(struct snd_kcontrol *ctl,
041f26b6 RV	70	struct snd_ctl_elem_value *value)
	71	{
	72	struct oxygen *chip = ctl->private_data;
	73	struct dg *data = chip->model_data;
	74
	75	mutex_lock(&chip->mutex);
	76	value->value.enumerated.item[0] = data->output_sel;
	77	mutex_unlock(&chip->mutex);
	78	return 0;
	79	}
	80
2809cb84	81	static int output_select_put(struct snd_kcontrol *ctl,
041f26b6 RV	82	struct snd_ctl_elem_value *value)
	83	{
	84	struct oxygen *chip = ctl->private_data;
	85	struct dg *data = chip->model_data;
2809cb84 RV	86	unsigned int new = value->value.enumerated.item[0];
	87	int changed = 0;
	88	int ret;
041f26b6 RV	89
041f26b6 RV	90	mutex_lock(&chip->mutex);
2809cb84 RV	91	if (data->output_sel != new) {
	92	data->output_sel = new;
	93	ret = output_select_apply(chip);
	94	changed = ret >= 0 ? 1 : ret;
	95	oxygen_update_dac_routing(chip);
041f26b6 RV	96	}
041f26b6 RV	97	mutex_unlock(&chip->mutex);
2809cb84	98
041f26b6 RV	99	return changed;
	100	}
	101
c754639a RV	102	/* CS4245 Headphone Channels A&B Volume Control */
	103
	104	static int hp_stereo_volume_info(struct snd_kcontrol *ctl,
	105	struct snd_ctl_elem_info *info)
041f26b6	106	{
c754639a RV	107	info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	108	info->count = 2;
	109	info->value.integer.min = 0;
	110	info->value.integer.max = 255;
	111	return 0;
	112	}
041f26b6	113
c754639a RV	114	static int hp_stereo_volume_get(struct snd_kcontrol *ctl,
	115	struct snd_ctl_elem_value *val)
	116	{
	117	struct oxygen *chip = ctl->private_data;
	118	struct dg *data = chip->model_data;
	119	unsigned int tmp;
	120
	121	mutex_lock(&chip->mutex);
	122	tmp = (~data->cs4245_shadow[CS4245_DAC_A_CTRL]) & 255;
	123	val->value.integer.value[0] = tmp;
	124	tmp = (~data->cs4245_shadow[CS4245_DAC_B_CTRL]) & 255;
	125	val->value.integer.value[1] = tmp;
	126	mutex_unlock(&chip->mutex);
	127	return 0;
041f26b6 RV	128	}
041f26b6 RV	129
c754639a RV	130	static int hp_stereo_volume_put(struct snd_kcontrol *ctl,
c754639a RV	131	struct snd_ctl_elem_value *val)
041f26b6 RV	132	{
	133	struct oxygen *chip = ctl->private_data;
	134	struct dg *data = chip->model_data;
c754639a RV	135	int ret;
	136	int changed = 0;
	137	long new1 = val->value.integer.value[0];
	138	long new2 = val->value.integer.value[1];
	139
	140	if ((new1 > 255) \|\| (new1 < 0) \|\| (new2 > 255) \|\| (new2 < 0))
	141	return -EINVAL;
041f26b6 RV	142
041f26b6 RV	143	mutex_lock(&chip->mutex);
c754639a RV	144	if ((data->cs4245_shadow[CS4245_DAC_A_CTRL] != ~new1) \|\|
	145	(data->cs4245_shadow[CS4245_DAC_B_CTRL] != ~new2)) {
	146	data->cs4245_shadow[CS4245_DAC_A_CTRL] = ~new1;
	147	data->cs4245_shadow[CS4245_DAC_B_CTRL] = ~new2;
	148	ret = cs4245_write_spi(chip, CS4245_DAC_A_CTRL);
	149	if (ret >= 0)
	150	ret = cs4245_write_spi(chip, CS4245_DAC_B_CTRL);
	151	changed = ret >= 0 ? 1 : ret;
	152	}
	153	mutex_unlock(&chip->mutex);
	154
	155	return changed;
	156	}
	157
	158	/* Headphone Mute */
	159
	160	static int hp_mute_get(struct snd_kcontrol *ctl,
	161	struct snd_ctl_elem_value *val)
	162	{
	163	struct oxygen *chip = ctl->private_data;
	164	struct dg *data = chip->model_data;
	165
	166	mutex_lock(&chip->mutex);
	167	val->value.integer.value[0] =
	168	!(data->cs4245_shadow[CS4245_DAC_CTRL_1] & CS4245_MUTE_DAC);
041f26b6 RV	169	mutex_unlock(&chip->mutex);
	170	return 0;
	171	}
	172
c754639a RV	173	static int hp_mute_put(struct snd_kcontrol *ctl,
c754639a RV	174	struct snd_ctl_elem_value *val)
041f26b6	175	{
041f26b6 RV	176	struct oxygen *chip = ctl->private_data;
041f26b6 RV	177	struct dg *data = chip->model_data;
c754639a	178	int ret;
041f26b6 RV	179	int changed;
041f26b6 RV	180
c754639a	181	if (val->value.integer.value[0] > 1)
041f26b6	182	return -EINVAL;
041f26b6	183	mutex_lock(&chip->mutex);
c754639a RV	184	data->cs4245_shadow[CS4245_DAC_CTRL_1] &= ~CS4245_MUTE_DAC;
	185	data->cs4245_shadow[CS4245_DAC_CTRL_1] \|=
	186	(~val->value.integer.value[0] << 2) & CS4245_MUTE_DAC;
	187	ret = cs4245_write_spi(chip, CS4245_DAC_CTRL_1);
	188	changed = ret >= 0 ? 1 : ret;
041f26b6 RV	189	mutex_unlock(&chip->mutex);
	190	return changed;
	191	}
	192
cf218b2e RV	193	/* capture volume for all sources */
	194
	195	static int input_volume_apply(struct oxygen *chip, char left, char right)
	196	{
	197	struct dg *data = chip->model_data;
	198	int ret;
	199
	200	data->cs4245_shadow[CS4245_PGA_A_CTRL] = left;
	201	data->cs4245_shadow[CS4245_PGA_B_CTRL] = right;
	202	ret = cs4245_write_spi(chip, CS4245_PGA_A_CTRL);
	203	if (ret < 0)
	204	return ret;
	205	return cs4245_write_spi(chip, CS4245_PGA_B_CTRL);
	206	}
	207
041f26b6 RV	208	static int input_vol_info(struct snd_kcontrol *ctl,
	209	struct snd_ctl_elem_info *info)
	210	{
	211	info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	212	info->count = 2;
	213	info->value.integer.min = 2 * -12;
	214	info->value.integer.max = 2 * 12;
	215	return 0;
	216	}
	217
	218	static int input_vol_get(struct snd_kcontrol *ctl,
	219	struct snd_ctl_elem_value *value)
	220	{
	221	struct oxygen *chip = ctl->private_data;
	222	struct dg *data = chip->model_data;
	223	unsigned int idx = ctl->private_value;
	224
	225	mutex_lock(&chip->mutex);
	226	value->value.integer.value[0] = data->input_vol[idx][0];
	227	value->value.integer.value[1] = data->input_vol[idx][1];
	228	mutex_unlock(&chip->mutex);
	229	return 0;
	230	}
	231
	232	static int input_vol_put(struct snd_kcontrol *ctl,
	233	struct snd_ctl_elem_value *value)
	234	{
	235	struct oxygen *chip = ctl->private_data;
	236	struct dg *data = chip->model_data;
	237	unsigned int idx = ctl->private_value;
	238	int changed = 0;
cf218b2e	239	int ret = 0;
041f26b6 RV	240
	241	if (value->value.integer.value[0] < 2 * -12 \|\|
	242	value->value.integer.value[0] > 2 * 12 \|\|
	243	value->value.integer.value[1] < 2 * -12 \|\|
	244	value->value.integer.value[1] > 2 * 12)
	245	return -EINVAL;
	246	mutex_lock(&chip->mutex);
	247	changed = data->input_vol[idx][0] != value->value.integer.value[0] \|\|
	248	data->input_vol[idx][1] != value->value.integer.value[1];
	249	if (changed) {
	250	data->input_vol[idx][0] = value->value.integer.value[0];
	251	data->input_vol[idx][1] = value->value.integer.value[1];
	252	if (idx == data->input_sel) {
cf218b2e RV	253	ret = input_volume_apply(chip,
	254	data->input_vol[idx][0],
	255	data->input_vol[idx][1]);
041f26b6	256	}
cf218b2e	257	changed = ret >= 0 ? 1 : ret;
041f26b6 RV	258	}
	259	mutex_unlock(&chip->mutex);
	260	return changed;
	261	}
	262
70e0d82d RV	263	/* Capture Source */
	264
	265	static int input_source_apply(struct oxygen *chip)
	266	{
	267	struct dg *data = chip->model_data;
	268
	269	data->cs4245_shadow[CS4245_ANALOG_IN] &= ~CS4245_SEL_MASK;
	270	if (data->input_sel == CAPTURE_SRC_FP_MIC)
	271	data->cs4245_shadow[CS4245_ANALOG_IN] \|= CS4245_SEL_INPUT_2;
	272	else if (data->input_sel == CAPTURE_SRC_LINE)
	273	data->cs4245_shadow[CS4245_ANALOG_IN] \|= CS4245_SEL_INPUT_4;
	274	else if (data->input_sel != CAPTURE_SRC_MIC)
	275	data->cs4245_shadow[CS4245_ANALOG_IN] \|= CS4245_SEL_INPUT_1;
	276	return cs4245_write_spi(chip, CS4245_ANALOG_IN);
	277	}
	278
041f26b6 RV	279	static int input_sel_info(struct snd_kcontrol *ctl,
	280	struct snd_ctl_elem_info *info)
	281	{
	282	static const char *const names[4] = {
70e0d82d	283	"Mic", "Front Mic", "Line", "Aux"
041f26b6 RV	284	};
	285
	286	return snd_ctl_enum_info(info, 1, 4, names);
	287	}
	288
	289	static int input_sel_get(struct snd_kcontrol *ctl,
	290	struct snd_ctl_elem_value *value)
	291	{
	292	struct oxygen *chip = ctl->private_data;
	293	struct dg *data = chip->model_data;
	294
	295	mutex_lock(&chip->mutex);
	296	value->value.enumerated.item[0] = data->input_sel;
	297	mutex_unlock(&chip->mutex);
	298	return 0;
	299	}
	300
	301	static int input_sel_put(struct snd_kcontrol *ctl,
	302	struct snd_ctl_elem_value *value)
	303	{
041f26b6 RV	304	struct oxygen *chip = ctl->private_data;
	305	struct dg *data = chip->model_data;
	306	int changed;
70e0d82d	307	int ret;
041f26b6 RV	308
	309	if (value->value.enumerated.item[0] > 3)
	310	return -EINVAL;
	311
	312	mutex_lock(&chip->mutex);
	313	changed = value->value.enumerated.item[0] != data->input_sel;
	314	if (changed) {
	315	data->input_sel = value->value.enumerated.item[0];
	316
70e0d82d RV	317	ret = input_source_apply(chip);
	318	if (ret >= 0)
	319	ret = input_volume_apply(chip,
	320	data->input_vol[data->input_sel][0],
	321	data->input_vol[data->input_sel][1]);
	322	changed = ret >= 0 ? 1 : ret;
041f26b6 RV	323	}
	324	mutex_unlock(&chip->mutex);
	325	return changed;
	326	}
	327
fc114e9f RV	328	/* ADC high-pass filter */
fc114e9f RV	329
041f26b6 RV	330	static int hpf_info(struct snd_kcontrol ctl, struct snd_ctl_elem_info info)
	331	{
	332	static const char *const names[2] = { "Active", "Frozen" };
	333
	334	return snd_ctl_enum_info(info, 1, 2, names);
	335	}
	336
	337	static int hpf_get(struct snd_kcontrol ctl, struct snd_ctl_elem_value value)
	338	{
	339	struct oxygen *chip = ctl->private_data;
	340	struct dg *data = chip->model_data;
	341
	342	value->value.enumerated.item[0] =
	343	!!(data->cs4245_shadow[CS4245_ADC_CTRL] & CS4245_HPF_FREEZE);
	344	return 0;
	345	}
	346
	347	static int hpf_put(struct snd_kcontrol ctl, struct snd_ctl_elem_value value)
	348	{
	349	struct oxygen *chip = ctl->private_data;
	350	struct dg *data = chip->model_data;
	351	u8 reg;
	352	int changed;
	353
	354	mutex_lock(&chip->mutex);
	355	reg = data->cs4245_shadow[CS4245_ADC_CTRL] & ~CS4245_HPF_FREEZE;
	356	if (value->value.enumerated.item[0])
	357	reg \|= CS4245_HPF_FREEZE;
	358	changed = reg != data->cs4245_shadow[CS4245_ADC_CTRL];
fc114e9f RV	359	if (changed) {
	360	data->cs4245_shadow[CS4245_ADC_CTRL] = reg;
	361	cs4245_write_spi(chip, CS4245_ADC_CTRL);
	362	}
041f26b6 RV	363	mutex_unlock(&chip->mutex);
	364	return changed;
	365	}
	366
	367	#define INPUT_VOLUME(xname, index) { \
	368	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
	369	.name = xname, \
cf218b2e RV	370	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE \| \
cf218b2e RV	371	SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
041f26b6 RV	372	.info = input_vol_info, \
	373	.get = input_vol_get, \
	374	.put = input_vol_put, \
cf218b2e	375	.tlv = { .p = pga_db_scale }, \
041f26b6 RV	376	.private_value = index, \
041f26b6 RV	377	}
c754639a	378	static const DECLARE_TLV_DB_MINMAX(hp_db_scale, -12550, 0);
cf218b2e	379	static const DECLARE_TLV_DB_MINMAX(pga_db_scale, -1200, 1200);
041f26b6 RV	380	static const struct snd_kcontrol_new dg_controls[] = {
	381	{
	382	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	383	.name = "Analog Output Playback Enum",
2809cb84 RV	384	.info = output_select_info,
	385	.get = output_select_get,
	386	.put = output_select_put,
041f26b6 RV	387	},
	388	{
	389	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
c754639a RV	390	.name = "Headphone Playback Volume",
	391	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE \|
	392	SNDRV_CTL_ELEM_ACCESS_TLV_READ,
	393	.info = hp_stereo_volume_info,
	394	.get = hp_stereo_volume_get,
	395	.put = hp_stereo_volume_put,
	396	.tlv = { .p = hp_db_scale, },
	397	},
	398	{
	399	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	400	.name = "Headphone Playback Switch",
	401	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
	402	.info = snd_ctl_boolean_mono_info,
	403	.get = hp_mute_get,
	404	.put = hp_mute_put,
041f26b6	405	},
70e0d82d RV	406	INPUT_VOLUME("Mic Capture Volume", CAPTURE_SRC_MIC),
	407	INPUT_VOLUME("Front Mic Capture Volume", CAPTURE_SRC_FP_MIC),
	408	INPUT_VOLUME("Line Capture Volume", CAPTURE_SRC_LINE),
	409	INPUT_VOLUME("Aux Capture Volume", CAPTURE_SRC_AUX),
041f26b6 RV	410	{
	411	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	412	.name = "Capture Source",
	413	.info = input_sel_info,
	414	.get = input_sel_get,
	415	.put = input_sel_put,
	416	},
	417	{
	418	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	419	.name = "ADC High-pass Filter Capture Enum",
	420	.info = hpf_info,
	421	.get = hpf_get,
	422	.put = hpf_put,
	423	},
	424	};
	425
	426	static int dg_control_filter(struct snd_kcontrol_new *template)
	427	{
	428	if (!strncmp(template->name, "Master Playback ", 16))
	429	return 1;
	430	return 0;
	431	}
	432
	433	static int dg_mixer_init(struct oxygen *chip)
	434	{
	435	unsigned int i;
	436	int err;
	437
3f49a66f RV	438	output_select_apply(chip);
	439	input_source_apply(chip);
	440	oxygen_update_dac_routing(chip);
	441
041f26b6 RV	442	for (i = 0; i < ARRAY_SIZE(dg_controls); ++i) {
	443	err = snd_ctl_add(chip->card,
	444	snd_ctl_new1(&dg_controls[i], chip));
	445	if (err < 0)
	446	return err;
	447	}
3f49a66f	448
041f26b6 RV	449	return 0;
	450	}
	451
	452	struct oxygen_model model_xonar_dg = {
	453	.longname = "C-Media Oxygen HD Audio",
	454	.chip = "CMI8786",
	455	.init = dg_init,
	456	.control_filter = dg_control_filter,
	457	.mixer_init = dg_mixer_init,
	458	.cleanup = dg_cleanup,
	459	.suspend = dg_suspend,
	460	.resume = dg_resume,
	461	.set_dac_params = set_cs4245_dac_params,
	462	.set_adc_params = set_cs4245_adc_params,
	463	.adjust_dac_routing = adjust_dg_dac_routing,
	464	.dump_registers = dump_cs4245_registers,
	465	.model_data_size = sizeof(struct dg),
	466	.device_config = PLAYBACK_0_TO_I2S \|
	467	PLAYBACK_1_TO_SPDIF \|
3dd77654	468	CAPTURE_0_FROM_I2S_1 \|
041f26b6 RV	469	CAPTURE_1_FROM_SPDIF,
	470	.dac_channels_pcm = 6,
	471	.dac_channels_mixer = 0,
	472	.function_flags = OXYGEN_FUNCTION_SPI,
	473	.dac_mclks = OXYGEN_MCLKS(256, 128, 128),
	474	.adc_mclks = OXYGEN_MCLKS(256, 128, 128),
	475	.dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
	476	.adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
	477	};