Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 041f26b6 authored by Roman Volkov's avatar Roman Volkov Committed by Clemens Ladisch
Browse files

ALSA: oxygen: Xonar DG(X): move the mixer code into another file 



Moving the mixer code away makes things easier. The mixer
will control the driver, so the functions of the
driver need to be non-static.

Signed-off-by: default avatarRoman Volkov <v1ron@mail.ru>
Signed-off-by: default avatarClemens Ladisch <clemens@ladisch.de>
parent 06f70d0d

sound/pci/oxygen/Makefile

+1 −1
Original line number Diff line number Diff line 
snd-oxygen-lib-objs := oxygen_io.o oxygen_lib.o oxygen_mixer.o oxygen_pcm.o

snd-oxygen-objs := oxygen.o xonar_dg.o

snd-oxygen-objs := oxygen.o xonar_dg_mixer.o xonar_dg.o

snd-virtuoso-objs := virtuoso.o xonar_lib.o \

	xonar_pcm179x.o xonar_cs43xx.o xonar_wm87x6.o xonar_hdmi.o

sound/pci/oxygen/xonar_dg.c

+10 −363
Original line number Diff line number Diff line
@@ -123,7 +123,7 @@ int cs4245_shadow_control(struct oxygen *chip, enum cs4245_shadow_operation op) 
	return 0;

}



static void cs4245_write(struct oxygen *chip, unsigned int reg, u8 value)

void cs4245_write(struct oxygen *chip, unsigned int reg, u8 value)

{

	struct dg *data = chip->model_data;
@@ -138,7 +138,7 @@ static void cs4245_write(struct oxygen *chip, unsigned int reg, u8 value) 
	data->cs4245_shadow[reg] = value;

}



static void cs4245_write_cached(struct oxygen *chip, unsigned int reg, u8 value)

void cs4245_write_cached(struct oxygen *chip, unsigned int reg, u8 value)

{

	struct dg *data = chip->model_data;
@@ -178,7 +178,7 @@ static void cs4245_init(struct oxygen *chip) 
	snd_component_add(chip->card, "CS4245");

}



static void dg_init(struct oxygen *chip)

void dg_init(struct oxygen *chip)

{

	struct dg *data = chip->model_data;
@@ -195,24 +195,24 @@ static void dg_init(struct oxygen *chip) 
		       GPIO_OUTPUT_ENABLE | GPIO_INPUT_ROUTE);

}



static void dg_cleanup(struct oxygen *chip)

void dg_cleanup(struct oxygen *chip)

{

	oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_OUTPUT_ENABLE);

}



static void dg_suspend(struct oxygen *chip)

void dg_suspend(struct oxygen *chip)

{

	dg_cleanup(chip);

}



static void dg_resume(struct oxygen *chip)

void dg_resume(struct oxygen *chip)

{

	cs4245_shadow_control(chip, CS4245_LOAD_FROM_SHADOW);

	msleep(2500);

	oxygen_set_bits16(chip, OXYGEN_GPIO_DATA, GPIO_OUTPUT_ENABLE);

}



