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

/*
 * C-Media CMI8788 driver - mixer code
 *
 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
 *
 *
 *  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, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

#include <linux/mutex.h>
#include <sound/ac97_codec.h>
#include <sound/asoundef.h>
#include <sound/control.h>
#include <sound/tlv.h>
#include "oxygen.h"

static int dac_volume_info(struct snd_kcontrol *ctl,
			   struct snd_ctl_elem_info *info)
{
	struct oxygen *chip = ctl->private_data;

	info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	info->count = 8;
	info->value.integer.min = chip->model->dac_minimum_volume;
	info->value.integer.max = 0xff;
	return 0;
}

static int dac_volume_get(struct snd_kcontrol *ctl,
			  struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	unsigned int i;

	mutex_lock(&chip->mutex);
	for (i = 0; i < 8; ++i)
		value->value.integer.value[i] = chip->dac_volume[i];
	mutex_unlock(&chip->mutex);
	return 0;
}

static int dac_volume_put(struct snd_kcontrol *ctl,
			  struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	unsigned int i;
	int changed;

	changed = 0;
	mutex_lock(&chip->mutex);
	for (i = 0; i < 8; ++i)
		if (value->value.integer.value[i] != chip->dac_volume[i]) {
			chip->dac_volume[i] = value->value.integer.value[i];
			changed = 1;
		}
	if (changed)
		chip->model->update_dac_volume(chip);
	mutex_unlock(&chip->mutex);
	return changed;
}

static int dac_mute_get(struct snd_kcontrol *ctl,
			struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;

	mutex_lock(&chip->mutex);
	value->value.integer.value[0] = !chip->dac_mute;
	mutex_unlock(&chip->mutex);
	return 0;
}

static int dac_mute_put(struct snd_kcontrol *ctl,
			  struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	int changed;

	mutex_lock(&chip->mutex);
	changed = !value->value.integer.value[0] != chip->dac_mute;
	if (changed) {
		chip->dac_mute = !value->value.integer.value[0];
		chip->model->update_dac_mute(chip);
	}
	mutex_unlock(&chip->mutex);
	return changed;
}

static int upmix_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
{
	static const char *const names[3] = {
		"Front", "Front+Surround", "Front+Surround+Back"
	};
	info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
	info->count = 1;
	info->value.enumerated.items = 3;
	if (info->value.enumerated.item > 2)
		info->value.enumerated.item = 2;
	strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
	return 0;
}

static int upmix_get(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;

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

void oxygen_update_dac_routing(struct oxygen *chip)
{
	static const unsigned int reg_values[3] = {
		0xe100, /* front <- 0, surround <- 1, center <- 2, back <- 3 */
		0xe000, /* front <- 0, surround <- 0, center <- 2, back <- 3 */
		0x2000  /* front <- 0, surround <- 0, center <- 2, back <- 0 */
	};
	u8 channels;
	unsigned int reg_value;

	channels = oxygen_read8(chip, OXYGEN_PLAY_CHANNELS) &
		OXYGEN_PLAY_CHANNELS_MASK;
	if (channels == OXYGEN_PLAY_CHANNELS_2)
		reg_value = reg_values[chip->dac_routing];
	else if (channels == OXYGEN_PLAY_CHANNELS_8)
		reg_value = 0x6c00; /* surround <- 3, back <- 1 */
	else
		reg_value = 0xe100;
	oxygen_write16_masked(chip, OXYGEN_PLAY_ROUTING, reg_value, 0xff00);
}

static int upmix_put(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	int changed;

	mutex_lock(&chip->mutex);
	changed = value->value.enumerated.item[0] != chip->dac_routing;
	if (changed) {
		chip->dac_routing = min(value->value.enumerated.item[0], 2u);
		spin_lock_irq(&chip->reg_lock);
		oxygen_update_dac_routing(chip);
		spin_unlock_irq(&chip->reg_lock);
	}
	mutex_unlock(&chip->mutex);
	return changed;
}

static int spdif_switch_get(struct snd_kcontrol *ctl,
			    struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;

	mutex_lock(&chip->mutex);
	value->value.integer.value[0] = chip->spdif_playback_enable;
	mutex_unlock(&chip->mutex);
	return 0;
}

static unsigned int oxygen_spdif_rate(unsigned int oxygen_rate)
{
	switch (oxygen_rate) {
	case OXYGEN_RATE_32000:
		return IEC958_AES3_CON_FS_32000 << OXYGEN_SPDIF_CS_RATE_SHIFT;
	case OXYGEN_RATE_44100:
		return IEC958_AES3_CON_FS_44100 << OXYGEN_SPDIF_CS_RATE_SHIFT;
	default: /* OXYGEN_RATE_48000 */
		return IEC958_AES3_CON_FS_48000 << OXYGEN_SPDIF_CS_RATE_SHIFT;
	case OXYGEN_RATE_64000:
		return 0xb << OXYGEN_SPDIF_CS_RATE_SHIFT;
	case OXYGEN_RATE_88200:
		return 0x8 << OXYGEN_SPDIF_CS_RATE_SHIFT;
	case OXYGEN_RATE_96000:
		return 0xa << OXYGEN_SPDIF_CS_RATE_SHIFT;
	case OXYGEN_RATE_176400:
		return 0xc << OXYGEN_SPDIF_CS_RATE_SHIFT;
	case OXYGEN_RATE_192000:
		return 0xe << OXYGEN_SPDIF_CS_RATE_SHIFT;
	}
}

