|
|
#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;
|
|
|
}
|
|
|
|
|
|
/* Reset the mixer to the currently saved settings. */
|
|
|
int
|
|
|
ac97_reset (struct ac97_hwint *dev)
|
|
|
{
|
|
|
int x;
|
|
|
|
|
|
if (dev->reset_device (dev))
|
|
|
return -1;
|
|
|
|
|
|
/* Now set the registers back to their last-written values. */
|
|
|
for (x = 0; mixerRegs[x].ac97_regnum != -1; x++) {
|
|
|
int regnum = mixerRegs[x].ac97_regnum;
|
|
|
int value = dev->last_written_mixer_values [regnum / 2];
|
|
|
if (value >= 0)
|
|
|
ac97_put_register (dev, regnum, value);
|
|
|
}
|
|
|
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);
|
|
|
EXPORT_SYMBOL(ac97_reset);
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Local variables:
|
|
|
* c-basic-offset: 4
|
|
|
* End:
|
|
|
*/
|
|
|
|
