[linux.git] / sound / oss / ac97.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include "ac97.h"

/* Flag for mono controls. */
#define MO 0
/* And for stereo. */
#define ST 1

/* Whether or not the bits in the channel are inverted. */
#define INV 1
#define NINV 0

static struct ac97_chn_desc {
    int ac97_regnum;
    int oss_channel;
    int maxval;
    int is_stereo;
    int oss_mask;
    int recordNum;
    u16 regmask;
    int is_inverted;
} mixerRegs[] = {
    { AC97_MASTER_VOL_STEREO, SOUND_MIXER_VOLUME,   0x3f, ST, SOUND_MASK_VOLUME,   5, 0x0000, INV  },
    { AC97_MASTER_VOL_MONO,   SOUND_MIXER_PHONEOUT, 0x3f, MO, SOUND_MASK_PHONEOUT, 6, 0x0000, INV  },
    { AC97_MASTER_TONE,       SOUND_MIXER_TREBLE,   0x0f, MO, SOUND_MASK_TREBLE,  -1, 0x00ff, INV  },
    { AC97_MASTER_TONE,       SOUND_MIXER_BASS,     0x0f, MO, SOUND_MASK_BASS,    -1, 0xff00, INV  },
    { AC97_PCBEEP_VOL,        SOUND_MIXER_SPEAKER,  0x0f, MO, SOUND_MASK_SPEAKER, -1, 0x001e, INV  },
    { AC97_PHONE_VOL,         SOUND_MIXER_PHONEIN,  0x1f, MO, SOUND_MASK_PHONEIN,  7, 0x0000, INV  },
    { AC97_MIC_VOL,           SOUND_MIXER_MIC,      0x1f, MO, SOUND_MASK_MIC,      0, 0x0000, INV  },
    { AC97_LINEIN_VOL,        SOUND_MIXER_LINE,     0x1f, ST, SOUND_MASK_LINE,     4, 0x0000, INV  },
    { AC97_CD_VOL,            SOUND_MIXER_CD,       0x1f, ST, SOUND_MASK_CD,       1, 0x0000, INV  },
    { AC97_VIDEO_VOL,         SOUND_MIXER_VIDEO,    0x1f, ST, SOUND_MASK_VIDEO,    2, 0x0000, INV  },
    { AC97_AUX_VOL,           SOUND_MIXER_LINE1,    0x1f, ST, SOUND_MASK_LINE1,	   3, 0x0000, INV  },
    { AC97_PCMOUT_VOL,        SOUND_MIXER_PCM,      0x1f, ST, SOUND_MASK_PCM,     -1, 0x0000, INV  },
    { AC97_RECORD_GAIN,       SOUND_MIXER_IGAIN,    0x0f, ST, SOUND_MASK_IGAIN,   -1, 0x0000, NINV },
    { -1,		      -1,		    0xff, 0,  0,                  -1, 0x0000, 0    },
};

static struct ac97_chn_desc *
ac97_find_chndesc (struct ac97_hwint *dev, int oss_channel)
{
    int x;

    for (x = 0; mixerRegs[x].oss_channel != -1; x++) {
	if (mixerRegs[x].oss_channel == oss_channel)
	    return mixerRegs + x;
    }

    return NULL;
}

static inline int
ac97_is_valid_channel (struct ac97_hwint *dev, struct ac97_chn_desc *chn)
{
    return (dev->last_written_mixer_values[chn->ac97_regnum / 2]
	    != AC97_REG_UNSUPPORTED);
}