static void set_cs4245_dac_params(struct oxygen *chip,

void set_cs4245_dac_params(struct oxygen *chip,

				  struct snd_pcm_hw_params *params)

{

	struct dg *data = chip->model_data;
@@ -237,7 +237,7 @@ static void set_cs4245_dac_params(struct oxygen *chip, 
	cs4245_write_spi(chip, CS4245_MCLK_FREQ);

}



static void set_cs4245_adc_params(struct oxygen *chip,

void set_cs4245_adc_params(struct oxygen *chip,

				  struct snd_pcm_hw_params *params)

{

	struct dg *data = chip->model_data;
@@ -262,7 +262,7 @@ static void set_cs4245_adc_params(struct oxygen *chip, 
	cs4245_write_spi(chip, CS4245_MCLK_FREQ);

}



static unsigned int adjust_dg_dac_routing(struct oxygen *chip,

unsigned int adjust_dg_dac_routing(struct oxygen *chip,

					  unsigned int play_routing)

{

	struct dg *data = chip->model_data;
@@ -287,333 +287,7 @@ static unsigned int adjust_dg_dac_routing(struct oxygen *chip, 
	return routing;

}



static int output_switch_info(struct snd_kcontrol *ctl,

			      struct snd_ctl_elem_info *info)

{

	static const char *const names[3] = {

		"Speakers", "Headphones", "FP Headphones"

	};



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

}



static int output_switch_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_switch_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;



	if (value->value.enumerated.item[0] > 2)

		return -EINVAL;



	mutex_lock(&chip->mutex);

	changed = value->value.enumerated.item[0] != data->output_sel;

	if (changed) {

		data->output_sel = value->value.enumerated.item[0];



		reg = data->cs4245_shadow[CS4245_SIGNAL_SEL] &

						~CS4245_A_OUT_SEL_MASK;

		reg |= data->output_sel == 2 ?

				CS4245_A_OUT_SEL_DAC : CS4245_A_OUT_SEL_HIZ;

		cs4245_write_cached(chip, CS4245_SIGNAL_SEL, reg);



		cs4245_write_cached(chip, CS4245_DAC_A_CTRL,

				    data->output_sel ? data->hp_vol_att : 0);

		cs4245_write_cached(chip, CS4245_DAC_B_CTRL,

				    data->output_sel ? data->hp_vol_att : 0);



		oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,

				      data->output_sel == 1 ? GPIO_HP_REAR : 0,

				      GPIO_HP_REAR);

	}

	mutex_unlock(&chip->mutex);

	return changed;

}



static int hp_volume_offset_info(struct snd_kcontrol *ctl,

				 struct snd_ctl_elem_info *info)

{

	static const char *const names[3] = {

		"< 64 ohms", "64-150 ohms", "150-300 ohms"

	};



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

}



static int hp_volume_offset_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);

	if (data->hp_vol_att > 2 * 7)

		value->value.enumerated.item[0] = 0;

	else if (data->hp_vol_att > 0)

		value->value.enumerated.item[0] = 1;

	else

		value->value.enumerated.item[0] = 2;

	mutex_unlock(&chip->mutex);

	return 0;

}



static int hp_volume_offset_put(struct snd_kcontrol *ctl,

				struct snd_ctl_elem_value *value)

{

	static const s8 atts[3] = { 2 * 16, 2 * 7, 0 };

	struct oxygen *chip = ctl->private_data;

	struct dg *data = chip->model_data;

	s8 att;

	int changed;



	if (value->value.enumerated.item[0] > 2)

		return -EINVAL;

	att = atts[value->value.enumerated.item[0]];

	mutex_lock(&chip->mutex);

	changed = att != data->hp_vol_att;

	if (changed) {

		data->hp_vol_att = att;

		if (data->output_sel) {

			cs4245_write_cached(chip, CS4245_DAC_A_CTRL, att);

			cs4245_write_cached(chip, CS4245_DAC_B_CTRL, att);

		}

	}

	mutex_unlock(&chip->mutex);

	return changed;

}



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;



	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) {

			cs4245_write_cached(chip, CS4245_PGA_A_CTRL,

					    data->input_vol[idx][0]);

			cs4245_write_cached(chip, CS4245_PGA_B_CTRL,

					    data->input_vol[idx][1]);

		}

	}

	mutex_unlock(&chip->mutex);

	return changed;

}



static DECLARE_TLV_DB_SCALE(cs4245_pga_db_scale, -1200, 50, 0);



static int input_sel_info(struct snd_kcontrol *ctl,

			  struct snd_ctl_elem_info *info)

{

	static const char *const names[4] = {

		"Mic", "Aux", "Front Mic", "Line"

	};



	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)

{

	static const u8 sel_values[4] = {

		CS4245_SEL_MIC,

		CS4245_SEL_INPUT_1,

		CS4245_SEL_INPUT_2,

		CS4245_SEL_INPUT_4

	};

	struct oxygen *chip = ctl->private_data;

	struct dg *data = chip->model_data;

	int changed;



	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];



		cs4245_write(chip, CS4245_ANALOG_IN,

			     (data->cs4245_shadow[CS4245_ANALOG_IN] &

							~CS4245_SEL_MASK) |

			     sel_values[data->input_sel]);



		cs4245_write_cached(chip, CS4245_PGA_A_CTRL,

				    data->input_vol[data->input_sel][0]);

		cs4245_write_cached(chip, CS4245_PGA_B_CTRL,

				    data->input_vol[data->input_sel][1]);



		oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,

				      data->input_sel ? 0 : GPIO_INPUT_ROUTE,

				      GPIO_INPUT_ROUTE);

	}

	mutex_unlock(&chip->mutex);

	return changed;

}



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)

		cs4245_write(chip, CS4245_ADC_CTRL, reg);

	mutex_unlock(&chip->mutex);

	return changed;

}



