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

Commit 9e298f44 authored by Takashi Iwai's avatar Takashi Iwai
Browse files

Merge branch 'topic/oxygen' into topic/hda

parents 2f703e7a 62428f7b

sound/pci/oxygen/Makefile

+2 −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-hifier-objs := hifier.o

snd-oxygen-objs := oxygen.o

snd-virtuoso-objs := virtuoso.o

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

	xonar_pcm179x.o xonar_cs43xx.o xonar_hdmi.o



obj-$(CONFIG_SND_OXYGEN_LIB) += snd-oxygen-lib.o

obj-$(CONFIG_SND_HIFIER) += snd-hifier.o

sound/pci/oxygen/cs2000.h

0 → 100644
+83 −0
Original line number Diff line number Diff line 
#ifndef CS2000_H_INCLUDED

#define CS2000_H_INCLUDED



#define CS2000_DEV_ID		0x01

#define CS2000_DEV_CTRL		0x02

#define CS2000_DEV_CFG_1	0x03

#define CS2000_DEV_CFG_2	0x04

#define CS2000_GLOBAL_CFG	0x05

#define CS2000_RATIO_0		0x06 /* 32 bits, big endian */

#define CS2000_RATIO_1		0x0a

#define CS2000_RATIO_2		0x0e

#define CS2000_RATIO_3		0x12

#define CS2000_FUN_CFG_1	0x16

#define CS2000_FUN_CFG_2	0x17

#define CS2000_FUN_CFG_3	0x1e



/* DEV_ID */

#define CS2000_DEVICE_MASK		0xf8

#define CS2000_REVISION_MASK		0x07



/* DEV_CTRL */

#define CS2000_UNLOCK			0x80

#define CS2000_AUX_OUT_DIS		0x02

#define CS2000_CLK_OUT_DIS		0x01



/* DEV_CFG_1 */

#define CS2000_R_MOD_SEL_MASK		0xe0

#define CS2000_R_MOD_SEL_1		0x00

#define CS2000_R_MOD_SEL_2		0x20

#define CS2000_R_MOD_SEL_4		0x40

#define CS2000_R_MOD_SEL_8		0x60

#define CS2000_R_MOD_SEL_1_2		0x80

#define CS2000_R_MOD_SEL_1_4		0xa0

#define CS2000_R_MOD_SEL_1_8		0xc0

#define CS2000_R_MOD_SEL_1_16		0xe0

#define CS2000_R_SEL_MASK		0x18

#define CS2000_R_SEL_SHIFT		3

#define CS2000_AUX_OUT_SRC_MASK		0x06

#define CS2000_AUX_OUT_SRC_REF_CLK	0x00

#define CS2000_AUX_OUT_SRC_CLK_IN	0x02

#define CS2000_AUX_OUT_SRC_CLK_OUT	0x04

#define CS2000_AUX_OUT_SRC_PLL_LOCK	0x06

#define CS2000_EN_DEV_CFG_1		0x01



/* DEV_CFG_2 */

#define CS2000_LOCK_CLK_MASK		0x06

#define CS2000_LOCK_CLK_SHIFT		1

#define CS2000_FRAC_N_SRC_MASK		0x01

#define CS2000_FRAC_N_SRC_STATIC	0x00

#define CS2000_FRAC_N_SRC_DYNAMIC	0x01



/* GLOBAL_CFG */

#define CS2000_FREEZE			0x08

#define CS2000_EN_DEV_CFG_2		0x01



/* FUN_CFG_1 */

#define CS2000_CLK_SKIP_EN		0x80

#define CS2000_AUX_LOCK_CFG_MASK	0x40

#define CS2000_AUX_LOCK_CFG_PP_HIGH	0x00

#define CS2000_AUX_LOCK_CFG_OD_LOW	0x40

#define CS2000_REF_CLK_DIV_MASK		0x18

#define CS2000_REF_CLK_DIV_4		0x00

#define CS2000_REF_CLK_DIV_2		0x08