int
ac97_init (struct ac97_hwint *dev)
{
    int x;
    int reg0;

    /* Clear out the arrays of cached values. */
    for (x = 0; x < AC97_REG_CNT; x++)
	dev->last_written_mixer_values[x] = AC97_REGVAL_UNKNOWN;

    for (x = 0; x < SOUND_MIXER_NRDEVICES; x++)
	dev->last_written_OSS_values[x] = AC97_REGVAL_UNKNOWN;

    /* Clear the device masks.  */
    dev->mixer_devmask = 0;
    dev->mixer_stereomask = 0;
    dev->mixer_recmask = 0;

    /* ??? Do a "standard reset" via register 0? */

    /* Hardware-dependent reset.  */
    if (dev->reset_device (dev))
	return -1;

    /* Check the mixer device capabilities.  */
    reg0 = dev->read_reg (dev, AC97_RESET);

    if (reg0 < 0)
	return -1;

    /* Check for support for treble/bass controls.  */
    if (! (reg0 & 4)) {
	dev->last_written_mixer_values[AC97_MASTER_TONE / 2] 
	    = AC97_REG_UNSUPPORTED;
    }

    /* ??? There may be other tests here? */

    /* Fill in the device masks.  */
    for (x = 0; mixerRegs[x].ac97_regnum != -1; x++) {
	if (ac97_is_valid_channel (dev, mixerRegs + x)) {
	    dev->mixer_devmask |= mixerRegs[x].oss_mask;

	    if (mixerRegs[x].is_stereo)
		dev->mixer_stereomask |= mixerRegs[x].oss_mask;

	    if (mixerRegs[x].recordNum != -1)
		dev->mixer_recmask |= mixerRegs[x].oss_mask;
	}
    }

    return 0;
}

/* Return the contents of register REG; use the cache if the value in it
   is valid.  Returns a negative error code on failure. */
static int
ac97_get_register (struct ac97_hwint *dev, u8 reg) 
{
    if (reg > 127 || (reg & 1))
	return -EINVAL;

    /* See if it's in the cache, or if it's just plain invalid.  */
    switch (dev->last_written_mixer_values[reg / 2]) {
    case AC97_REG_UNSUPPORTED:
	return -EINVAL;
	break;
    case AC97_REGVAL_UNKNOWN:
	dev->last_written_mixer_values[reg / 2] = dev->read_reg (dev, reg);
	break;
    default:
	break;
    }
    return dev->last_written_mixer_values[reg / 2];
}

/* Write VALUE to AC97 register REG, and cache its value in the last-written
   cache.  Returns a negative error code on failure, or 0 on success. */
int
ac97_put_register (struct ac97_hwint *dev, u8 reg, u16 value)
{
    if (reg > 127 || (reg & 1))
	return -EINVAL;

    if (dev->last_written_mixer_values[reg / 2] == AC97_REG_UNSUPPORTED)
	return -EINVAL;
    else {
	int res = dev->write_reg (dev, reg, value);
	if (res >= 0) {
	    dev->last_written_mixer_values[reg / 2] = value;
	    return 0;
	}
	else
	    return res;
    }
}

/* Scale VALUE (a value fro 0 to MAXVAL) to a value from 0-100.  If
   IS_STEREO is set, VALUE is a stereo value; the left channel value
   is in the lower 8 bits, and the right channel value is in the upper
   8 bits.

   A negative error code is returned on failure, or the unsigned
   scaled value on success.  */

static int
ac97_scale_to_oss_val (int value, int maxval, int is_stereo, int inv)
{
    /* Muted?  */
    if (value & AC97_MUTE)
	return 0;

    if (is_stereo)
	return (ac97_scale_to_oss_val (value & 255, maxval, 0, inv) << 8)
	| (ac97_scale_to_oss_val ((value >> 8) & 255, maxval, 0, inv) << 0);
    else {
	int i;
	
	/* Inverted. */
	if (inv)
	    value = maxval - value;

	i = (value * 100 + (maxval / 2)) / maxval;
	if (i > 100)
	     i = 100;
	if (i < 0)
	    i = 0;
	return i;
    }
}