#define INPUT_VOLUME(xname, index) { \

	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \

	.name = xname, \

	.info = input_vol_info, \

	.get = input_vol_get, \

	.put = input_vol_put, \

	.tlv = { .p = cs4245_pga_db_scale }, \

	.private_value = index, \

}

static const struct snd_kcontrol_new dg_controls[] = {

	{

		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,

		.name = "Analog Output Playback Enum",

		.info = output_switch_info,

		.get = output_switch_get,

		.put = output_switch_put,

	},

	{

		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,

		.name = "Headphones Impedance Playback Enum",

		.info = hp_volume_offset_info,

		.get = hp_volume_offset_get,

		.put = hp_volume_offset_put,

	},

	INPUT_VOLUME("Mic Capture Volume", 0),

	INPUT_VOLUME("Aux Capture Volume", 1),

	INPUT_VOLUME("Front Mic Capture Volume", 2),

	INPUT_VOLUME("Line Capture Volume", 3),

	{

		.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;



	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;

}



static void dump_cs4245_registers(struct oxygen *chip,

void dump_cs4245_registers(struct oxygen *chip,

				  struct snd_info_buffer *buffer)

{

	struct dg *data = chip->model_data;
@@ -625,30 +299,3 @@ static void dump_cs4245_registers(struct oxygen *chip, 
		snd_iprintf(buffer, " %02x", data->cs4245_shadow[addr]);

	snd_iprintf(buffer, "\n");

}
 


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_2 |

			 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,

};

sound/pci/oxygen/xonar_dg.h

+19 −0
Original line number Diff line number Diff line
@@ -34,6 +34,25 @@ struct dg { 
	u8 hp_vol_att;

};



/* Xonar DG control routines */

int cs4245_write_spi(struct oxygen *chip, u8 reg);

int cs4245_read_spi(struct oxygen *chip, u8 reg);

int cs4245_shadow_control(struct oxygen *chip, enum cs4245_shadow_operation op);

void dg_init(struct oxygen *chip);

void set_cs4245_dac_params(struct oxygen *chip,

				  struct snd_pcm_hw_params *params);

void set_cs4245_adc_params(struct oxygen *chip,

				  struct snd_pcm_hw_params *params);

unsigned int adjust_dg_dac_routing(struct oxygen *chip,

					  unsigned int play_routing);

void dump_cs4245_registers(struct oxygen *chip,

				struct snd_info_buffer *buffer);

void dg_suspend(struct oxygen *chip);

void dg_resume(struct oxygen *chip);

void dg_cleanup(struct oxygen *chip);

void cs4245_write(struct oxygen *chip, unsigned int reg, u8 value);

void cs4245_write_cached(struct oxygen *chip, unsigned int reg, u8 value);



extern struct oxygen_model model_xonar_dg;



#endif

sound/pci/oxygen/xonar_dg_mixer.c

0 → 100644
+381 −0
Original line number Diff line number Diff line 
/*

 * 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"



static int output_switch_info(struct snd_kcontrol *ctl,

			      struct snd_ctl_elem_info *info)

{

	static const char *const names[3] = {

		"Speakers", "Headphones", "FP Headphones"

	};



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

}



static int output_switch_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_switch_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;



	if (value->value.enumerated.item[0] > 2)

		return -EINVAL;



	mutex_lock(&chip->mutex);

	changed = value->value.enumerated.item[0] != data->output_sel;

	if (changed) {

		data->output_sel = value->value.enumerated.item[0];



		reg = data->cs4245_shadow[CS4245_SIGNAL_SEL] &

						~CS4245_A_OUT_SEL_MASK;

		reg |= data->output_sel == 2 ?

				CS4245_A_OUT_SEL_DAC : CS4245_A_OUT_SEL_HIZ;

		cs4245_write_cached(chip, CS4245_SIGNAL_SEL, reg);



		cs4245_write_cached(chip, CS4245_DAC_A_CTRL,

				    data->output_sel ? data->hp_vol_att : 0);

		cs4245_write_cached(chip, CS4245_DAC_B_CTRL,

				    data->output_sel ? data->hp_vol_att : 0);



		oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,

				      data->output_sel == 1 ? GPIO_HP_REAR : 0,

				      GPIO_HP_REAR);

	}

	mutex_unlock(&chip->mutex);

	return changed;

}



static int hp_volume_offset_info(struct snd_kcontrol *ctl,

				 struct snd_ctl_elem_info *info)

{

	static const char *const names[3] = {

		"< 64 ohms", "64-150 ohms", "150-300 ohms"

	};



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

}



static int hp_volume_offset_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);

	if (data->hp_vol_att > 2 * 7)

		value->value.enumerated.item[0] = 0;

	else if (data->hp_vol_att > 0)

		value->value.enumerated.item[0] = 1;

	else

		value->value.enumerated.item[0] = 2;

	mutex_unlock(&chip->mutex);

	return 0;

}



static int hp_volume_offset_put(struct snd_kcontrol *ctl,

				struct snd_ctl_elem_value *value)

{

	static const s8 atts[3] = { 2 * 16, 2 * 7, 0 };

	struct oxygen *chip = ctl->private_data;

	struct dg *data = chip->model_data;

	s8 att;

	int changed;



	if (value->value.enumerated.item[0] > 2)

		return -EINVAL;

	att = atts[value->value.enumerated.item[0]];

	mutex_lock(&chip->mutex);

	changed = att != data->hp_vol_att;

	if (changed) {

		data->hp_vol_att = att;

		if (data->output_sel) {

			cs4245_write_cached(chip, CS4245_DAC_A_CTRL, att);

			cs4245_write_cached(chip, CS4245_DAC_B_CTRL, att);

		}

	}

	mutex_unlock(&chip->mutex);

	return changed;

}



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;



	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) {

			cs4245_write_cached(chip, CS4245_PGA_A_CTRL,

					    data->input_vol[idx][0]);

			cs4245_write_cached(chip, CS4245_PGA_B_CTRL,

					    data->input_vol[idx][1]);

		}

	}

	mutex_unlock(&chip->mutex);

	return changed;

}



static DECLARE_TLV_DB_SCALE(cs4245_pga_db_scale, -1200, 50, 0);



static int input_sel_info(struct snd_kcontrol *ctl,

			  struct snd_ctl_elem_info *info)

{

	static const char *const names[4] = {

		"Mic", "Aux", "Front Mic", "Line"

	};



	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)

{

	static const u8 sel_values[4] = {

		CS4245_SEL_MIC,

		CS4245_SEL_INPUT_1,

		CS4245_SEL_INPUT_2,

		CS4245_SEL_INPUT_4

	};

	struct oxygen *chip = ctl->private_data;

	struct dg *data = chip->model_data;

	int changed;



	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];



		cs4245_write(chip, CS4245_ANALOG_IN,

			     (data->cs4245_shadow[CS4245_ANALOG_IN] &

							~CS4245_SEL_MASK) |

			     sel_values[data->input_sel]);



		cs4245_write_cached(chip, CS4245_PGA_A_CTRL,

				    data->input_vol[data->input_sel][0]);

		cs4245_write_cached(chip, CS4245_PGA_B_CTRL,

				    data->input_vol[data->input_sel][1]);



		oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,

				      data->input_sel ? 0 : GPIO_INPUT_ROUTE,

				      GPIO_INPUT_ROUTE);

	}

	mutex_unlock(&chip->mutex);

	return changed;

}



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)

		cs4245_write(chip, CS4245_ADC_CTRL, reg);

	mutex_unlock(&chip->mutex);

	return changed;

}



#define INPUT_VOLUME(xname, index) { \

	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \

	.name = xname, \

	.info = input_vol_info, \

	.get = input_vol_get, \

	.put = input_vol_put, \

	.tlv = { .p = cs4245_pga_db_scale }, \

	.private_value = index, \

}

static const struct snd_kcontrol_new dg_controls[] = {

	{

		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,

		.name = "Analog Output Playback Enum",

		.info = output_switch_info,

		.get = output_switch_get,

		.put = output_switch_put,

	},

	{

		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,

		.name = "Headphones Impedance Playback Enum",

		.info = hp_volume_offset_info,

		.get = hp_volume_offset_get,

		.put = hp_volume_offset_put,

	},

	INPUT_VOLUME("Mic Capture Volume", 0),

	INPUT_VOLUME("Aux Capture Volume", 1),

	INPUT_VOLUME("Front Mic Capture Volume", 2),

	INPUT_VOLUME("Line Capture Volume", 3),

	{

		.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;



	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_2 |

			 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,

};