[linux-2.6-block.git] / sound / isa / msnd / msnd_pinnacle_mixer.c

/***************************************************************************
			  msnd_pinnacle_mixer.c  -  description
			     -------------------
    begin		: Fre Jun 7 2002
    copyright 		: (C) 2002 by karsten wiese
    email		: annabellesgarden@yahoo.de
 ***************************************************************************/

/***************************************************************************
 *							      		   *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.				   *
 *									   *
 ***************************************************************************/

#include <linux/io.h>
#include <linux/export.h>

#include <sound/core.h>
#include <sound/control.h>
#include "msnd.h"
#include "msnd_pinnacle.h"


#define MSND_MIXER_VOLUME	0
#define MSND_MIXER_PCM		1
#define MSND_MIXER_AUX		2	/* Input source 1  (aux1) */
#define MSND_MIXER_IMIX		3	/*  Recording monitor  */
#define MSND_MIXER_SYNTH	4
#define MSND_MIXER_SPEAKER	5
#define MSND_MIXER_LINE		6
#define MSND_MIXER_MIC		7
#define MSND_MIXER_RECLEV	11	/* Recording level */
#define MSND_MIXER_IGAIN	12	/* Input gain */
#define MSND_MIXER_OGAIN	13	/* Output gain */
#define MSND_MIXER_DIGITAL	17	/* Digital (input) 1 */

/*	Device mask bits	*/

#define MSND_MASK_VOLUME	(1 << MSND_MIXER_VOLUME)
#define MSND_MASK_SYNTH		(1 << MSND_MIXER_SYNTH)
#define MSND_MASK_PCM		(1 << MSND_MIXER_PCM)
#define MSND_MASK_SPEAKER	(1 << MSND_MIXER_SPEAKER)
#define MSND_MASK_LINE		(1 << MSND_MIXER_LINE)
#define MSND_MASK_MIC		(1 << MSND_MIXER_MIC)
#define MSND_MASK_IMIX		(1 << MSND_MIXER_IMIX)
#define MSND_MASK_RECLEV	(1 << MSND_MIXER_RECLEV)
#define MSND_MASK_IGAIN		(1 << MSND_MIXER_IGAIN)
#define MSND_MASK_OGAIN		(1 << MSND_MIXER_OGAIN)
#define MSND_MASK_AUX		(1 << MSND_MIXER_AUX)
#define MSND_MASK_DIGITAL	(1 << MSND_MIXER_DIGITAL)

static int snd_msndmix_info_mux(struct snd_kcontrol *kcontrol,
				struct snd_ctl_elem_info *uinfo)
{
	static char *texts[3] = {
		"Analog", "MASS", "SPDIF",
	};
	struct snd_msnd *chip = snd_kcontrol_chip(kcontrol);
	unsigned items = test_bit(F_HAVEDIGITAL, &chip->flags) ? 3 : 2;

	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
	uinfo->count = 1;
	uinfo->value.enumerated.items = items;
	if (uinfo->value.enumerated.item >= items)
		uinfo->value.enumerated.item = items - 1;
	strcpy(uinfo->value.enumerated.name,
		texts[uinfo->value.enumerated.item]);
	return 0;
}

static int snd_msndmix_get_mux(struct snd_kcontrol *kcontrol,
				struct snd_ctl_elem_value *ucontrol)
{
	struct snd_msnd *chip = snd_kcontrol_chip(kcontrol);
	/* MSND_MASK_IMIX is the default */
	ucontrol->value.enumerated.item[0] = 0;

	if (chip->recsrc & MSND_MASK_SYNTH) {
		ucontrol->value.enumerated.item[0] = 1;
	} else if ((chip->recsrc & MSND_MASK_DIGITAL) &&
		 test_bit(F_HAVEDIGITAL, &chip->flags)) {
		ucontrol->value.enumerated.item[0] = 2;
	}


	return 0;
}