#define CS2000_REF_CLK_DIV_1		0x10



/* FUN_CFG_2 */

#define CS2000_CLK_OUT_UNL		0x10

#define CS2000_L_F_RATIO_CFG_MASK	0x08

#define CS2000_L_F_RATIO_CFG_20_12	0x00

#define CS2000_L_F_RATIO_CFG_12_20	0x08



/* FUN_CFG_3 */

#define CS2000_CLK_IN_BW_MASK		0x70

#define CS2000_CLK_IN_BW_1		0x00

#define CS2000_CLK_IN_BW_2		0x10

#define CS2000_CLK_IN_BW_4		0x20

#define CS2000_CLK_IN_BW_8		0x30

#define CS2000_CLK_IN_BW_16		0x40

#define CS2000_CLK_IN_BW_32		0x50

#define CS2000_CLK_IN_BW_64		0x60

#define CS2000_CLK_IN_BW_128		0x70



#endif

sound/pci/oxygen/hifier.c

+38 −23
Original line number Diff line number Diff line
@@ -17,6 +17,12 @@ 
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA

 */



/*

 * CMI8788:

 *

 * SPI 0 -> AK4396

 */



#include <linux/delay.h>

#include <linux/pci.h>

#include <sound/control.h>
@@ -51,23 +57,28 @@ static struct pci_device_id hifier_ids[] __devinitdata = { 
MODULE_DEVICE_TABLE(pci, hifier_ids);



struct hifier_data {

	u8 ak4396_ctl2;

	u8 ak4396_regs[5];

};



static void ak4396_write(struct oxygen *chip, u8 reg, u8 value)

{

	struct hifier_data *data = chip->model_data;



	oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER  |

			 OXYGEN_SPI_DATA_LENGTH_2 |

			 OXYGEN_SPI_CLOCK_160 |

			 (0 << OXYGEN_SPI_CODEC_SHIFT) |

			 OXYGEN_SPI_CEN_LATCH_CLOCK_HI,

			 AK4396_WRITE | (reg << 8) | value);

	data->ak4396_regs[reg] = value;

}



static void update_ak4396_volume(struct oxygen *chip)

static void ak4396_write_cached(struct oxygen *chip, u8 reg, u8 value)

{

	ak4396_write(chip, AK4396_LCH_ATT, chip->dac_volume[0]);

	ak4396_write(chip, AK4396_RCH_ATT, chip->dac_volume[1]);

	struct hifier_data *data = chip->model_data;



	if (value != data->ak4396_regs[reg])

		ak4396_write(chip, reg, value);

}



static void hifier_registers_init(struct oxygen *chip)
@@ -75,16 +86,19 @@ static void hifier_registers_init(struct oxygen *chip) 
	struct hifier_data *data = chip->model_data;



	ak4396_write(chip, AK4396_CONTROL_1, AK4396_DIF_24_MSB | AK4396_RSTN);

	ak4396_write(chip, AK4396_CONTROL_2, data->ak4396_ctl2);

	ak4396_write(chip, AK4396_CONTROL_2,

		     data->ak4396_regs[AK4396_CONTROL_2]);

	ak4396_write(chip, AK4396_CONTROL_3, AK4396_PCM);

	update_ak4396_volume(chip);

	ak4396_write(chip, AK4396_LCH_ATT, chip->dac_volume[0]);

	ak4396_write(chip, AK4396_RCH_ATT, chip->dac_volume[1]);

}



static void hifier_init(struct oxygen *chip)