static int
ac97_scale_from_oss_val (int value, int maxval, int is_stereo, int inv)
{
    if (is_stereo)
	return (ac97_scale_from_oss_val (value & 255, maxval, 0, inv) << 8)
	| (ac97_scale_from_oss_val ((value >> 8) & 255, maxval, 0, inv) << 0);
    else {
	int i = ((value & 255) * maxval + 50) / 100;
	if (inv)
	    i = maxval - i;
	if (i < 0)
	    i = 0;
	if (i > maxval)
	    i = maxval;
	return i;
    }
}

static int
ac97_set_mixer (struct ac97_hwint *dev, int oss_channel, u16 oss_value)
{
    int scaled_value;
    struct ac97_chn_desc *channel = ac97_find_chndesc (dev, oss_channel);
    int result;

    if (channel == NULL)
	return -ENODEV;
    if (! ac97_is_valid_channel (dev, channel))
	return -ENODEV;
    scaled_value = ac97_scale_from_oss_val (oss_value, channel->maxval,
					    channel->is_stereo, 
					    channel->is_inverted);
    if (scaled_value < 0)
	return scaled_value;

    if (channel->regmask != 0) {
	int mv;

	int oldval = ac97_get_register (dev, channel->ac97_regnum);
	if (oldval < 0)
	    return oldval;

	for (mv = channel->regmask; ! (mv & 1); mv >>= 1)
	    scaled_value <<= 1;

	scaled_value &= channel->regmask;
	scaled_value |= (oldval & ~channel->regmask);
    }
    result = ac97_put_register (dev, channel->ac97_regnum, scaled_value);
    if (result == 0)
	dev->last_written_OSS_values[oss_channel] = oss_value;
    return result;
}

static int
ac97_get_mixer_scaled (struct ac97_hwint *dev, int oss_channel)
{
    struct ac97_chn_desc *channel = ac97_find_chndesc (dev, oss_channel);
    int regval;

    if (channel == NULL)
	return -ENODEV;

    if (! ac97_is_valid_channel (dev, channel))
	return -ENODEV;

    regval = ac97_get_register (dev, channel->ac97_regnum);

    if (regval < 0)
	return regval;

    if (channel->regmask != 0) {
	int mv;

	regval &= channel->regmask;

	for (mv = channel->regmask; ! (mv & 1); mv >>= 1)
	    regval >>= 1;
    }
    return ac97_scale_to_oss_val (regval, channel->maxval,
				  channel->is_stereo, 
				  channel->is_inverted);
}

static int
ac97_get_recmask (struct ac97_hwint *dev)
{
    int recReg = ac97_get_register (dev, AC97_RECORD_SELECT);

    if (recReg < 0)
	return recReg;
    else {
	int x;
	for (x = 0; mixerRegs[x].ac97_regnum >= 0; x++) {
	    if (mixerRegs[x].recordNum == (recReg & 7))
		return mixerRegs[x].oss_mask;
	}
	return -ENODEV;
    }
}

static int
ac97_set_recmask (struct ac97_hwint *dev, int oss_recmask)
{
    int x;

    if (oss_recmask == 0)
	oss_recmask = SOUND_MIXER_MIC;

    for (x = 0; mixerRegs[x].ac97_regnum >= 0; x++) { 
	if ((mixerRegs[x].recordNum >= 0)
	     && (oss_recmask & mixerRegs[x].oss_mask))
	    break;
    }
    if (mixerRegs[x].ac97_regnum < 0)
	return -ENODEV;
    else {
	int regval = (mixerRegs[x].recordNum << 8) | mixerRegs[x].recordNum;
	int res = ac97_put_register (dev, AC97_RECORD_SELECT, regval);
	if (res == 0)
	    return ac97_get_recmask (dev);
	else
	    return res;
    }
}

/* Set the mixer DEV to the list of values in VALUE_LIST.  Return 0 on
   success, or a negative error code.  */
int
ac97_set_values (struct ac97_hwint *dev, 
		 struct ac97_mixer_value_list *value_list)
{
    int x;