static int snd_msndmix_set_mux(struct snd_msnd *chip, int val)
{
	unsigned newrecsrc;
	int change;
	unsigned char msndbyte;

	switch (val) {
	case 0:
		newrecsrc = MSND_MASK_IMIX;
		msndbyte = HDEXAR_SET_ANA_IN;
		break;
	case 1:
		newrecsrc = MSND_MASK_SYNTH;
		msndbyte = HDEXAR_SET_SYNTH_IN;
		break;
	case 2:
		newrecsrc = MSND_MASK_DIGITAL;
		msndbyte = HDEXAR_SET_DAT_IN;
		break;
	default:
		return -EINVAL;
	}
	change  = newrecsrc != chip->recsrc;
	if (change) {
		change = 0;
		if (!snd_msnd_send_word(chip, 0, 0, msndbyte))
			if (!snd_msnd_send_dsp_cmd(chip, HDEX_AUX_REQ)) {
				chip->recsrc = newrecsrc;
				change = 1;
			}
	}
	return change;
}

static int snd_msndmix_put_mux(struct snd_kcontrol *kcontrol,
				struct snd_ctl_elem_value *ucontrol)
{
	struct snd_msnd *msnd = snd_kcontrol_chip(kcontrol);
	return snd_msndmix_set_mux(msnd, ucontrol->value.enumerated.item[0]);
}


static int snd_msndmix_volume_info(struct snd_kcontrol *kcontrol,
				   struct snd_ctl_elem_info *uinfo)
{
	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	uinfo->count = 2;
	uinfo->value.integer.min = 0;
	uinfo->value.integer.max = 100;
	return 0;
}

static int snd_msndmix_volume_get(struct snd_kcontrol *kcontrol,
				  struct snd_ctl_elem_value *ucontrol)
{
	struct snd_msnd *msnd = snd_kcontrol_chip(kcontrol);
	int addr = kcontrol->private_value;
	unsigned long flags;

	spin_lock_irqsave(&msnd->mixer_lock, flags);
	ucontrol->value.integer.value[0] = msnd->left_levels[addr] * 100;
	ucontrol->value.integer.value[0] /= 0xFFFF;
	ucontrol->value.integer.value[1] = msnd->right_levels[addr] * 100;
	ucontrol->value.integer.value[1] /= 0xFFFF;
	spin_unlock_irqrestore(&msnd->mixer_lock, flags);
	return 0;
}