{

	struct hifier_data *data = chip->model_data;



	data->ak4396_ctl2 = AK4396_SMUTE | AK4396_DEM_OFF | AK4396_DFS_NORMAL;

	data->ak4396_regs[AK4396_CONTROL_2] =

		AK4396_SMUTE | AK4396_DEM_OFF | AK4396_DFS_NORMAL;

	hifier_registers_init(chip);



	snd_component_add(chip->card, "AK4396");
@@ -106,20 +120,29 @@ static void set_ak4396_params(struct oxygen *chip, 
	struct hifier_data *data = chip->model_data;

	u8 value;



	value = data->ak4396_ctl2 & ~AK4396_DFS_MASK;

	value = data->ak4396_regs[AK4396_CONTROL_2] & ~AK4396_DFS_MASK;

	if (params_rate(params) <= 54000)

		value |= AK4396_DFS_NORMAL;

	else if (params_rate(params) <= 108000)

		value |= AK4396_DFS_DOUBLE;

	else

		value |= AK4396_DFS_QUAD;

	data->ak4396_ctl2 = value;



	msleep(1); /* wait for the new MCLK to become stable */



	ak4396_write(chip, AK4396_CONTROL_1, AK4396_DIF_24_MSB);

	if (value != data->ak4396_regs[AK4396_CONTROL_2]) {

		ak4396_write(chip, AK4396_CONTROL_1,

			     AK4396_DIF_24_MSB);

		ak4396_write(chip, AK4396_CONTROL_2, value);

	ak4396_write(chip, AK4396_CONTROL_1, AK4396_DIF_24_MSB | AK4396_RSTN);

		ak4396_write(chip, AK4396_CONTROL_1,

			     AK4396_DIF_24_MSB | AK4396_RSTN);

	}

}



static void update_ak4396_volume(struct oxygen *chip)

{

	ak4396_write_cached(chip, AK4396_LCH_ATT, chip->dac_volume[0]);

	ak4396_write_cached(chip, AK4396_RCH_ATT, chip->dac_volume[1]);

}



static void update_ak4396_mute(struct oxygen *chip)
@@ -127,11 +150,10 @@ static void update_ak4396_mute(struct oxygen *chip) 
	struct hifier_data *data = chip->model_data;

	u8 value;



	value = data->ak4396_ctl2 & ~AK4396_SMUTE;

	value = data->ak4396_regs[AK4396_CONTROL_2] & ~AK4396_SMUTE;

	if (chip->dac_mute)

		value |= AK4396_SMUTE;

	data->ak4396_ctl2 = value;

	ak4396_write(chip, AK4396_CONTROL_2, value);

	ak4396_write_cached(chip, AK4396_CONTROL_2, value);

}