void oxygen_update_spdif_source(struct oxygen *chip)
{
	u32 old_control, new_control;
	u16 old_routing, new_routing;
	unsigned int oxygen_rate;

	old_control = oxygen_read32(chip, OXYGEN_SPDIF_CONTROL);
	old_routing = oxygen_read16(chip, OXYGEN_PLAY_ROUTING);
	if (chip->pcm_active & (1 << PCM_SPDIF)) {
		new_control = old_control | OXYGEN_SPDIF_OUT_ENABLE;
		new_routing = (old_routing & ~0x00e0) | 0x0000;
		oxygen_rate = (old_control >> OXYGEN_SPDIF_OUT_RATE_SHIFT)
			& OXYGEN_I2S_RATE_MASK;
		/* S/PDIF rate was already set by the caller */
	} else if ((chip->pcm_active & (1 << PCM_MULTICH)) &&
		   chip->spdif_playback_enable) {
		new_routing = (old_routing & ~0x00e0) | 0x0020;
		oxygen_rate = oxygen_read16(chip, OXYGEN_I2S_MULTICH_FORMAT)
			& OXYGEN_I2S_RATE_MASK;
		new_control = (old_control & ~OXYGEN_SPDIF_OUT_RATE_MASK) |
			(oxygen_rate << OXYGEN_SPDIF_OUT_RATE_SHIFT) |
			OXYGEN_SPDIF_OUT_ENABLE;
	} else {
		new_control = old_control & ~OXYGEN_SPDIF_OUT_ENABLE;
		new_routing = old_routing;
		oxygen_rate = OXYGEN_RATE_44100;
	}
	if (old_routing != new_routing) {
		oxygen_write32(chip, OXYGEN_SPDIF_CONTROL,
			       new_control & ~OXYGEN_SPDIF_OUT_ENABLE);
		oxygen_write16(chip, OXYGEN_PLAY_ROUTING, new_routing);
	}
	if (new_control & OXYGEN_SPDIF_OUT_ENABLE)
		oxygen_write32(chip, OXYGEN_SPDIF_OUTPUT_BITS,
			       oxygen_spdif_rate(oxygen_rate) |
			       ((chip->pcm_active & (1 << PCM_SPDIF)) ?
				chip->spdif_pcm_bits : chip->spdif_bits));
	oxygen_write32(chip, OXYGEN_SPDIF_CONTROL, new_control);
}

static int spdif_switch_put(struct snd_kcontrol *ctl,
			    struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	int changed;

	mutex_lock(&chip->mutex);
	changed = value->value.integer.value[0] != chip->spdif_playback_enable;
	if (changed) {
		chip->spdif_playback_enable = !!value->value.integer.value[0];
		spin_lock_irq(&chip->reg_lock);
		oxygen_update_spdif_source(chip);
		spin_unlock_irq(&chip->reg_lock);
	}
	mutex_unlock(&chip->mutex);
	return changed;
}

static int spdif_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
{
	info->type = SNDRV_CTL_ELEM_TYPE_IEC958;
	info->count = 1;
	return 0;
}

static void oxygen_to_iec958(u32 bits, struct snd_ctl_elem_value *value)
{
	value->value.iec958.status[0] =
		bits & (OXYGEN_SPDIF_NONAUDIO | OXYGEN_SPDIF_C |
			OXYGEN_SPDIF_PREEMPHASIS);
	value->value.iec958.status[1] = /* category and original */
		bits >> OXYGEN_SPDIF_CATEGORY_SHIFT;
}

static u32 iec958_to_oxygen(struct snd_ctl_elem_value *value)
{
	u32 bits;

	bits = value->value.iec958.status[0] &
		(OXYGEN_SPDIF_NONAUDIO | OXYGEN_SPDIF_C |
		 OXYGEN_SPDIF_PREEMPHASIS);
	bits |= value->value.iec958.status[1] << OXYGEN_SPDIF_CATEGORY_SHIFT;
	if (bits & OXYGEN_SPDIF_NONAUDIO)
		bits |= OXYGEN_SPDIF_V;
	return bits;
}

static inline void write_spdif_bits(struct oxygen *chip, u32 bits)
{
	oxygen_write32_masked(chip, OXYGEN_SPDIF_OUTPUT_BITS, bits,
			      OXYGEN_SPDIF_NONAUDIO |
			      OXYGEN_SPDIF_C |
			      OXYGEN_SPDIF_PREEMPHASIS |
			      OXYGEN_SPDIF_CATEGORY_MASK |
			      OXYGEN_SPDIF_ORIGINAL |
			      OXYGEN_SPDIF_V);
}

static int spdif_default_get(struct snd_kcontrol *ctl,
			     struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;

	mutex_lock(&chip->mutex);
	oxygen_to_iec958(chip->spdif_bits, value);
	mutex_unlock(&chip->mutex);
	return 0;
}

static int spdif_default_put(struct snd_kcontrol *ctl,
			     struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	u32 new_bits;
	int changed;

	new_bits = iec958_to_oxygen(value);
	mutex_lock(&chip->mutex);
	changed = new_bits != chip->spdif_bits;
	if (changed) {
		chip->spdif_bits = new_bits;
		if (!(chip->pcm_active & (1 << PCM_SPDIF)))
			write_spdif_bits(chip, new_bits);
	}
	mutex_unlock(&chip->mutex);
	return changed;
}

static int spdif_mask_get(struct snd_kcontrol *ctl,
			  struct snd_ctl_elem_value *value)
{
	value->value.iec958.status[0] = IEC958_AES0_NONAUDIO |
		IEC958_AES0_CON_NOT_COPYRIGHT | IEC958_AES0_CON_EMPHASIS;
	value->value.iec958.status[1] =
		IEC958_AES1_CON_CATEGORY | IEC958_AES1_CON_ORIGINAL;
	return 0;
}

static int spdif_pcm_get(struct snd_kcontrol *ctl,
			 struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;

	mutex_lock(&chip->mutex);
	oxygen_to_iec958(chip->spdif_pcm_bits, value);
	mutex_unlock(&chip->mutex);
	return 0;
}

static int spdif_pcm_put(struct snd_kcontrol *ctl,
			 struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	u32 new_bits;
	int changed;

	new_bits = iec958_to_oxygen(value);
	mutex_lock(&chip->mutex);
	changed = new_bits != chip->spdif_pcm_bits;
	if (changed) {
		chip->spdif_pcm_bits = new_bits;
		if (chip->pcm_active & (1 << PCM_SPDIF))
			write_spdif_bits(chip, new_bits);
	}
	mutex_unlock(&chip->mutex);
	return changed;
}

static int spdif_input_mask_get(struct snd_kcontrol *ctl,
				struct snd_ctl_elem_value *value)
{
	value->value.iec958.status[0] = 0xff;
	value->value.iec958.status[1] = 0xff;
	value->value.iec958.status[2] = 0xff;
	value->value.iec958.status[3] = 0xff;
	return 0;
}

static int spdif_input_default_get(struct snd_kcontrol *ctl,
				   struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	u32 bits;

	bits = oxygen_read32(chip, OXYGEN_SPDIF_INPUT_BITS);
	value->value.iec958.status[0] = bits;
	value->value.iec958.status[1] = bits >> 8;
	value->value.iec958.status[2] = bits >> 16;
	value->value.iec958.status[3] = bits >> 24;
	return 0;
}

