Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 452 insertions, 0 deletions

diff --git a/sound/oss/ac97.c b/sound/oss/ac97.c
new file mode 100644
index 000000000000..3ba6d91e891d
--- /dev/null
+++ b/sound/oss/ac97.c
@@ -0,0 +1,452 @@
+#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:
+ */