static void set_cs5340_params(struct oxygen *chip,
@@ -141,21 +163,14 @@ static void set_cs5340_params(struct oxygen *chip, 


static const DECLARE_TLV_DB_LINEAR(ak4396_db_scale, TLV_DB_GAIN_MUTE, 0);



static int hifier_control_filter(struct snd_kcontrol_new *template)

{

	if (!strcmp(template->name, "Stereo Upmixing"))

		return 1; /* stereo only - we don't need upmixing */

	return 0;

}



static const struct oxygen_model model_hifier = {

	.shortname = "C-Media CMI8787",

	.longname = "C-Media Oxygen HD Audio",

	.chip = "CMI8788",

	.init = hifier_init,

	.control_filter = hifier_control_filter,

	.cleanup = hifier_cleanup,

	.resume = hifier_resume,

	.get_i2s_mclk = oxygen_default_i2s_mclk,

	.set_dac_params = set_ak4396_params,

	.set_adc_params = set_cs5340_params,

	.update_dac_volume = update_ak4396_volume,

sound/pci/oxygen/oxygen.c

+199 −49
Original line number Diff line number Diff line
@@ -18,6 +18,8 @@ 
 */



/*

 * CMI8788:

 *

 * SPI 0 -> 1st AK4396 (front)

 * SPI 1 -> 2nd AK4396 (surround)

 * SPI 2 -> 3rd AK4396 (center/LFE)
@@ -27,6 +29,10 @@ 
 * GPIO 0 -> DFS0 of AK5385

 * GPIO 1 -> DFS1 of AK5385

 * GPIO 8 -> enable headphone amplifier on HT-Omega models

 *

 * CM9780:

 *

 * GPO 0 -> route line-in (0) or AC97 output (1) to ADC input

 */



#include <linux/delay.h>
@@ -91,8 +97,8 @@ MODULE_DEVICE_TABLE(pci, oxygen_ids); 
#define GPIO_CLARO_HP		0x0100



struct generic_data {

	u8 ak4396_ctl2;

	u16 saved_wm8785_registers[2];

	u8 ak4396_regs[4][5];

	u16 wm8785_regs[3];

};



static void ak4396_write(struct oxygen *chip, unsigned int codec,
@@ -102,12 +108,24 @@ static void ak4396_write(struct oxygen *chip, unsigned int codec, 
	static const u8 codec_spi_map[4] = {

		0, 1, 2, 4

	};

	struct generic_data *data = chip->model_data;



	oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER |

			 OXYGEN_SPI_DATA_LENGTH_2 |

			 OXYGEN_SPI_CLOCK_160 |

			 (codec_spi_map[codec] << OXYGEN_SPI_CODEC_SHIFT) |

			 OXYGEN_SPI_CEN_LATCH_CLOCK_HI,

			 AK4396_WRITE | (reg << 8) | value);

	data->ak4396_regs[codec][reg] = value;

}



static void ak4396_write_cached(struct oxygen *chip, unsigned int codec,

				u8 reg, u8 value)

{

	struct generic_data *data = chip->model_data;



	if (value != data->ak4396_regs[codec][reg])

		ak4396_write(chip, codec, reg, value);

}



static void wm8785_write(struct oxygen *chip, u8 reg, unsigned int value)
@@ -120,20 +138,8 @@ static void wm8785_write(struct oxygen *chip, u8 reg, unsigned int value) 
			 (3 << OXYGEN_SPI_CODEC_SHIFT) |

			 OXYGEN_SPI_CEN_LATCH_CLOCK_LO,

			 (reg << 9) | value);

	if (reg < ARRAY_SIZE(data->saved_wm8785_registers))

		data->saved_wm8785_registers[reg] = value;

}



static void update_ak4396_volume(struct oxygen *chip)

{

	unsigned int i;



	for (i = 0; i < 4; ++i) {

		ak4396_write(chip, i,

			     AK4396_LCH_ATT, chip->dac_volume[i * 2]);

		ak4396_write(chip, i,

			     AK4396_RCH_ATT, chip->dac_volume[i * 2 + 1]);

	}

	if (reg < ARRAY_SIZE(data->wm8785_regs))

		data->wm8785_regs[reg] = value;

}



static void ak4396_registers_init(struct oxygen *chip)
@@ -142,21 +148,25 @@ static void ak4396_registers_init(struct oxygen *chip) 
	unsigned int i;



	for (i = 0; i < 4; ++i) {

		ak4396_write(chip, i,

			     AK4396_CONTROL_1, AK4396_DIF_24_MSB | AK4396_RSTN);

		ak4396_write(chip, i,

			     AK4396_CONTROL_2, data->ak4396_ctl2);

		ak4396_write(chip, i,

			     AK4396_CONTROL_3, AK4396_PCM);

		ak4396_write(chip, i, AK4396_CONTROL_1,

			     AK4396_DIF_24_MSB | AK4396_RSTN);

		ak4396_write(chip, i, AK4396_CONTROL_2,

			     data->ak4396_regs[0][AK4396_CONTROL_2]);

		ak4396_write(chip, i, AK4396_CONTROL_3,

			     AK4396_PCM);

		ak4396_write(chip, i, AK4396_LCH_ATT,

			     chip->dac_volume[i * 2]);

		ak4396_write(chip, i, AK4396_RCH_ATT,

			     chip->dac_volume[i * 2 + 1]);

	}

	update_ak4396_volume(chip);

}



static void ak4396_init(struct oxygen *chip)