static int ac97_switch_get(struct snd_kcontrol *ctl,
			   struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	unsigned int index = ctl->private_value & 0xff;
	unsigned int bitnr = (ctl->private_value >> 8) & 0xff;
	int invert = ctl->private_value & (1 << 16);
	u16 reg;

	mutex_lock(&chip->mutex);
	reg = oxygen_read_ac97(chip, 0, index);
	mutex_unlock(&chip->mutex);
	if (!(reg & (1 << bitnr)) ^ !invert)
		value->value.integer.value[0] = 1;
	else
		value->value.integer.value[0] = 0;
	return 0;
}

static void ac97_mute_ctl(struct oxygen *chip, unsigned int control)
{
	unsigned int index = chip->controls[control]->private_value & 0xff;
	u16 value;

	value = oxygen_read_ac97(chip, 0, index);
	if (!(value & 0x8000)) {
		oxygen_write_ac97(chip, 0, index, value | 0x8000);
		snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
			       &chip->controls[control]->id);
	}
}

static int ac97_switch_put(struct snd_kcontrol *ctl,
			   struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	unsigned int index = ctl->private_value & 0xff;
	unsigned int bitnr = (ctl->private_value >> 8) & 0xff;
	int invert = ctl->private_value & (1 << 16);
	u16 oldreg, newreg;
	int change;

	mutex_lock(&chip->mutex);
	oldreg = oxygen_read_ac97(chip, 0, index);
	newreg = oldreg;
	if (!value->value.integer.value[0] ^ !invert)
		newreg |= 1 << bitnr;
	else
		newreg &= ~(1 << bitnr);
	change = newreg != oldreg;
	if (change) {
		oxygen_write_ac97(chip, 0, index, newreg);
		if (index == AC97_LINE) {
			oxygen_write_ac97_masked(chip, 0, 0x72,
						 !!(newreg & 0x8000), 0x0001);
			if (!(newreg & 0x8000)) {
				ac97_mute_ctl(chip, CONTROL_MIC_CAPTURE_SWITCH);
				ac97_mute_ctl(chip, CONTROL_CD_CAPTURE_SWITCH);
				ac97_mute_ctl(chip, CONTROL_AUX_CAPTURE_SWITCH);
			}
		} else if ((index == AC97_MIC || index == AC97_CD ||
			    index == AC97_VIDEO || index == AC97_AUX) &&
			   bitnr == 15 && !(newreg & 0x8000)) {
			ac97_mute_ctl(chip, CONTROL_LINE_CAPTURE_SWITCH);
			oxygen_write_ac97_masked(chip, 0, 0x72, 0x0001, 0x0001);
		}
	}
	mutex_unlock(&chip->mutex);
	return change;
}

static int ac97_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 = 0x1f;
	return 0;
}

static int ac97_volume_get(struct snd_kcontrol *ctl,
			   struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	unsigned int index = ctl->private_value;
	u16 reg;

	mutex_lock(&chip->mutex);
	reg = oxygen_read_ac97(chip, 0, index);
	mutex_unlock(&chip->mutex);
	value->value.integer.value[0] = 31 - (reg & 0x1f);
	value->value.integer.value[1] = 31 - ((reg >> 8) & 0x1f);
	return 0;
}

static int ac97_volume_put(struct snd_kcontrol *ctl,
			   struct snd_ctl_elem_value *value)
{
	struct oxygen *chip = ctl->private_data;
	unsigned int index = ctl->private_value;
	u16 oldreg, newreg;
	int change;

	mutex_lock(&chip->mutex);
	oldreg = oxygen_read_ac97(chip, 0, index);
	newreg = oldreg;
	newreg = (newreg & ~0x1f) |
		(31 - (value->value.integer.value[0] & 0x1f));
	newreg = (newreg & ~0x1f00) |
		((31 - (value->value.integer.value[0] & 0x1f)) << 8);
	change = newreg != oldreg;
	if (change)
		oxygen_write_ac97(chip, 0, index, newreg);
	mutex_unlock(&chip->mutex);
	return change;
}

#define AC97_SWITCH(xname, index, bitnr, invert) { \
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
		.name = xname, \
		.info = snd_ctl_boolean_mono_info, \
		.get = ac97_switch_get, \
		.put = ac97_switch_put, \
		.private_value = ((invert) << 16) | ((bitnr) << 8) | (index), \
	}
#define AC97_VOLUME(xname, index) { \
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
		.name = xname, \
		.info = ac97_volume_info, \
		.get = ac97_volume_get, \
		.put = ac97_volume_put, \
		.tlv = { .p = ac97_db_scale, }, \
		.private_value = (index), \
	}

static DECLARE_TLV_DB_SCALE(ac97_db_scale, -3450, 150, 0);

static const struct snd_kcontrol_new controls[] = {
	{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		.name = "Master Playback Volume",
		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
			  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
		.info = dac_volume_info,
		.get = dac_volume_get,
		.put = dac_volume_put,
		.tlv = {
			.p = NULL, /* set later */
		},
	},
	{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		.name = "Master Playback Switch",
		.info = snd_ctl_boolean_mono_info,
		.get = dac_mute_get,
		.put = dac_mute_put,
	},
	{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		.name = "Stereo Upmixing",
		.info = upmix_info,
		.get = upmix_get,
		.put = upmix_put,
	},
	{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
		.info = snd_ctl_boolean_mono_info,
		.get = spdif_switch_get,
		.put = spdif_switch_put,
	},
	{
		.iface = SNDRV_CTL_ELEM_IFACE_PCM,
		.device = 1,
		.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
		.info = spdif_info,
		.get = spdif_default_get,
		.put = spdif_default_put,
	},
	{
		.iface = SNDRV_CTL_ELEM_IFACE_PCM,
		.device = 1,
		.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
		.access = SNDRV_CTL_ELEM_ACCESS_READ,
		.info = spdif_info,
		.get = spdif_mask_get,
	},
	{
		.iface = SNDRV_CTL_ELEM_IFACE_PCM,
		.device = 1,
		.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PCM_STREAM),
		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
			  SNDRV_CTL_ELEM_ACCESS_INACTIVE,
		.info = spdif_info,
		.get = spdif_pcm_get,
		.put = spdif_pcm_put,
	},
	{
		.iface = SNDRV_CTL_ELEM_IFACE_PCM,
		.device = 1,
		.name = SNDRV_CTL_NAME_IEC958("", CAPTURE, MASK),
		.access = SNDRV_CTL_ELEM_ACCESS_READ,
		.info = spdif_info,
		.get = spdif_input_mask_get,
	},
	{
		.iface = SNDRV_CTL_ELEM_IFACE_PCM,
		.device = 1,
		.name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
		.access = SNDRV_CTL_ELEM_ACCESS_READ,
		.info = spdif_info,
		.get = spdif_input_default_get,
	},
};