#define update_volm(a, b)						\
	do {								\
		writew((dev->left_levels[a] >> 1) *			\
		       readw(dev->SMA + SMA_wCurrMastVolLeft) / 0xffff,	\
		       dev->SMA + SMA_##b##Left);			\
		writew((dev->right_levels[a] >> 1)  *			\
		       readw(dev->SMA + SMA_wCurrMastVolRight) / 0xffff, \
		       dev->SMA + SMA_##b##Right);			\
	} while (0);

#define update_potm(d, s, ar)						\
	do {								\
		writeb((dev->left_levels[d] >> 8) *			\
		       readw(dev->SMA + SMA_wCurrMastVolLeft) / 0xffff, \
		       dev->SMA + SMA_##s##Left);			\
		writeb((dev->right_levels[d] >> 8) *			\
		       readw(dev->SMA + SMA_wCurrMastVolRight) / 0xffff, \
		       dev->SMA + SMA_##s##Right);			\
		if (snd_msnd_send_word(dev, 0, 0, ar) == 0)		\
			snd_msnd_send_dsp_cmd(dev, HDEX_AUX_REQ);	\
	} while (0);

#define update_pot(d, s, ar)						\
	do {								\
		writeb(dev->left_levels[d] >> 8,			\
		       dev->SMA + SMA_##s##Left);			\
		writeb(dev->right_levels[d] >> 8,			\
		       dev->SMA + SMA_##s##Right);			\
		if (snd_msnd_send_word(dev, 0, 0, ar) == 0)		\
			snd_msnd_send_dsp_cmd(dev, HDEX_AUX_REQ);	\
	} while (0);


static int snd_msndmix_set(struct snd_msnd *dev, int d, int left, int right)
{
	int bLeft, bRight;
	int wLeft, wRight;
	int updatemaster = 0;

	if (d >= LEVEL_ENTRIES)
		return -EINVAL;

	bLeft = left * 0xff / 100;
	wLeft = left * 0xffff / 100;

	bRight = right * 0xff / 100;
	wRight = right * 0xffff / 100;

	dev->left_levels[d] = wLeft;
	dev->right_levels[d] = wRight;

	switch (d) {
		/* master volume unscaled controls */
	case MSND_MIXER_LINE:			/* line pot control */
		/* scaled by IMIX in digital mix */
		writeb(bLeft, dev->SMA + SMA_bInPotPosLeft);
		writeb(bRight, dev->SMA + SMA_bInPotPosRight);
		if (snd_msnd_send_word(dev, 0, 0, HDEXAR_IN_SET_POTS) == 0)
			snd_msnd_send_dsp_cmd(dev, HDEX_AUX_REQ);
		break;
	case MSND_MIXER_MIC:			/* mic pot control */
		if (dev->type == msndClassic)
			return -EINVAL;
		/* scaled by IMIX in digital mix */
		writeb(bLeft, dev->SMA + SMA_bMicPotPosLeft);
		writeb(bRight, dev->SMA + SMA_bMicPotPosRight);
		if (snd_msnd_send_word(dev, 0, 0, HDEXAR_MIC_SET_POTS) == 0)
			snd_msnd_send_dsp_cmd(dev, HDEX_AUX_REQ);
		break;
	case MSND_MIXER_VOLUME:		/* master volume */
		writew(wLeft, dev->SMA + SMA_wCurrMastVolLeft);
		writew(wRight, dev->SMA + SMA_wCurrMastVolRight);
		/* fall through */

	case MSND_MIXER_AUX:			/* aux pot control */
		/* scaled by master volume */
		/* fall through */

		/* digital controls */
	case MSND_MIXER_SYNTH:			/* synth vol (dsp mix) */
	case MSND_MIXER_PCM:			/* pcm vol (dsp mix) */
	case MSND_MIXER_IMIX:			/* input monitor (dsp mix) */
		/* scaled by master volume */
		updatemaster = 1;
		break;

	default:
		return -EINVAL;
	}

	if (updatemaster) {
		/* update master volume scaled controls */
		update_volm(MSND_MIXER_PCM, wCurrPlayVol);
		update_volm(MSND_MIXER_IMIX, wCurrInVol);
		if (dev->type == msndPinnacle)
			update_volm(MSND_MIXER_SYNTH, wCurrMHdrVol);
		update_potm(MSND_MIXER_AUX, bAuxPotPos, HDEXAR_AUX_SET_POTS);
	}

	return 0;
}

static int snd_msndmix_volume_put(struct snd_kcontrol *kcontrol,
				  struct snd_ctl_elem_value *ucontrol)
{
	struct snd_msnd *msnd = snd_kcontrol_chip(kcontrol);
	int change, addr = kcontrol->private_value;
	int left, right;
	unsigned long flags;

	left = ucontrol->value.integer.value[0] % 101;
	right = ucontrol->value.integer.value[1] % 101;
	spin_lock_irqsave(&msnd->mixer_lock, flags);
	change = msnd->left_levels[addr] != left
		|| msnd->right_levels[addr] != right;
	snd_msndmix_set(msnd, addr, left, right);
	spin_unlock_irqrestore(&msnd->mixer_lock, flags);
	return change;
}


#define DUMMY_VOLUME(xname, xindex, addr) \
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
  .info = snd_msndmix_volume_info, \
  .get = snd_msndmix_volume_get, .put = snd_msndmix_volume_put, \
  .private_value = addr }


static struct snd_kcontrol_new snd_msnd_controls[] = {
DUMMY_VOLUME("Master Volume", 0, MSND_MIXER_VOLUME),
DUMMY_VOLUME("PCM Volume", 0, MSND_MIXER_PCM),
DUMMY_VOLUME("Aux Volume", 0, MSND_MIXER_AUX),
DUMMY_VOLUME("Line Volume", 0, MSND_MIXER_LINE),
DUMMY_VOLUME("Mic Volume", 0, MSND_MIXER_MIC),
DUMMY_VOLUME("Monitor",	0, MSND_MIXER_IMIX),
{
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.name = "Capture Source",
	.info = snd_msndmix_info_mux,
	.get = snd_msndmix_get_mux,
	.put = snd_msndmix_put_mux,
}
};


int __devinit snd_msndmix_new(struct snd_card *card)
{
	struct snd_msnd *chip = card->private_data;
	unsigned int idx;
	int err;

	if (snd_BUG_ON(!chip))
		return -EINVAL;
	spin_lock_init(&chip->mixer_lock);
	strcpy(card->mixername, "MSND Pinnacle Mixer");

	for (idx = 0; idx < ARRAY_SIZE(snd_msnd_controls); idx++)
		err = snd_ctl_add(card,
				  snd_ctl_new1(snd_msnd_controls + idx, chip));
		if (err < 0)
			return err;

	return 0;
}
EXPORT_SYMBOL(snd_msndmix_new);

void snd_msndmix_setup(struct snd_msnd *dev)
{
	update_pot(MSND_MIXER_LINE, bInPotPos, HDEXAR_IN_SET_POTS);
	update_potm(MSND_MIXER_AUX, bAuxPotPos, HDEXAR_AUX_SET_POTS);
	update_volm(MSND_MIXER_PCM, wCurrPlayVol);
	update_volm(MSND_MIXER_IMIX, wCurrInVol);
	if (dev->type == msndPinnacle) {
		update_pot(MSND_MIXER_MIC, bMicPotPos, HDEXAR_MIC_SET_POTS);
		update_volm(MSND_MIXER_SYNTH, wCurrMHdrVol);
	}
}
EXPORT_SYMBOL(snd_msndmix_setup);

int snd_msndmix_force_recsrc(struct snd_msnd *dev, int recsrc)
{
	dev->recsrc = -1;
	return snd_msndmix_set_mux(dev, recsrc);
}
EXPORT_SYMBOL(snd_msndmix_force_recsrc);
Commit	Line	Data
f6c63835 KH	1	/***************************************************************************
	2	msnd_pinnacle_mixer.c - description
	3	-------------------
	4	begin : Fre Jun 7 2002
	5	copyright : (C) 2002 by karsten wiese
	6	email : annabellesgarden@yahoo.de
	7	***************************************************************************/
	8
	9	/***************************************************************************
	10	* *
	11	* This program is free software; you can redistribute it and/or modify *
	12	* it under the terms of the GNU General Public License as published by *
	13	* the Free Software Foundation; either version 2 of the License, or *
	14	* (at your option) any later version. *
	15	* *
	16	***************************************************************************/
	17
	18	#include <linux/io.h>
d81a6d71	19	#include <linux/export.h>
f6c63835 KH	20
	21	#include <sound/core.h>
	22	#include <sound/control.h>
	23	#include "msnd.h"
	24	#include "msnd_pinnacle.h"
	25
	26
	27	#define MSND_MIXER_VOLUME 0
	28	#define MSND_MIXER_PCM 1
	29	#define MSND_MIXER_AUX 2 /* Input source 1 (aux1) */
	30	#define MSND_MIXER_IMIX 3 /* Recording monitor */
	31	#define MSND_MIXER_SYNTH 4
	32	#define MSND_MIXER_SPEAKER 5
	33	#define MSND_MIXER_LINE 6
	34	#define MSND_MIXER_MIC 7
	35	#define MSND_MIXER_RECLEV 11 /* Recording level */
	36	#define MSND_MIXER_IGAIN 12 /* Input gain */
	37	#define MSND_MIXER_OGAIN 13 /* Output gain */
	38	#define MSND_MIXER_DIGITAL 17 /* Digital (input) 1 */
	39
	40	/* Device mask bits */
	41
	42	#define MSND_MASK_VOLUME (1 << MSND_MIXER_VOLUME)
	43	#define MSND_MASK_SYNTH (1 << MSND_MIXER_SYNTH)
	44	#define MSND_MASK_PCM (1 << MSND_MIXER_PCM)
	45	#define MSND_MASK_SPEAKER (1 << MSND_MIXER_SPEAKER)
	46	#define MSND_MASK_LINE (1 << MSND_MIXER_LINE)
	47	#define MSND_MASK_MIC (1 << MSND_MIXER_MIC)
	48	#define MSND_MASK_IMIX (1 << MSND_MIXER_IMIX)
	49	#define MSND_MASK_RECLEV (1 << MSND_MIXER_RECLEV)
	50	#define MSND_MASK_IGAIN (1 << MSND_MIXER_IGAIN)
	51	#define MSND_MASK_OGAIN (1 << MSND_MIXER_OGAIN)
	52	#define MSND_MASK_AUX (1 << MSND_MIXER_AUX)
	53	#define MSND_MASK_DIGITAL (1 << MSND_MIXER_DIGITAL)
	54
	55	static int snd_msndmix_info_mux(struct snd_kcontrol *kcontrol,
	56	struct snd_ctl_elem_info *uinfo)
	57	{
	58	static char *texts[3] = {
	59	"Analog", "MASS", "SPDIF",
	60	};
	61	struct snd_msnd *chip = snd_kcontrol_chip(kcontrol);
	62	unsigned items = test_bit(F_HAVEDIGITAL, &chip->flags) ? 3 : 2;
	63
	64	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
	65	uinfo->count = 1;
	66	uinfo->value.enumerated.items = items;
	67	if (uinfo->value.enumerated.item >= items)
	68	uinfo->value.enumerated.item = items - 1;
	69	strcpy(uinfo->value.enumerated.name,
	70	texts[uinfo->value.enumerated.item]);
	71	return 0;
	72	}
	73
	74	static int snd_msndmix_get_mux(struct snd_kcontrol *kcontrol,
	75	struct snd_ctl_elem_value *ucontrol)
	76	{
	77	struct snd_msnd *chip = snd_kcontrol_chip(kcontrol);
	78	/* MSND_MASK_IMIX is the default */
	79	ucontrol->value.enumerated.item[0] = 0;
	80
	81	if (chip->recsrc & MSND_MASK_SYNTH) {
	82	ucontrol->value.enumerated.item[0] = 1;
	83	} else if ((chip->recsrc & MSND_MASK_DIGITAL) &&
84	test_bit(F_HAVEDIGITAL, &chip->flags)) {
85	ucontrol->value.enumerated.item[0] = 2;
86	}
87
88
89	return 0;
90	}
91
92	static int snd_msndmix_set_mux(struct snd_msnd *chip, int val)
93	{
94	unsigned newrecsrc;
95	int change;
96	unsigned char msndbyte;
97
98	switch (val) {
99	case 0:
100	newrecsrc = MSND_MASK_IMIX;
101	msndbyte = HDEXAR_SET_ANA_IN;
102	break;
103	case 1:
104	newrecsrc = MSND_MASK_SYNTH;
105	msndbyte = HDEXAR_SET_SYNTH_IN;
106	break;
107	case 2:
108	newrecsrc = MSND_MASK_DIGITAL;
109	msndbyte = HDEXAR_SET_DAT_IN;
110	break;
111	default:
112	return -EINVAL;
113	}
114	change = newrecsrc != chip->recsrc;
115	if (change) {
116	change = 0;
117	if (!snd_msnd_send_word(chip, 0, 0, msndbyte))
118	if (!snd_msnd_send_dsp_cmd(chip, HDEX_AUX_REQ)) {
119	chip->recsrc = newrecsrc;
120	change = 1;
121	}
122	}
123	return change;
124	}
125
126	static int snd_msndmix_put_mux(struct snd_kcontrol *kcontrol,
127	struct snd_ctl_elem_value *ucontrol)
128	{
129	struct snd_msnd *msnd = snd_kcontrol_chip(kcontrol);
130	return snd_msndmix_set_mux(msnd, ucontrol->value.enumerated.item[0]);
131	}
132
133
134	static int snd_msndmix_volume_info(struct snd_kcontrol *kcontrol,
135	struct snd_ctl_elem_info *uinfo)
136	{
137	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
138	uinfo->count = 2;
139	uinfo->value.integer.min = 0;
140	uinfo->value.integer.max = 100;
141	return 0;
142	}
143
144	static int snd_msndmix_volume_get(struct snd_kcontrol *kcontrol,
145	struct snd_ctl_elem_value *ucontrol)
146	{
147	struct snd_msnd *msnd = snd_kcontrol_chip(kcontrol);
148	int addr = kcontrol->private_value;
149	unsigned long flags;
150
151	spin_lock_irqsave(&msnd->mixer_lock, flags);
152	ucontrol->value.integer.value[0] = msnd->left_levels[addr] * 100;
153	ucontrol->value.integer.value[0] /= 0xFFFF;
154	ucontrol->value.integer.value[1] = msnd->right_levels[addr] * 100;
155	ucontrol->value.integer.value[1] /= 0xFFFF;
156	spin_unlock_irqrestore(&msnd->mixer_lock, flags);
157	return 0;
158	}
159
160	#define update_volm(a, b) \
161	do { \
162	writew((dev->left_levels[a] >> 1) * \
163	readw(dev->SMA + SMA_wCurrMastVolLeft) / 0xffff, \
164	dev->SMA + SMA_##b##Left); \
165	writew((dev->right_levels[a] >> 1) * \
166	readw(dev->SMA + SMA_wCurrMastVolRight) / 0xffff, \
167	dev->SMA + SMA_##b##Right); \
168	} while (0);
169
170	#define update_potm(d, s, ar) \
171	do { \
172	writeb((dev->left_levels[d] >> 8) * \
173	readw(dev->SMA + SMA_wCurrMastVolLeft) / 0xffff, \
174	dev->SMA + SMA_##s##Left); \
175	writeb((dev->right_levels[d] >> 8) * \
176	readw(dev->SMA + SMA_wCurrMastVolRight) / 0xffff, \
177	dev->SMA + SMA_##s##Right); \
178	if (snd_msnd_send_word(dev, 0, 0, ar) == 0) \
179	snd_msnd_send_dsp_cmd(dev, HDEX_AUX_REQ); \
180	} while (0);
181
182	#define update_pot(d, s, ar) \
183	do { \
184	writeb(dev->left_levels[d] >> 8, \
185	dev->SMA + SMA_##s##Left); \
186	writeb(dev->right_levels[d] >> 8, \
187	dev->SMA + SMA_##s##Right); \
188	if (snd_msnd_send_word(dev, 0, 0, ar) == 0) \
189	snd_msnd_send_dsp_cmd(dev, HDEX_AUX_REQ); \
190	} while (0);
191
192
193	static int snd_msndmix_set(struct snd_msnd *dev, int d, int left, int right)
194	{
195	int bLeft, bRight;
196	int wLeft, wRight;
197	int updatemaster = 0;
198
199	if (d >= LEVEL_ENTRIES)
200	return -EINVAL;
201
202	bLeft = left * 0xff / 100;
203	wLeft = left * 0xffff / 100;
204
205	bRight = right * 0xff / 100;
206	wRight = right * 0xffff / 100;
207
208	dev->left_levels[d] = wLeft;
209	dev->right_levels[d] = wRight;
210
211	switch (d) {
212	/* master volume unscaled controls */
213	case MSND_MIXER_LINE: /* line pot control */
214	/* scaled by IMIX in digital mix */
215	writeb(bLeft, dev->SMA + SMA_bInPotPosLeft);
216	writeb(bRight, dev->SMA + SMA_bInPotPosRight);
217	if (snd_msnd_send_word(dev, 0, 0, HDEXAR_IN_SET_POTS) == 0)
218	snd_msnd_send_dsp_cmd(dev, HDEX_AUX_REQ);
219	break;
220	case MSND_MIXER_MIC: /* mic pot control */
221	if (dev->type == msndClassic)
222	return -EINVAL;
223	/* scaled by IMIX in digital mix */
224	writeb(bLeft, dev->SMA + SMA_bMicPotPosLeft);
225	writeb(bRight, dev->SMA + SMA_bMicPotPosRight);
226	if (snd_msnd_send_word(dev, 0, 0, HDEXAR_MIC_SET_POTS) == 0)
227	snd_msnd_send_dsp_cmd(dev, HDEX_AUX_REQ);
228	break;
229	case MSND_MIXER_VOLUME: /* master volume */
230	writew(wLeft, dev->SMA + SMA_wCurrMastVolLeft);
231	writew(wRight, dev->SMA + SMA_wCurrMastVolRight);
232	/* fall through */
233
234	case MSND_MIXER_AUX: /* aux pot control */
235	/* scaled by master volume */
236	/* fall through */
237
238	/* digital controls */
239	case MSND_MIXER_SYNTH: /* synth vol (dsp mix) */
240	case MSND_MIXER_PCM: /* pcm vol (dsp mix) */
241	case MSND_MIXER_IMIX: /* input monitor (dsp mix) */
242	/* scaled by master volume */
243	updatemaster = 1;
244	break;
245
246	default:
247	return -EINVAL;
248	}
249
250	if (updatemaster) {
251	/* update master volume scaled controls */
252	update_volm(MSND_MIXER_PCM, wCurrPlayVol);
253	update_volm(MSND_MIXER_IMIX, wCurrInVol);
254	if (dev->type == msndPinnacle)
255	update_volm(MSND_MIXER_SYNTH, wCurrMHdrVol);
256	update_potm(MSND_MIXER_AUX, bAuxPotPos, HDEXAR_AUX_SET_POTS);
257	}
258
259	return 0;
260	}
261
262	static int snd_msndmix_volume_put(struct snd_kcontrol *kcontrol,
263	struct snd_ctl_elem_value *ucontrol)
264	{
265	struct snd_msnd *msnd = snd_kcontrol_chip(kcontrol);
266	int change, addr = kcontrol->private_value;
267	int left, right;
268	unsigned long flags;
269
270	left = ucontrol->value.integer.value[0] % 101;
271	right = ucontrol->value.integer.value[1] % 101;
272	spin_lock_irqsave(&msnd->mixer_lock, flags);
273	change = msnd->left_levels[addr] != left
274	\|\| msnd->right_levels[addr] != right;
275	snd_msndmix_set(msnd, addr, left, right);
276	spin_unlock_irqrestore(&msnd->mixer_lock, flags);
277	return change;
278	}
279
280
281	#define DUMMY_VOLUME(xname, xindex, addr) \
282	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
283	.info = snd_msndmix_volume_info, \
284	.get = snd_msndmix_volume_get, .put = snd_msndmix_volume_put, \
285	.private_value = addr }
286
287
288	static struct snd_kcontrol_new snd_msnd_controls[] = {
289	DUMMY_VOLUME("Master Volume", 0, MSND_MIXER_VOLUME),
290	DUMMY_VOLUME("PCM Volume", 0, MSND_MIXER_PCM),
291	DUMMY_VOLUME("Aux Volume", 0, MSND_MIXER_AUX),
292	DUMMY_VOLUME("Line Volume", 0, MSND_MIXER_LINE),
293	DUMMY_VOLUME("Mic Volume", 0, MSND_MIXER_MIC),
294	DUMMY_VOLUME("Monitor", 0, MSND_MIXER_IMIX),
295	{
296	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
297	.name = "Capture Source",
298	.info = snd_msndmix_info_mux,
299	.get = snd_msndmix_get_mux,
300	.put = snd_msndmix_put_mux,
301	}
302	};
303
304
305	int __devinit snd_msndmix_new(struct snd_card *card)
306	{
307	struct snd_msnd *chip = card->private_data;
308	unsigned int idx;
309	int err;
310
311	if (snd_BUG_ON(!chip))
312	return -EINVAL;
313	spin_lock_init(&chip->mixer_lock);
314	strcpy(card->mixername, "MSND Pinnacle Mixer");
315
316	for (idx = 0; idx < ARRAY_SIZE(snd_msnd_controls); idx++)
317	err = snd_ctl_add(card,
318	snd_ctl_new1(snd_msnd_controls + idx, chip));
319	if (err < 0)
320	return err;
321
322	return 0;
323	}
324	EXPORT_SYMBOL(snd_msndmix_new);
325
326	void snd_msndmix_setup(struct snd_msnd *dev)
327	{
328	update_pot(MSND_MIXER_LINE, bInPotPos, HDEXAR_IN_SET_POTS);
329	update_potm(MSND_MIXER_AUX, bAuxPotPos, HDEXAR_AUX_SET_POTS);
330	update_volm(MSND_MIXER_PCM, wCurrPlayVol);
331	update_volm(MSND_MIXER_IMIX, wCurrInVol);
332	if (dev->type == msndPinnacle) {
333	update_pot(MSND_MIXER_MIC, bMicPotPos, HDEXAR_MIC_SET_POTS);
334	update_volm(MSND_MIXER_SYNTH, wCurrMHdrVol);
335	}
336	}
337	EXPORT_SYMBOL(snd_msndmix_setup);
338
339	int snd_msndmix_force_recsrc(struct snd_msnd *dev, int recsrc)
340	{
341	dev->recsrc = -1;
342	return snd_msndmix_set_mux(dev, recsrc);
343	}
344	EXPORT_SYMBOL(snd_msndmix_force_recsrc);