{

	struct generic_data *data = chip->model_data;



	data->ak4396_ctl2 = AK4396_SMUTE | AK4396_DEM_OFF | AK4396_DFS_NORMAL;

	data->ak4396_regs[0][AK4396_CONTROL_2] =

		AK4396_SMUTE | AK4396_DEM_OFF | AK4396_DFS_NORMAL;

	ak4396_registers_init(chip);

	snd_component_add(chip->card, "AK4396");

}
@@ -173,17 +183,17 @@ static void wm8785_registers_init(struct oxygen *chip) 
	struct generic_data *data = chip->model_data;



	wm8785_write(chip, WM8785_R7, 0);

	wm8785_write(chip, WM8785_R0, data->saved_wm8785_registers[0]);

	wm8785_write(chip, WM8785_R1, data->saved_wm8785_registers[1]);

	wm8785_write(chip, WM8785_R0, data->wm8785_regs[0]);

	wm8785_write(chip, WM8785_R2, data->wm8785_regs[2]);

}



static void wm8785_init(struct oxygen *chip)

{

	struct generic_data *data = chip->model_data;



	data->saved_wm8785_registers[0] = WM8785_MCR_SLAVE |

		WM8785_OSR_SINGLE | WM8785_FORMAT_LJUST;

	data->saved_wm8785_registers[1] = WM8785_WL_24;

	data->wm8785_regs[0] =

		WM8785_MCR_SLAVE | WM8785_OSR_SINGLE | WM8785_FORMAT_LJUST;

	data->wm8785_regs[2] = WM8785_HPFR | WM8785_HPFL;

	wm8785_registers_init(chip);

	snd_component_add(chip->card, "WM8785");

}
@@ -264,24 +274,36 @@ static void set_ak4396_params(struct oxygen *chip, 
	unsigned int i;

	u8 value;



	value = data->ak4396_ctl2 & ~AK4396_DFS_MASK;

	value = data->ak4396_regs[0][AK4396_CONTROL_2] & ~AK4396_DFS_MASK;

	if (params_rate(params) <= 54000)

		value |= AK4396_DFS_NORMAL;

	else if (params_rate(params) <= 108000)

		value |= AK4396_DFS_DOUBLE;

	else

		value |= AK4396_DFS_QUAD;

	data->ak4396_ctl2 = value;



	msleep(1); /* wait for the new MCLK to become stable */



	if (value != data->ak4396_regs[0][AK4396_CONTROL_2]) {

		for (i = 0; i < 4; ++i) {

			ak4396_write(chip, i, AK4396_CONTROL_1,

				     AK4396_DIF_24_MSB);

			ak4396_write(chip, i, AK4396_CONTROL_2, value);

			ak4396_write(chip, i, AK4396_CONTROL_1,

				     AK4396_DIF_24_MSB | AK4396_RSTN);

		}

	}

}



static void update_ak4396_volume(struct oxygen *chip)

{

	unsigned int i;



	for (i = 0; i < 4; ++i) {

		ak4396_write(chip, i,

			     AK4396_CONTROL_1, AK4396_DIF_24_MSB);

		ak4396_write(chip, i,

			     AK4396_CONTROL_2, value);

		ak4396_write(chip, i,

			     AK4396_CONTROL_1, AK4396_DIF_24_MSB | AK4396_RSTN);

		ak4396_write_cached(chip, i, AK4396_LCH_ATT,

				    chip->dac_volume[i * 2]);

		ak4396_write_cached(chip, i, AK4396_RCH_ATT,

				    chip->dac_volume[i * 2 + 1]);

	}

}
@@ -291,21 +313,19 @@ static void update_ak4396_mute(struct oxygen *chip) 
	unsigned int i;

	u8 value;



	value = data->ak4396_ctl2 & ~AK4396_SMUTE;

	value = data->ak4396_regs[0][AK4396_CONTROL_2] & ~AK4396_SMUTE;

	if (chip->dac_mute)

		value |= AK4396_SMUTE;

	data->ak4396_ctl2 = value;

	for (i = 0; i < 4; ++i)

		ak4396_write(chip, i, AK4396_CONTROL_2, value);

		ak4396_write_cached(chip, i, AK4396_CONTROL_2, value);

}