static const struct snd_kcontrol_new ac97_controls[] = {
	AC97_VOLUME("Mic Capture Volume", AC97_MIC),
	AC97_SWITCH("Mic Capture Switch", AC97_MIC, 15, 1),
	AC97_SWITCH("Mic Boost (+20dB)", AC97_MIC, 6, 0),
	AC97_SWITCH("Line Capture Switch", AC97_LINE, 15, 1),
	AC97_VOLUME("CD Capture Volume", AC97_CD),
	AC97_SWITCH("CD Capture Switch", AC97_CD, 15, 1),
	AC97_VOLUME("Aux Capture Volume", AC97_AUX),
	AC97_SWITCH("Aux Capture Switch", AC97_AUX, 15, 1),
};

static void oxygen_any_ctl_free(struct snd_kcontrol *ctl)
{
	struct oxygen *chip = ctl->private_data;
	unsigned int i;

	/* I'm too lazy to write a function for each control :-) */
	for (i = 0; i < ARRAY_SIZE(chip->controls); ++i)
		chip->controls[i] = NULL;
}

static int add_controls(struct oxygen *chip,
			const struct snd_kcontrol_new controls[],
			unsigned int count)
{
	static const char *const known_ctl_names[CONTROL_COUNT] = {
		[CONTROL_SPDIF_PCM] =
			SNDRV_CTL_NAME_IEC958("", PLAYBACK, PCM_STREAM),
		[CONTROL_SPDIF_INPUT_BITS] =
			SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
		[CONTROL_MIC_CAPTURE_SWITCH] = "Mic Capture Switch",
		[CONTROL_LINE_CAPTURE_SWITCH] = "Line Capture Switch",
		[CONTROL_CD_CAPTURE_SWITCH] = "CD Capture Switch",
		[CONTROL_AUX_CAPTURE_SWITCH] = "Aux Capture Switch",
	};
	unsigned int i, j;
	struct snd_kcontrol *ctl;
	int err;

	for (i = 0; i < count; ++i) {
		ctl = snd_ctl_new1(&controls[i], chip);
		if (!ctl)
			return -ENOMEM;
		if (!strcmp(ctl->id.name, "Master Playback Volume"))
			ctl->tlv.p = chip->model->dac_tlv;
		else if (chip->model->cd_in_from_video_in &&
			 !strncmp(ctl->id.name, "CD Capture ", 11))
			ctl->private_value ^= AC97_CD ^ AC97_VIDEO;
		err = snd_ctl_add(chip->card, ctl);
		if (err < 0)
			return err;
		for (j = 0; j < CONTROL_COUNT; ++j)
			if (!strcmp(ctl->id.name, known_ctl_names[j])) {
				chip->controls[j] = ctl;
				ctl->private_free = oxygen_any_ctl_free;
			}
	}
	return 0;
}

int oxygen_mixer_init(struct oxygen *chip)
{
	int err;

	err = add_controls(chip, controls, ARRAY_SIZE(controls));
	if (err < 0)
		return err;
	if (chip->has_ac97_0) {
		err = add_controls(chip, ac97_controls,
				   ARRAY_SIZE(ac97_controls));
		if (err < 0)
			return err;
	}
	return chip->model->mixer_init ? chip->model->mixer_init(chip) : 0;
}
Commit	Line	Data
d0ce9946 CL	1	/*
	2	* C-Media CMI8788 driver - mixer code
	3	*
	4	* Copyright (c) Clemens Ladisch <clemens@ladisch.de>
	5	*
	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, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*/
	19