    for (x = 0; value_list[x].oss_channel != -1; x++) {
	int chnum = value_list[x].oss_channel;
	struct ac97_chn_desc *chent = ac97_find_chndesc (dev, chnum);
	if (chent != NULL) {
	    u16 val;
	    int res;

	    if (chent->is_stereo)
		val = (value_list[x].value.stereo.right << 8) 
		      | value_list[x].value.stereo.left;
	    else {
		/* We do this so the returned value looks OK in the
		   mixer app.  It's not necessary otherwise.  */
		val = (value_list[x].value.mono << 8) 
		      | value_list[x].value.mono;
	    }
	    res = ac97_set_mixer (dev, chnum, val);
	    if (res < 0)
		return res;
	}
	else
	    return -ENODEV;
    }
    return 0;
}

int
ac97_mixer_ioctl (struct ac97_hwint *dev, unsigned int cmd, void __user *arg)
{
    int ret;

    switch (cmd) {
    case SOUND_MIXER_READ_RECSRC:
	ret = ac97_get_recmask (dev);
	break;

    case SOUND_MIXER_WRITE_RECSRC:
	{
	    if (get_user (ret, (int __user *) arg))
		ret = -EFAULT;
	    else
		ret = ac97_set_recmask (dev, ret);
	}
	break;

    case SOUND_MIXER_READ_CAPS:
	ret = SOUND_CAP_EXCL_INPUT;
	break;

    case SOUND_MIXER_READ_DEVMASK:
	ret = dev->mixer_devmask;
	break;

    case SOUND_MIXER_READ_RECMASK:
	ret = dev->mixer_recmask;
	break;

    case SOUND_MIXER_READ_STEREODEVS:
	ret = dev->mixer_stereomask;
	break;

    default:
	/* Read or write request. */
	ret = -EINVAL;
	if (_IOC_TYPE (cmd) == 'M') {
	    int dir = _SIOC_DIR (cmd);
	    int channel = _IOC_NR (cmd);

	    if (channel >= 0 && channel < SOUND_MIXER_NRDEVICES) {
		ret = 0;
		if (dir & _SIOC_WRITE) {
		    int val;
		    if (get_user (val, (int __user *) arg) == 0)
			ret = ac97_set_mixer (dev, channel, val);
		    else
			ret = -EFAULT;
		}
		if (ret >= 0 && (dir & _SIOC_READ)) {
		    if (dev->last_written_OSS_values[channel]
			== AC97_REGVAL_UNKNOWN)
			dev->last_written_OSS_values[channel]
			    = ac97_get_mixer_scaled (dev, channel);
		    ret = dev->last_written_OSS_values[channel];
		}
	    }
	}
	break;
    }

    if (ret < 0)
	return ret;
    else
	return put_user(ret, (int __user *) arg);
}

EXPORT_SYMBOL(ac97_init);
EXPORT_SYMBOL(ac97_set_values);
EXPORT_SYMBOL(ac97_put_register);
EXPORT_SYMBOL(ac97_mixer_ioctl);
MODULE_LICENSE("GPL");

\f
/*
 * Local variables:
 *  c-basic-offset: 4
 * End:
 */