static void set_wm8785_params(struct oxygen *chip,

			      struct snd_pcm_hw_params *params)

{

	struct generic_data *data = chip->model_data;

	unsigned int value;



	wm8785_write(chip, WM8785_R7, 0);



	value = WM8785_MCR_SLAVE | WM8785_FORMAT_LJUST;

	if (params_rate(params) <= 48000)

		value |= WM8785_OSR_SINGLE;
@@ -313,13 +333,11 @@ static void set_wm8785_params(struct oxygen *chip, 
		value |= WM8785_OSR_DOUBLE;

	else

		value |= WM8785_OSR_QUAD;

	if (value != data->wm8785_regs[0]) {

		wm8785_write(chip, WM8785_R7, 0);

		wm8785_write(chip, WM8785_R0, value);



	if (snd_pcm_format_width(params_format(params)) <= 16)

		value = WM8785_WL_16;

	else

		value = WM8785_WL_24;

	wm8785_write(chip, WM8785_R1, value);

		wm8785_write(chip, WM8785_R2, data->wm8785_regs[2]);

	}

}



static void set_ak5385_params(struct oxygen *chip,
@@ -337,6 +355,134 @@ static void set_ak5385_params(struct oxygen *chip, 
			      value, GPIO_AK5385_DFS_MASK);

}



static int rolloff_info(struct snd_kcontrol *ctl,

			struct snd_ctl_elem_info *info)

{

	static const char *const names[2] = {

		"Sharp Roll-off", "Slow Roll-off"

	};



	info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;

	info->count = 1;

	info->value.enumerated.items = 2;

	if (info->value.enumerated.item >= 2)

		info->value.enumerated.item = 1;

	strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);

	return 0;

}



static int rolloff_get(struct snd_kcontrol *ctl,

		       struct snd_ctl_elem_value *value)

{

	struct oxygen *chip = ctl->private_data;

	struct generic_data *data = chip->model_data;



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

		(data->ak4396_regs[0][AK4396_CONTROL_2] & AK4396_SLOW) != 0;

	return 0;

}



static int rolloff_put(struct snd_kcontrol *ctl,

		       struct snd_ctl_elem_value *value)

{

	struct oxygen *chip = ctl->private_data;

	struct generic_data *data = chip->model_data;

	unsigned int i;

	int changed;

	u8 reg;



	mutex_lock(&chip->mutex);

	reg = data->ak4396_regs[0][AK4396_CONTROL_2];

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

		reg |= AK4396_SLOW;

	else

		reg &= ~AK4396_SLOW;

	changed = reg != data->ak4396_regs[0][AK4396_CONTROL_2];

	if (changed) {

		for (i = 0; i < 4; ++i)

			ak4396_write(chip, i, AK4396_CONTROL_2, reg);

	}

	mutex_unlock(&chip->mutex);

	return changed;

}



static const struct snd_kcontrol_new rolloff_control = {

	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,

	.name = "DAC Filter Playback Enum",

	.info = rolloff_info,

	.get = rolloff_get,

	.put = rolloff_put,

};



static int hpf_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)

{

	static const char *const names[2] = {

		"None", "High-pass Filter"

	};



	info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;

	info->count = 1;

	info->value.enumerated.items = 2;

	if (info->value.enumerated.item >= 2)

		info->value.enumerated.item = 1;

	strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);

	return 0;

}



static int hpf_get(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)

{

	struct oxygen *chip = ctl->private_data;

	struct generic_data *data = chip->model_data;



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

		(data->wm8785_regs[WM8785_R2] & WM8785_HPFR) != 0;

	return 0;

}



static int hpf_put(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)

{

	struct oxygen *chip = ctl->private_data;

	struct generic_data *data = chip->model_data;

	unsigned int reg;

	int changed;



	mutex_lock(&chip->mutex);

	reg = data->wm8785_regs[WM8785_R2] & ~(WM8785_HPFR | WM8785_HPFL);

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

		reg |= WM8785_HPFR | WM8785_HPFL;

	changed = reg != data->wm8785_regs[WM8785_R2];

	if (changed)

		wm8785_write(chip, WM8785_R2, reg);

	mutex_unlock(&chip->mutex);

	return changed;

}