d0ce9946 CL	20	#include <linux/mutex.h>
	21	#include <sound/ac97_codec.h>
	22	#include <sound/asoundef.h>
	23	#include <sound/control.h>
	24	#include <sound/tlv.h>
	25	#include "oxygen.h"
	26
	27	static int dac_volume_info(struct snd_kcontrol *ctl,
	28	struct snd_ctl_elem_info *info)
	29	{
	30	struct oxygen *chip = ctl->private_data;
	31
	32	info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	33	info->count = 8;
	34	info->value.integer.min = chip->model->dac_minimum_volume;
	35	info->value.integer.max = 0xff;
	36	return 0;
	37	}
	38
	39	static int dac_volume_get(struct snd_kcontrol *ctl,
	40	struct snd_ctl_elem_value *value)
	41	{
	42	struct oxygen *chip = ctl->private_data;
	43	unsigned int i;
	44
	45	mutex_lock(&chip->mutex);
	46	for (i = 0; i < 8; ++i)
	47	value->value.integer.value[i] = chip->dac_volume[i];
	48	mutex_unlock(&chip->mutex);
	49	return 0;
	50	}
	51
	52	static int dac_volume_put(struct snd_kcontrol *ctl,
	53	struct snd_ctl_elem_value *value)
	54	{
	55	struct oxygen *chip = ctl->private_data;
	56	unsigned int i;
	57	int changed;
	58
	59	changed = 0;
	60	mutex_lock(&chip->mutex);
	61	for (i = 0; i < 8; ++i)
	62	if (value->value.integer.value[i] != chip->dac_volume[i]) {
	63	chip->dac_volume[i] = value->value.integer.value[i];
	64	changed = 1;
	65	}
	66	if (changed)
	67	chip->model->update_dac_volume(chip);
	68	mutex_unlock(&chip->mutex);
	69	return changed;
	70	}
	71
	72	static int dac_mute_get(struct snd_kcontrol *ctl,
	73	struct snd_ctl_elem_value *value)
	74	{
	75	struct oxygen *chip = ctl->private_data;
	76
	77	mutex_lock(&chip->mutex);
	78	value->value.integer.value[0] = !chip->dac_mute;
	79	mutex_unlock(&chip->mutex);
	80	return 0;
	81	}
	82
	83	static int dac_mute_put(struct snd_kcontrol *ctl,
84	struct snd_ctl_elem_value *value)
85	{
86	struct oxygen *chip = ctl->private_data;
87	int changed;
88
89	mutex_lock(&chip->mutex);
90	changed = !value->value.integer.value[0] != chip->dac_mute;
91	if (changed) {
92	chip->dac_mute = !value->value.integer.value[0];
93	chip->model->update_dac_mute(chip);
94	}
95	mutex_unlock(&chip->mutex);
96	return changed;
97	}
98
99	static int upmix_info(struct snd_kcontrol ctl, struct snd_ctl_elem_info info)
100	{
101	static const char *const names[3] = {
7113e958	102	"Front", "Front+Surround", "Front+Surround+Back"
d0ce9946 CL	103	};
	104	info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
	105	info->count = 1;
	106	info->value.enumerated.items = 3;
	107	if (info->value.enumerated.item > 2)
	108	info->value.enumerated.item = 2;
	109	strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
	110	return 0;
	111	}
	112
	113	static int upmix_get(struct snd_kcontrol ctl, struct snd_ctl_elem_value value)
	114	{
	115	struct oxygen *chip = ctl->private_data;
	116
	117	mutex_lock(&chip->mutex);
	118	value->value.enumerated.item[0] = chip->dac_routing;
	119	mutex_unlock(&chip->mutex);
	120	return 0;
	121	}
	122
	123	void oxygen_update_dac_routing(struct oxygen *chip)
	124	{
d0ce9946	125	static const unsigned int reg_values[3] = {
7113e958 CL	126	0xe100, /* front <- 0, surround <- 1, center <- 2, back <- 3 */
	127	0xe000, /* front <- 0, surround <- 0, center <- 2, back <- 3 */
	128	0x2000 /* front <- 0, surround <- 0, center <- 2, back <- 0 */
d0ce9946	129	};
7113e958	130	u8 channels;
d0ce9946 CL	131	unsigned int reg_value;
d0ce9946 CL	132
7113e958 CL	133	channels = oxygen_read8(chip, OXYGEN_PLAY_CHANNELS) &
	134	OXYGEN_PLAY_CHANNELS_MASK;
	135	if (channels == OXYGEN_PLAY_CHANNELS_2)
d0ce9946	136	reg_value = reg_values[chip->dac_routing];
7113e958 CL	137	else if (channels == OXYGEN_PLAY_CHANNELS_8)
7113e958 CL	138	reg_value = 0x6c00; /* surround <- 3, back <- 1 */
d0ce9946	139	else
7113e958	140	reg_value = 0xe100;
d0ce9946 CL	141	oxygen_write16_masked(chip, OXYGEN_PLAY_ROUTING, reg_value, 0xff00);
	142	}
	143
	144	static int upmix_put(struct snd_kcontrol ctl, struct snd_ctl_elem_value value)
	145	{
	146	struct oxygen *chip = ctl->private_data;
	147	int changed;
	148
	149	mutex_lock(&chip->mutex);
	150	changed = value->value.enumerated.item[0] != chip->dac_routing;
	151	if (changed) {
	152	chip->dac_routing = min(value->value.enumerated.item[0], 2u);
	153	spin_lock_irq(&chip->reg_lock);
	154	oxygen_update_dac_routing(chip);
	155	spin_unlock_irq(&chip->reg_lock);
	156	}
	157	mutex_unlock(&chip->mutex);
	158	return changed;
	159	}
	160
	161	static int spdif_switch_get(struct snd_kcontrol *ctl,
	162	struct snd_ctl_elem_value *value)
	163	{
	164	struct oxygen *chip = ctl->private_data;
	165
	166	mutex_lock(&chip->mutex);
	167	value->value.integer.value[0] = chip->spdif_playback_enable;
	168	mutex_unlock(&chip->mutex);
	169	return 0;
	170	}
	171
	172	static unsigned int oxygen_spdif_rate(unsigned int oxygen_rate)
	173	{
	174	switch (oxygen_rate) {
	175	case OXYGEN_RATE_32000:
	176	return IEC958_AES3_CON_FS_32000 << OXYGEN_SPDIF_CS_RATE_SHIFT;
	177	case OXYGEN_RATE_44100:
	178	return IEC958_AES3_CON_FS_44100 << OXYGEN_SPDIF_CS_RATE_SHIFT;
	179	default: /* OXYGEN_RATE_48000 */
	180	return IEC958_AES3_CON_FS_48000 << OXYGEN_SPDIF_CS_RATE_SHIFT;
	181	case OXYGEN_RATE_64000:
	182	return 0xb << OXYGEN_SPDIF_CS_RATE_SHIFT;
	183	case OXYGEN_RATE_88200:
	184	return 0x8 << OXYGEN_SPDIF_CS_RATE_SHIFT;
	185	case OXYGEN_RATE_96000:
	186	return 0xa << OXYGEN_SPDIF_CS_RATE_SHIFT;
	187	case OXYGEN_RATE_176400:
	188	return 0xc << OXYGEN_SPDIF_CS_RATE_SHIFT;
	189	case OXYGEN_RATE_192000:
	190	return 0xe << OXYGEN_SPDIF_CS_RATE_SHIFT;
	191	}
	192	}
	193
	194	void oxygen_update_spdif_source(struct oxygen *chip)
	195	{
	196	u32 old_control, new_control;
	197	u16 old_routing, new_routing;
	198	unsigned int oxygen_rate;
	199
	200	old_control = oxygen_read32(chip, OXYGEN_SPDIF_CONTROL);
	201	old_routing = oxygen_read16(chip, OXYGEN_PLAY_ROUTING);
	202	if (chip->pcm_active & (1 << PCM_SPDIF)) {
	203	new_control = old_control \| OXYGEN_SPDIF_OUT_ENABLE;
	204	new_routing = (old_routing & ~0x00e0) \| 0x0000;
205	oxygen_rate = (old_control >> OXYGEN_SPDIF_OUT_RATE_SHIFT)
206	& OXYGEN_I2S_RATE_MASK;
207	/* S/PDIF rate was already set by the caller */
208	} else if ((chip->pcm_active & (1 << PCM_MULTICH)) &&
209	chip->spdif_playback_enable) {
210	new_routing = (old_routing & ~0x00e0) \| 0x0020;
211	oxygen_rate = oxygen_read16(chip, OXYGEN_I2S_MULTICH_FORMAT)
212	& OXYGEN_I2S_RATE_MASK;
213	new_control = (old_control & ~OXYGEN_SPDIF_OUT_RATE_MASK) \|
214	(oxygen_rate << OXYGEN_SPDIF_OUT_RATE_SHIFT) \|
215	OXYGEN_SPDIF_OUT_ENABLE;
216	} else {
217	new_control = old_control & ~OXYGEN_SPDIF_OUT_ENABLE;
218	new_routing = old_routing;
219	oxygen_rate = OXYGEN_RATE_44100;
220	}
221	if (old_routing != new_routing) {
222	oxygen_write32(chip, OXYGEN_SPDIF_CONTROL,
223	new_control & ~OXYGEN_SPDIF_OUT_ENABLE);
224	oxygen_write16(chip, OXYGEN_PLAY_ROUTING, new_routing);
225	}
226	if (new_control & OXYGEN_SPDIF_OUT_ENABLE)
227	oxygen_write32(chip, OXYGEN_SPDIF_OUTPUT_BITS,
228	oxygen_spdif_rate(oxygen_rate) \|
229	((chip->pcm_active & (1 << PCM_SPDIF)) ?
230	chip->spdif_pcm_bits : chip->spdif_bits));
231	oxygen_write32(chip, OXYGEN_SPDIF_CONTROL, new_control);
232	}
233
234	static int spdif_switch_put(struct snd_kcontrol *ctl,
235	struct snd_ctl_elem_value *value)
236	{
237	struct oxygen *chip = ctl->private_data;
238	int changed;
239
240	mutex_lock(&chip->mutex);
241	changed = value->value.integer.value[0] != chip->spdif_playback_enable;
242	if (changed) {
243	chip->spdif_playback_enable = !!value->value.integer.value[0];
244	spin_lock_irq(&chip->reg_lock);
245	oxygen_update_spdif_source(chip);
246	spin_unlock_irq(&chip->reg_lock);
247	}
248	mutex_unlock(&chip->mutex);
249	return changed;
250	}
251
252	static int spdif_info(struct snd_kcontrol ctl, struct snd_ctl_elem_info info)
253	{
254	info->type = SNDRV_CTL_ELEM_TYPE_IEC958;
255	info->count = 1;
256	return 0;
257	}
258
259	static void oxygen_to_iec958(u32 bits, struct snd_ctl_elem_value *value)
260	{
261	value->value.iec958.status[0] =
262	bits & (OXYGEN_SPDIF_NONAUDIO \| OXYGEN_SPDIF_C \|
263	OXYGEN_SPDIF_PREEMPHASIS);
264	value->value.iec958.status[1] = /* category and original */
265	bits >> OXYGEN_SPDIF_CATEGORY_SHIFT;
266	}
267
268	static u32 iec958_to_oxygen(struct snd_ctl_elem_value *value)
269	{
270	u32 bits;
271
272	bits = value->value.iec958.status[0] &
273	(OXYGEN_SPDIF_NONAUDIO \| OXYGEN_SPDIF_C \|
274	OXYGEN_SPDIF_PREEMPHASIS);
275	bits \|= value->value.iec958.status[1] << OXYGEN_SPDIF_CATEGORY_SHIFT;
276	if (bits & OXYGEN_SPDIF_NONAUDIO)
277	bits \|= OXYGEN_SPDIF_V;
278	return bits;
279	}
280
281	static inline void write_spdif_bits(struct oxygen *chip, u32 bits)
282	{
283	oxygen_write32_masked(chip, OXYGEN_SPDIF_OUTPUT_BITS, bits,
284	OXYGEN_SPDIF_NONAUDIO \|
285	OXYGEN_SPDIF_C \|
286	OXYGEN_SPDIF_PREEMPHASIS \|
287	OXYGEN_SPDIF_CATEGORY_MASK \|
288	OXYGEN_SPDIF_ORIGINAL \|
289	OXYGEN_SPDIF_V);
290	}
291
292	static int spdif_default_get(struct snd_kcontrol *ctl,
293	struct snd_ctl_elem_value *value)
294	{
295	struct oxygen *chip = ctl->private_data;
296
297	mutex_lock(&chip->mutex);
298	oxygen_to_iec958(chip->spdif_bits, value);
299	mutex_unlock(&chip->mutex);
300	return 0;
301	}
302
303	static int spdif_default_put(struct snd_kcontrol *ctl,
304	struct snd_ctl_elem_value *value)
305	{
306	struct oxygen *chip = ctl->private_data;
307	u32 new_bits;
308	int changed;
309
310	new_bits = iec958_to_oxygen(value);
311	mutex_lock(&chip->mutex);
312	changed = new_bits != chip->spdif_bits;
313	if (changed) {
314	chip->spdif_bits = new_bits;
315	if (!(chip->pcm_active & (1 << PCM_SPDIF)))
316	write_spdif_bits(chip, new_bits);
317	}
318	mutex_unlock(&chip->mutex);
319	return changed;
320	}
321
322	static int spdif_mask_get(struct snd_kcontrol *ctl,
323	struct snd_ctl_elem_value *value)
324	{
325	value->value.iec958.status[0] = IEC958_AES0_NONAUDIO \|
326	IEC958_AES0_CON_NOT_COPYRIGHT \| IEC958_AES0_CON_EMPHASIS;
327	value->value.iec958.status[1] =
328	IEC958_AES1_CON_CATEGORY \| IEC958_AES1_CON_ORIGINAL;
329	return 0;
330	}
331
332	static int spdif_pcm_get(struct snd_kcontrol *ctl,
333	struct snd_ctl_elem_value *value)
334	{
335	struct oxygen *chip = ctl->private_data;
336
337	mutex_lock(&chip->mutex);
338	oxygen_to_iec958(chip->spdif_pcm_bits, value);
339	mutex_unlock(&chip->mutex);
340	return 0;
341	}
342
343	static int spdif_pcm_put(struct snd_kcontrol *ctl,
344	struct snd_ctl_elem_value *value)
345	{
346	struct oxygen *chip = ctl->private_data;
347	u32 new_bits;
348	int changed;
349
350	new_bits = iec958_to_oxygen(value);
351	mutex_lock(&chip->mutex);
352	changed = new_bits != chip->spdif_pcm_bits;
353	if (changed) {
354	chip->spdif_pcm_bits = new_bits;
355	if (chip->pcm_active & (1 << PCM_SPDIF))
356	write_spdif_bits(chip, new_bits);
357	}
358	mutex_unlock(&chip->mutex);
359	return changed;
360	}
361
362	static int spdif_input_mask_get(struct snd_kcontrol *ctl,
363	struct snd_ctl_elem_value *value)
364	{
365	value->value.iec958.status[0] = 0xff;
366	value->value.iec958.status[1] = 0xff;
367	value->value.iec958.status[2] = 0xff;
368	value->value.iec958.status[3] = 0xff;
369	return 0;
370	}
371
372	static int spdif_input_default_get(struct snd_kcontrol *ctl,
373	struct snd_ctl_elem_value *value)
374	{
375	struct oxygen *chip = ctl->private_data;
376	u32 bits;
377
378	bits = oxygen_read32(chip, OXYGEN_SPDIF_INPUT_BITS);
379	value->value.iec958.status[0] = bits;
380	value->value.iec958.status[1] = bits >> 8;
381	value->value.iec958.status[2] = bits >> 16;
382	value->value.iec958.status[3] = bits >> 24;
383	return 0;
384	}
385
386	static int ac97_switch_get(struct snd_kcontrol *ctl,
387	struct snd_ctl_elem_value *value)
388	{
389	struct oxygen *chip = ctl->private_data;
390	unsigned int index = ctl->private_value & 0xff;
391	unsigned int bitnr = (ctl->private_value >> 8) & 0xff;
392	int invert = ctl->private_value & (1 << 16);
393	u16 reg;
394
395	mutex_lock(&chip->mutex);
396	reg = oxygen_read_ac97(chip, 0, index);
397	mutex_unlock(&chip->mutex);
398	if (!(reg & (1 << bitnr)) ^ !invert)
399	value->value.integer.value[0] = 1;
400	else
401	value->value.integer.value[0] = 0;
402	return 0;
403	}
404
893e44ba CL	405	static void ac97_mute_ctl(struct oxygen *chip, unsigned int control)
	406	{
	407	unsigned int index = chip->controls[control]->private_value & 0xff;
	408	u16 value;
	409
	410	value = oxygen_read_ac97(chip, 0, index);
	411	if (!(value & 0x8000)) {
	412	oxygen_write_ac97(chip, 0, index, value \| 0x8000);
	413	snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
	414	&chip->controls[control]->id);
	415	}
	416	}
	417