Commit	Line	Data
1da177e4 LT	1	#include <linux/module.h>
	2	#include <linux/kernel.h>
	3	#include <linux/init.h>
	4	#include "ac97.h"
	5
	6	/* Flag for mono controls. */
	7	#define MO 0
	8	/* And for stereo. */
	9	#define ST 1
	10
	11	/* Whether or not the bits in the channel are inverted. */
	12	#define INV 1
	13	#define NINV 0
	14
	15	static struct ac97_chn_desc {
	16	int ac97_regnum;
	17	int oss_channel;
	18	int maxval;
	19	int is_stereo;
	20	int oss_mask;
	21	int recordNum;
	22	u16 regmask;
	23	int is_inverted;
	24	} mixerRegs[] = {
	25	{ AC97_MASTER_VOL_STEREO, SOUND_MIXER_VOLUME, 0x3f, ST, SOUND_MASK_VOLUME, 5, 0x0000, INV },
	26	{ AC97_MASTER_VOL_MONO, SOUND_MIXER_PHONEOUT, 0x3f, MO, SOUND_MASK_PHONEOUT, 6, 0x0000, INV },
	27	{ AC97_MASTER_TONE, SOUND_MIXER_TREBLE, 0x0f, MO, SOUND_MASK_TREBLE, -1, 0x00ff, INV },
	28	{ AC97_MASTER_TONE, SOUND_MIXER_BASS, 0x0f, MO, SOUND_MASK_BASS, -1, 0xff00, INV },
	29	{ AC97_PCBEEP_VOL, SOUND_MIXER_SPEAKER, 0x0f, MO, SOUND_MASK_SPEAKER, -1, 0x001e, INV },
	30	{ AC97_PHONE_VOL, SOUND_MIXER_PHONEIN, 0x1f, MO, SOUND_MASK_PHONEIN, 7, 0x0000, INV },
	31	{ AC97_MIC_VOL, SOUND_MIXER_MIC, 0x1f, MO, SOUND_MASK_MIC, 0, 0x0000, INV },
	32	{ AC97_LINEIN_VOL, SOUND_MIXER_LINE, 0x1f, ST, SOUND_MASK_LINE, 4, 0x0000, INV },
	33	{ AC97_CD_VOL, SOUND_MIXER_CD, 0x1f, ST, SOUND_MASK_CD, 1, 0x0000, INV },
	34	{ AC97_VIDEO_VOL, SOUND_MIXER_VIDEO, 0x1f, ST, SOUND_MASK_VIDEO, 2, 0x0000, INV },
	35	{ AC97_AUX_VOL, SOUND_MIXER_LINE1, 0x1f, ST, SOUND_MASK_LINE1, 3, 0x0000, INV },
	36	{ AC97_PCMOUT_VOL, SOUND_MIXER_PCM, 0x1f, ST, SOUND_MASK_PCM, -1, 0x0000, INV },
	37	{ AC97_RECORD_GAIN, SOUND_MIXER_IGAIN, 0x0f, ST, SOUND_MASK_IGAIN, -1, 0x0000, NINV },
	38	{ -1, -1, 0xff, 0, 0, -1, 0x0000, 0 },
	39	};
	40
	41	static struct ac97_chn_desc *
	42	ac97_find_chndesc (struct ac97_hwint *dev, int oss_channel)
	43	{
	44	int x;
	45
	46	for (x = 0; mixerRegs[x].oss_channel != -1; x++) {
	47	if (mixerRegs[x].oss_channel == oss_channel)
	48	return mixerRegs + x;
	49	}
	50
	51	return NULL;
	52	}
	53
	54	static inline int
	55	ac97_is_valid_channel (struct ac97_hwint dev, struct ac97_chn_desc chn)
	56	{
	57	return (dev->last_written_mixer_values[chn->ac97_regnum / 2]
	58	!= AC97_REG_UNSUPPORTED);
	59	}
	60
	61	int
	62	ac97_init (struct ac97_hwint *dev)
	63	{
	64	int x;
65	int reg0;
66
67	/* Clear out the arrays of cached values. */
68	for (x = 0; x < AC97_REG_CNT; x++)
69	dev->last_written_mixer_values[x] = AC97_REGVAL_UNKNOWN;
70
71	for (x = 0; x < SOUND_MIXER_NRDEVICES; x++)
72	dev->last_written_OSS_values[x] = AC97_REGVAL_UNKNOWN;
73
74	/* Clear the device masks. */
75	dev->mixer_devmask = 0;
76	dev->mixer_stereomask = 0;
77	dev->mixer_recmask = 0;
78
79	/* ??? Do a "standard reset" via register 0? */
80
81	/* Hardware-dependent reset. */
82	if (dev->reset_device (dev))
83	return -1;
84
85	/* Check the mixer device capabilities. */
86	reg0 = dev->read_reg (dev, AC97_RESET);
87
88	if (reg0 < 0)
89	return -1;
90
91	/* Check for support for treble/bass controls. */
92	if (! (reg0 & 4)) {
93	dev->last_written_mixer_values[AC97_MASTER_TONE / 2]
94	= AC97_REG_UNSUPPORTED;
95	}
96
97	/* ??? There may be other tests here? */
98
99	/* Fill in the device masks. */
100	for (x = 0; mixerRegs[x].ac97_regnum != -1; x++) {
101	if (ac97_is_valid_channel (dev, mixerRegs + x)) {
102	dev->mixer_devmask \|= mixerRegs[x].oss_mask;
103
104	if (mixerRegs[x].is_stereo)
105	dev->mixer_stereomask \|= mixerRegs[x].oss_mask;
106
107	if (mixerRegs[x].recordNum != -1)
108	dev->mixer_recmask \|= mixerRegs[x].oss_mask;
109	}
110	}
111
112	return 0;
113	}
114
1da177e4 LT	115	/* Return the contents of register REG; use the cache if the value in it
	116	is valid. Returns a negative error code on failure. */
	117	static int
	118	ac97_get_register (struct ac97_hwint *dev, u8 reg)
	119	{
	120	if (reg > 127 \|\| (reg & 1))
	121	return -EINVAL;
	122
	123	/* See if it's in the cache, or if it's just plain invalid. */
	124	switch (dev->last_written_mixer_values[reg / 2]) {
	125	case AC97_REG_UNSUPPORTED:
	126	return -EINVAL;
	127	break;
	128	case AC97_REGVAL_UNKNOWN:
	129	dev->last_written_mixer_values[reg / 2] = dev->read_reg (dev, reg);
	130	break;
	131	default:
	132	break;
	133	}
	134	return dev->last_written_mixer_values[reg / 2];
	135	}
	136
	137	/* Write VALUE to AC97 register REG, and cache its value in the last-written
	138	cache. Returns a negative error code on failure, or 0 on success. */
	139	int
	140	ac97_put_register (struct ac97_hwint *dev, u8 reg, u16 value)
	141	{
	142	if (reg > 127 \|\| (reg & 1))
	143	return -EINVAL;
	144
	145	if (dev->last_written_mixer_values[reg / 2] == AC97_REG_UNSUPPORTED)
	146	return -EINVAL;
	147	else {
	148	int res = dev->write_reg (dev, reg, value);
	149	if (res >= 0) {
	150	dev->last_written_mixer_values[reg / 2] = value;
	151	return 0;
	152	}
	153	else
	154	return res;
	155	}
	156	}
	157
	158	/* Scale VALUE (a value fro 0 to MAXVAL) to a value from 0-100. If
	159	IS_STEREO is set, VALUE is a stereo value; the left channel value
	160	is in the lower 8 bits, and the right channel value is in the upper
	161	8 bits.
	162
	163	A negative error code is returned on failure, or the unsigned
	164	scaled value on success. */
	165
	166	static int
	167	ac97_scale_to_oss_val (int value, int maxval, int is_stereo, int inv)
	168	{
	169	/* Muted? */
	170	if (value & AC97_MUTE)
	171	return 0;
	172
	173	if (is_stereo)
	174	return (ac97_scale_to_oss_val (value & 255, maxval, 0, inv) << 8)
	175	\| (ac97_scale_to_oss_val ((value >> 8) & 255, maxval, 0, inv) << 0);
	176	else {
	177	int i;
	178
179	/* Inverted. */
180	if (inv)
181	value = maxval - value;
182
183	i = (value * 100 + (maxval / 2)) / maxval;
184	if (i > 100)
185	i = 100;
186	if (i < 0)
187	i = 0;
188	return i;
189	}
190	}
191
192	static int
193	ac97_scale_from_oss_val (int value, int maxval, int is_stereo, int inv)
194	{
195	if (is_stereo)
196	return (ac97_scale_from_oss_val (value & 255, maxval, 0, inv) << 8)
197	\| (ac97_scale_from_oss_val ((value >> 8) & 255, maxval, 0, inv) << 0);
198	else {
199	int i = ((value & 255) * maxval + 50) / 100;
200	if (inv)
201	i = maxval - i;
202	if (i < 0)
203	i = 0;
204	if (i > maxval)
205	i = maxval;
206	return i;
207	}
208	}
209
210	static int
211	ac97_set_mixer (struct ac97_hwint *dev, int oss_channel, u16 oss_value)
212	{
213	int scaled_value;
214	struct ac97_chn_desc *channel = ac97_find_chndesc (dev, oss_channel);
215	int result;
216
217	if (channel == NULL)
218	return -ENODEV;
219	if (! ac97_is_valid_channel (dev, channel))
220	return -ENODEV;
221	scaled_value = ac97_scale_from_oss_val (oss_value, channel->maxval,
222	channel->is_stereo,
223	channel->is_inverted);
224	if (scaled_value < 0)
225	return scaled_value;
226
227	if (channel->regmask != 0) {
228	int mv;
229
230	int oldval = ac97_get_register (dev, channel->ac97_regnum);
231	if (oldval < 0)
232	return oldval;
233
234	for (mv = channel->regmask; ! (mv & 1); mv >>= 1)
235	scaled_value <<= 1;
236
237	scaled_value &= channel->regmask;
238	scaled_value \|= (oldval & ~channel->regmask);
239	}
240	result = ac97_put_register (dev, channel->ac97_regnum, scaled_value);
241	if (result == 0)
242	dev->last_written_OSS_values[oss_channel] = oss_value;
243	return result;
244	}
245
246	static int
247	ac97_get_mixer_scaled (struct ac97_hwint *dev, int oss_channel)
248	{
249	struct ac97_chn_desc *channel = ac97_find_chndesc (dev, oss_channel);
250	int regval;
251
252	if (channel == NULL)
253	return -ENODEV;
254
255	if (! ac97_is_valid_channel (dev, channel))
256	return -ENODEV;
257
258	regval = ac97_get_register (dev, channel->ac97_regnum);
259
260	if (regval < 0)
261	return regval;
262
263	if (channel->regmask != 0) {
264	int mv;
265
266	regval &= channel->regmask;
267
268	for (mv = channel->regmask; ! (mv & 1); mv >>= 1)
269	regval >>= 1;
270	}
271	return ac97_scale_to_oss_val (regval, channel->maxval,
272	channel->is_stereo,
273	channel->is_inverted);
274	}
275
276	static int
277	ac97_get_recmask (struct ac97_hwint *dev)
278	{
279	int recReg = ac97_get_register (dev, AC97_RECORD_SELECT);
280
281	if (recReg < 0)
282	return recReg;
283	else {
284	int x;
285	for (x = 0; mixerRegs[x].ac97_regnum >= 0; x++) {
286	if (mixerRegs[x].recordNum == (recReg & 7))
287	return mixerRegs[x].oss_mask;
288	}
289	return -ENODEV;
290	}
291	}
292
293	static int
294	ac97_set_recmask (struct ac97_hwint *dev, int oss_recmask)
295	{
296	int x;
297
298	if (oss_recmask == 0)
299	oss_recmask = SOUND_MIXER_MIC;
300
301	for (x = 0; mixerRegs[x].ac97_regnum >= 0; x++) {
302	if ((mixerRegs[x].recordNum >= 0)
303	&& (oss_recmask & mixerRegs[x].oss_mask))
304	break;
305	}
306	if (mixerRegs[x].ac97_regnum < 0)
307	return -ENODEV;
308	else {
309	int regval = (mixerRegs[x].recordNum << 8) \| mixerRegs[x].recordNum;
310	int res = ac97_put_register (dev, AC97_RECORD_SELECT, regval);
311	if (res == 0)
312	return ac97_get_recmask (dev);
313	else
314	return res;
315	}
316	}
317
318	/* Set the mixer DEV to the list of values in VALUE_LIST. Return 0 on
319	success, or a negative error code. */
320	int
321	ac97_set_values (struct ac97_hwint *dev,
322	struct ac97_mixer_value_list *value_list)
323	{
324	int x;
325
326	for (x = 0; value_list[x].oss_channel != -1; x++) {
327	int chnum = value_list[x].oss_channel;
328	struct ac97_chn_desc *chent = ac97_find_chndesc (dev, chnum);
329	if (chent != NULL) {
330	u16 val;
331	int res;
332
333	if (chent->is_stereo)
334	val = (value_list[x].value.stereo.right << 8)
335	\| value_list[x].value.stereo.left;
336	else {
337	/* We do this so the returned value looks OK in the
338	mixer app. It's not necessary otherwise. */
339	val = (value_list[x].value.mono << 8)
340	\| value_list[x].value.mono;
341	}
342	res = ac97_set_mixer (dev, chnum, val);
343	if (res < 0)
344	return res;
345	}
346	else
347	return -ENODEV;
348	}
349	return 0;
350	}
351
352	int
353	ac97_mixer_ioctl (struct ac97_hwint dev, unsigned int cmd, void __user arg)
354	{
355	int ret;
356
357	switch (cmd) {
358	case SOUND_MIXER_READ_RECSRC:
359	ret = ac97_get_recmask (dev);
360	break;
361
362	case SOUND_MIXER_WRITE_RECSRC:
363	{
364	if (get_user (ret, (int __user *) arg))
365	ret = -EFAULT;
366	else
367	ret = ac97_set_recmask (dev, ret);
368	}
369	break;
370
371	case SOUND_MIXER_READ_CAPS:
372	ret = SOUND_CAP_EXCL_INPUT;
373	break;
374
375	case SOUND_MIXER_READ_DEVMASK:
376	ret = dev->mixer_devmask;
377	break;
378
379	case SOUND_MIXER_READ_RECMASK:
380	ret = dev->mixer_recmask;
381	break;
382
383	case SOUND_MIXER_READ_STEREODEVS:
384	ret = dev->mixer_stereomask;
385	break;
386
387	default:
388	/* Read or write request. */
389	ret = -EINVAL;
390	if (_IOC_TYPE (cmd) == 'M') {
391	int dir = _SIOC_DIR (cmd);
392	int channel = _IOC_NR (cmd);
393
394	if (channel >= 0 && channel < SOUND_MIXER_NRDEVICES) {
395	ret = 0;
396	if (dir & _SIOC_WRITE) {
397	int val;
398	if (get_user (val, (int __user *) arg) == 0)
399	ret = ac97_set_mixer (dev, channel, val);
400	else
401	ret = -EFAULT;
402	}
403	if (ret >= 0 && (dir & _SIOC_READ)) {
404	if (dev->last_written_OSS_values[channel]
405	== AC97_REGVAL_UNKNOWN)
406	dev->last_written_OSS_values[channel]
407	= ac97_get_mixer_scaled (dev, channel);
408	ret = dev->last_written_OSS_values[channel];
409	}
410	}
411	}
412	break;
413	}
414
415	if (ret < 0)
416	return ret;
417	else
418	return put_user(ret, (int __user *) arg);
419	}
420
421	EXPORT_SYMBOL(ac97_init);
422	EXPORT_SYMBOL(ac97_set_values);
423	EXPORT_SYMBOL(ac97_put_register);
424	EXPORT_SYMBOL(ac97_mixer_ioctl);
1da177e4 LT	425	MODULE_LICENSE("GPL");
	426
	427	\f
	428	/*
	429	* Local variables:
	430	* c-basic-offset: 4
	431	* End:
	432	*/