static const struct snd_kcontrol_new hpf_control = {

	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,

	.name = "ADC Filter Capture Enum",

	.info = hpf_info,

	.get = hpf_get,

	.put = hpf_put,

};



static int generic_mixer_init(struct oxygen *chip)

{

	return snd_ctl_add(chip->card, snd_ctl_new1(&rolloff_control, chip));

}



static int generic_wm8785_mixer_init(struct oxygen *chip)

{

	int err;



	err = generic_mixer_init(chip);

	if (err < 0)

		return err;

	err = snd_ctl_add(chip->card, snd_ctl_new1(&hpf_control, chip));

	if (err < 0)

		return err;

	return 0;

}



static const DECLARE_TLV_DB_LINEAR(ak4396_db_scale, TLV_DB_GAIN_MUTE, 0);



static const struct oxygen_model model_generic = {
@@ -344,8 +490,10 @@ static const struct oxygen_model model_generic = { 
	.longname = "C-Media Oxygen HD Audio",

	.chip = "CMI8788",

	.init = generic_init,

	.mixer_init = generic_wm8785_mixer_init,

	.cleanup = generic_cleanup,

	.resume = generic_resume,

	.get_i2s_mclk = oxygen_default_i2s_mclk,

	.set_dac_params = set_ak4396_params,

	.set_adc_params = set_wm8785_params,

	.update_dac_volume = update_ak4396_volume,
@@ -374,6 +522,7 @@ static int __devinit get_oxygen_model(struct oxygen *chip, 
	switch (id->driver_data) {

	case MODEL_MERIDIAN:

		chip->model.init = meridian_init;

		chip->model.mixer_init = generic_mixer_init;

		chip->model.resume = meridian_resume;

		chip->model.set_adc_params = set_ak5385_params;

		chip->model.device_config = PLAYBACK_0_TO_I2S |
@@ -389,6 +538,7 @@ static int __devinit get_oxygen_model(struct oxygen *chip, 
		break;

	case MODEL_CLARO_HALO:

		chip->model.init = claro_halo_init;

		chip->model.mixer_init = generic_mixer_init;

		chip->model.cleanup = claro_cleanup;

		chip->model.suspend = claro_suspend;

		chip->model.resume = claro_resume;

sound/pci/oxygen/oxygen.h

+5 −0
Original line number Diff line number Diff line
@@ -78,12 +78,15 @@ struct oxygen_model { 
	void (*resume)(struct oxygen *chip);

	void (*pcm_hardware_filter)(unsigned int channel,

				    struct snd_pcm_hardware *hardware);

	unsigned int (*get_i2s_mclk)(struct oxygen *chip, unsigned int channel,

				     struct snd_pcm_hw_params *hw_params);

	void (*set_dac_params)(struct oxygen *chip,

			       struct snd_pcm_hw_params *params);

	void (*set_adc_params)(struct oxygen *chip,

			       struct snd_pcm_hw_params *params);

	void (*update_dac_volume)(struct oxygen *chip);

	void (*update_dac_mute)(struct oxygen *chip);

	void (*update_center_lfe_mix)(struct oxygen *chip, bool mixed);

	void (*gpio_changed)(struct oxygen *chip);

	void (*uart_input)(struct oxygen *chip);

	void (*ac97_switch)(struct oxygen *chip,
@@ -162,6 +165,8 @@ void oxygen_update_spdif_source(struct oxygen *chip); 
/* oxygen_pcm.c */



int oxygen_pcm_init(struct oxygen *chip);

unsigned int oxygen_default_i2s_mclk(struct oxygen *chip, unsigned int channel,

				     struct snd_pcm_hw_params *hw_params);



/* oxygen_io.c */