d0ce9946 CL	418	static int ac97_switch_put(struct snd_kcontrol *ctl,
	419	struct snd_ctl_elem_value *value)
	420	{
	421	struct oxygen *chip = ctl->private_data;
	422	unsigned int index = ctl->private_value & 0xff;
	423	unsigned int bitnr = (ctl->private_value >> 8) & 0xff;
	424	int invert = ctl->private_value & (1 << 16);
	425	u16 oldreg, newreg;
	426	int change;
	427
	428	mutex_lock(&chip->mutex);
	429	oldreg = oxygen_read_ac97(chip, 0, index);
	430	newreg = oldreg;
	431	if (!value->value.integer.value[0] ^ !invert)
	432	newreg \|= 1 << bitnr;
	433	else
	434	newreg &= ~(1 << bitnr);
	435	change = newreg != oldreg;
	436	if (change) {
	437	oxygen_write_ac97(chip, 0, index, newreg);
893e44ba	438	if (index == AC97_LINE) {
d0ce9946 CL	439	oxygen_write_ac97_masked(chip, 0, 0x72,
d0ce9946 CL	440	!!(newreg & 0x8000), 0x0001);
893e44ba CL	441	if (!(newreg & 0x8000)) {
	442	ac97_mute_ctl(chip, CONTROL_MIC_CAPTURE_SWITCH);
	443	ac97_mute_ctl(chip, CONTROL_CD_CAPTURE_SWITCH);
	444	ac97_mute_ctl(chip, CONTROL_AUX_CAPTURE_SWITCH);
	445	}
	446	} else if ((index == AC97_MIC \|\| index == AC97_CD \|\|
	447	index == AC97_VIDEO \|\| index == AC97_AUX) &&
	448	bitnr == 15 && !(newreg & 0x8000)) {
	449	ac97_mute_ctl(chip, CONTROL_LINE_CAPTURE_SWITCH);
	450	oxygen_write_ac97_masked(chip, 0, 0x72, 0x0001, 0x0001);
	451	}
d0ce9946 CL	452	}
	453	mutex_unlock(&chip->mutex);
	454	return change;
	455	}
	456
	457	static int ac97_volume_info(struct snd_kcontrol *ctl,
	458	struct snd_ctl_elem_info *info)
	459	{
	460	info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	461	info->count = 2;
	462	info->value.integer.min = 0;
	463	info->value.integer.max = 0x1f;
	464	return 0;
	465	}
	466
	467	static int ac97_volume_get(struct snd_kcontrol *ctl,
	468	struct snd_ctl_elem_value *value)
	469	{
	470	struct oxygen *chip = ctl->private_data;
	471	unsigned int index = ctl->private_value;
	472	u16 reg;
	473
	474	mutex_lock(&chip->mutex);
	475	reg = oxygen_read_ac97(chip, 0, index);
	476	mutex_unlock(&chip->mutex);
	477	value->value.integer.value[0] = 31 - (reg & 0x1f);
	478	value->value.integer.value[1] = 31 - ((reg >> 8) & 0x1f);
	479	return 0;
	480	}
	481
	482	static int ac97_volume_put(struct snd_kcontrol *ctl,
	483	struct snd_ctl_elem_value *value)
	484	{
	485	struct oxygen *chip = ctl->private_data;
	486	unsigned int index = ctl->private_value;
	487	u16 oldreg, newreg;
	488	int change;
	489
	490	mutex_lock(&chip->mutex);
	491	oldreg = oxygen_read_ac97(chip, 0, index);
	492	newreg = oldreg;
	493	newreg = (newreg & ~0x1f) \|
	494	(31 - (value->value.integer.value[0] & 0x1f));
	495	newreg = (newreg & ~0x1f00) \|
	496	((31 - (value->value.integer.value[0] & 0x1f)) << 8);
	497	change = newreg != oldreg;
	498	if (change)
	499	oxygen_write_ac97(chip, 0, index, newreg);
	500	mutex_unlock(&chip->mutex);
	501	return change;
	502	}
	503
	504	#define AC97_SWITCH(xname, index, bitnr, invert) { \
	505	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
	506	.name = xname, \
	507	.info = snd_ctl_boolean_mono_info, \
	508	.get = ac97_switch_get, \
	509	.put = ac97_switch_put, \
	510	.private_value = ((invert) << 16) \| ((bitnr) << 8) \| (index), \
	511	}
	512	#define AC97_VOLUME(xname, index) { \
	513	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
	514	.name = xname, \
	515	.info = ac97_volume_info, \
516	.get = ac97_volume_get, \
517	.put = ac97_volume_put, \
518	.tlv = { .p = ac97_db_scale, }, \
519	.private_value = (index), \
520	}
521
522	static DECLARE_TLV_DB_SCALE(ac97_db_scale, -3450, 150, 0);
523
524	static const struct snd_kcontrol_new controls[] = {
525	{
526	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
fb920b7d	527	.name = "Master Playback Volume",
d0ce9946 CL	528	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE \|
	529	SNDRV_CTL_ELEM_ACCESS_TLV_READ,
	530	.info = dac_volume_info,
	531	.get = dac_volume_get,
	532	.put = dac_volume_put,
	533	.tlv = {
	534	.p = NULL, /* set later */
	535	},
	536	},
	537	{
	538	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
fb920b7d	539	.name = "Master Playback Switch",
d0ce9946 CL	540	.info = snd_ctl_boolean_mono_info,
	541	.get = dac_mute_get,
	542	.put = dac_mute_put,
	543	},
	544	{
	545	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	546	.name = "Stereo Upmixing",
	547	.info = upmix_info,
	548	.get = upmix_get,
	549	.put = upmix_put,
	550	},
	551	{
	552	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	553	.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
	554	.info = snd_ctl_boolean_mono_info,
	555	.get = spdif_switch_get,
	556	.put = spdif_switch_put,
	557	},
	558	{
	559	.iface = SNDRV_CTL_ELEM_IFACE_PCM,
	560	.device = 1,
	561	.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
	562	.info = spdif_info,
	563	.get = spdif_default_get,
	564	.put = spdif_default_put,
	565	},
	566	{
	567	.iface = SNDRV_CTL_ELEM_IFACE_PCM,
	568	.device = 1,
	569	.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
	570	.access = SNDRV_CTL_ELEM_ACCESS_READ,
	571	.info = spdif_info,
	572	.get = spdif_mask_get,
	573	},
	574	{
	575	.iface = SNDRV_CTL_ELEM_IFACE_PCM,
	576	.device = 1,
	577	.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PCM_STREAM),
	578	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE \|
	579	SNDRV_CTL_ELEM_ACCESS_INACTIVE,
	580	.info = spdif_info,
	581	.get = spdif_pcm_get,
	582	.put = spdif_pcm_put,
	583	},
	584	{
	585	.iface = SNDRV_CTL_ELEM_IFACE_PCM,
	586	.device = 1,
	587	.name = SNDRV_CTL_NAME_IEC958("", CAPTURE, MASK),
	588	.access = SNDRV_CTL_ELEM_ACCESS_READ,
	589	.info = spdif_info,
	590	.get = spdif_input_mask_get,
	591	},
	592	{
	593	.iface = SNDRV_CTL_ELEM_IFACE_PCM,
	594	.device = 1,
	595	.name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
	596	.access = SNDRV_CTL_ELEM_ACCESS_READ,
	597	.info = spdif_info,
	598	.get = spdif_input_default_get,
	599	},
31c77643 CL	600	};
	601
	602	static const struct snd_kcontrol_new ac97_controls[] = {
d0ce9946 CL	603	AC97_VOLUME("Mic Capture Volume", AC97_MIC),
	604	AC97_SWITCH("Mic Capture Switch", AC97_MIC, 15, 1),
	605	AC97_SWITCH("Mic Boost (+20dB)", AC97_MIC, 6, 0),
	606	AC97_SWITCH("Line Capture Switch", AC97_LINE, 15, 1),
	607	AC97_VOLUME("CD Capture Volume", AC97_CD),
	608	AC97_SWITCH("CD Capture Switch", AC97_CD, 15, 1),
	609	AC97_VOLUME("Aux Capture Volume", AC97_AUX),
	610	AC97_SWITCH("Aux Capture Switch", AC97_AUX, 15, 1),
	611	};
	612
	613	static void oxygen_any_ctl_free(struct snd_kcontrol *ctl)
	614	{
	615	struct oxygen *chip = ctl->private_data;
01a3affb	616	unsigned int i;
d0ce9946 CL	617
d0ce9946 CL	618	/* I'm too lazy to write a function for each control :-) */
01a3affb CL	619	for (i = 0; i < ARRAY_SIZE(chip->controls); ++i)
01a3affb CL	620	chip->controls[i] = NULL;
d0ce9946 CL	621	}
d0ce9946 CL	622
31c77643 CL	623	static int add_controls(struct oxygen *chip,
	624	const struct snd_kcontrol_new controls[],
	625	unsigned int count)
d0ce9946	626	{
01a3affb CL	627	static const char *const known_ctl_names[CONTROL_COUNT] = {
	628	[CONTROL_SPDIF_PCM] =
	629	SNDRV_CTL_NAME_IEC958("", PLAYBACK, PCM_STREAM),
	630	[CONTROL_SPDIF_INPUT_BITS] =
	631	SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
893e44ba CL	632	[CONTROL_MIC_CAPTURE_SWITCH] = "Mic Capture Switch",
	633	[CONTROL_LINE_CAPTURE_SWITCH] = "Line Capture Switch",
	634	[CONTROL_CD_CAPTURE_SWITCH] = "CD Capture Switch",
	635	[CONTROL_AUX_CAPTURE_SWITCH] = "Aux Capture Switch",
01a3affb CL	636	};
01a3affb CL	637	unsigned int i, j;
d0ce9946 CL	638	struct snd_kcontrol *ctl;
	639	int err;
	640
31c77643	641	for (i = 0; i < count; ++i) {
d0ce9946 CL	642	ctl = snd_ctl_new1(&controls[i], chip);
	643	if (!ctl)
	644	return -ENOMEM;
fb920b7d	645	if (!strcmp(ctl->id.name, "Master Playback Volume"))
d0ce9946 CL	646	ctl->tlv.p = chip->model->dac_tlv;
	647	else if (chip->model->cd_in_from_video_in &&
	648	!strncmp(ctl->id.name, "CD Capture ", 11))
	649	ctl->private_value ^= AC97_CD ^ AC97_VIDEO;
	650	err = snd_ctl_add(chip->card, ctl);
	651	if (err < 0)
	652	return err;
01a3affb CL	653	for (j = 0; j < CONTROL_COUNT; ++j)
	654	if (!strcmp(ctl->id.name, known_ctl_names[j])) {
	655	chip->controls[j] = ctl;
	656	ctl->private_free = oxygen_any_ctl_free;
	657	}
d0ce9946	658	}
31c77643 CL	659	return 0;
	660	}
	661
	662	int oxygen_mixer_init(struct oxygen *chip)
	663	{
	664	int err;
	665
	666	err = add_controls(chip, controls, ARRAY_SIZE(controls));
	667	if (err < 0)
	668	return err;
	669	if (chip->has_ac97_0) {
	670	err = add_controls(chip, ac97_controls,
	671	ARRAY_SIZE(ac97_controls));
	672	if (err < 0)
	673	return err;
	674	}
d0ce9946 CL	675	return chip->model->mixer_init ? chip->model->mixer_init(chip) : 0;
d0ce9946 CL	676	}