mixer.c

Go to the documentation of this file.

/*-
 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
 *
 * Copyright (c) 2005-2009 Ariff Abdullah <ariff@FreeBSD.org>
 * Portions Copyright (c) Ryan Beasley <ryan.beasley@gmail.com> - GSoC 2006
 * Copyright (c) 1999 Cameron Grant <cg@FreeBSD.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
 
#ifdef HAVE_KERNEL_OPTION_HEADERS
#include "opt_snd.h"
#endif
 
#include <dev/sound/pcm/sound.h>
 
#include "feeder_if.h"
#include "mixer_if.h"
 
SND_DECLARE_FILE("$FreeBSD$");
 
static MALLOC_DEFINE(M_MIXER, "mixer", "mixer");
 
static int mixer_bypass = 1;
SYSCTL_INT(_hw_snd, OID_AUTO, vpc_mixer_bypass, CTLFLAG_RWTUN,
    &mixer_bypass, 0,
    "control channel pcm/rec volume, bypassing real mixer device");
 
#define MIXER_NAMELEN   16
struct snd_mixer {
        KOBJ_FIELDS;
        void *devinfo;
        int busy;
        int hwvol_mixer;
        int hwvol_step;
        int type;
        device_t dev;
        u_int32_t devs;
        u_int32_t mutedevs;
        u_int32_t recdevs;
        u_int32_t recsrc;
        u_int16_t level[32];
        u_int16_t level_muted[32];
        u_int8_t parent[32];
        u_int32_t child[32];
        u_int8_t realdev[32];
        char name[MIXER_NAMELEN];
        struct mtx *lock;
        oss_mixer_enuminfo enuminfo;
        int modify_counter;
};
 
static u_int16_t snd_mixerdefaults[SOUND_MIXER_NRDEVICES] = {
        [SOUND_MIXER_VOLUME]    = 75,
        [SOUND_MIXER_BASS]      = 50,
        [SOUND_MIXER_TREBLE]    = 50,
        [SOUND_MIXER_SYNTH]     = 75,
        [SOUND_MIXER_PCM]       = 75,
        [SOUND_MIXER_SPEAKER]   = 75,
        [SOUND_MIXER_LINE]      = 75,
        [SOUND_MIXER_MIC]       = 25,
        [SOUND_MIXER_CD]        = 75,
        [SOUND_MIXER_IGAIN]     = 0,
        [SOUND_MIXER_LINE1]     = 75,
        [SOUND_MIXER_VIDEO]     = 75,
        [SOUND_MIXER_RECLEV]    = 75,
        [SOUND_MIXER_OGAIN]     = 50,
        [SOUND_MIXER_MONITOR]   = 75,
};
 
static char* snd_mixernames[SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_NAMES;
 
static d_open_t mixer_open;
static d_close_t mixer_close;
static d_ioctl_t mixer_ioctl;
 
static struct cdevsw mixer_cdevsw = {
        .d_version =    D_VERSION,
        .d_open =       mixer_open,
        .d_close =      mixer_close,
        .d_ioctl =      mixer_ioctl,
        .d_name =       "mixer",
};
 
int mixer_count = 0;
 
static eventhandler_tag mixer_ehtag = NULL;
 
static struct cdev *
mixer_get_devt(device_t dev)
{
        struct snddev_info *snddev;
 
        snddev = device_get_softc(dev);
 
        return snddev->mixer_dev;
}
 
static int
mixer_lookup(char *devname)
{
        int i;
 
        for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
                if (strncmp(devname, snd_mixernames[i],
                    strlen(snd_mixernames[i])) == 0)
                        return i;
        return -1;
}
 
#define MIXER_SET_UNLOCK(x, y)          do {                            \
        if ((y) != 0)                                                   \
                snd_mtxunlock((x)->lock);                               \
} while (0)
 
#define MIXER_SET_LOCK(x, y)            do {                            \
        if ((y) != 0)                                                   \
                snd_mtxlock((x)->lock);                                 \
} while (0)
 
static int
mixer_set_softpcmvol(struct snd_mixer *m, struct snddev_info *d,
    u_int left, u_int right)
{
        struct pcm_channel *c;
        int dropmtx, acquiremtx;
 
        if (PCM_DETACHING(d) || !PCM_REGISTERED(d))
                return (EINVAL);
 
        if (mtx_owned(m->lock))
                dropmtx = 1;
        else
                dropmtx = 0;
 
        if (!(d->flags & SD_F_MPSAFE) || mtx_owned(d->lock) != 0)
                acquiremtx = 0;
        else
                acquiremtx = 1;
 
        /*
         * Be careful here. If we're coming from cdev ioctl, it is OK to
         * not doing locking AT ALL (except on individual channel) since
         * we've been heavily guarded by pcm cv, or if we're still
         * under Giant influence. Since we also have mix_* calls, we cannot
         * assume such protection and just do the lock as usuall.
         */
        MIXER_SET_UNLOCK(m, dropmtx);
        MIXER_SET_LOCK(d, acquiremtx);
 
        CHN_FOREACH(c, d, channels.pcm.busy) {
                CHN_LOCK(c);
                if (c->direction == PCMDIR_PLAY &&
                    (c->feederflags & (1 << FEEDER_VOLUME)))
                        chn_setvolume_multi(c, SND_VOL_C_MASTER, left, right,
                            (left + right) >> 1);
                CHN_UNLOCK(c);
        }
 
        MIXER_SET_UNLOCK(d, acquiremtx);
        MIXER_SET_LOCK(m, dropmtx);
 
        return (0);
}
 
static int
mixer_set_eq(struct snd_mixer *m, struct snddev_info *d,
    u_int dev, u_int level)
{
        struct pcm_channel *c;
        struct pcm_feeder *f;
        int tone, dropmtx, acquiremtx;
 
        if (dev == SOUND_MIXER_TREBLE)
                tone = FEEDEQ_TREBLE;
        else if (dev == SOUND_MIXER_BASS)
                tone = FEEDEQ_BASS;
        else
                return (EINVAL);
 
        if (PCM_DETACHING(d) || !PCM_REGISTERED(d))
                return (EINVAL);
 
        if (mtx_owned(m->lock))
                dropmtx = 1;
        else
                dropmtx = 0;
 
        if (!(d->flags & SD_F_MPSAFE) || mtx_owned(d->lock) != 0)
                acquiremtx = 0;
        else
                acquiremtx = 1;
 
        /*
         * Be careful here. If we're coming from cdev ioctl, it is OK to
         * not doing locking AT ALL (except on individual channel) since
         * we've been heavily guarded by pcm cv, or if we're still
         * under Giant influence. Since we also have mix_* calls, we cannot
         * assume such protection and just do the lock as usuall.
         */
        MIXER_SET_UNLOCK(m, dropmtx);
        MIXER_SET_LOCK(d, acquiremtx);
 
        CHN_FOREACH(c, d, channels.pcm.busy) {
                CHN_LOCK(c);
                f = chn_findfeeder(c, FEEDER_EQ);
                if (f != NULL)
                        (void)FEEDER_SET(f, tone, level);
                CHN_UNLOCK(c);
        }
 
        MIXER_SET_UNLOCK(d, acquiremtx);
        MIXER_SET_LOCK(m, dropmtx);
 
        return (0);
}
 
static int
mixer_set(struct snd_mixer *m, u_int dev, u_int32_t muted, u_int lev)
{
        struct snddev_info *d;
        u_int l, r, tl, tr;
        u_int32_t parent = SOUND_MIXER_NONE, child = 0;
        u_int32_t realdev;
        int i, dropmtx;
 
        if (m == NULL || dev >= SOUND_MIXER_NRDEVICES ||
            (0 == (m->devs & (1 << dev))))
                return (-1);
 
        l = min((lev & 0x00ff), 100);
        r = min(((lev & 0xff00) >> 8), 100);
        realdev = m->realdev[dev];
 
        d = device_get_softc(m->dev);
        if (d == NULL)
                return (-1);
 
        /* It is safe to drop this mutex due to Giant. */
        if (!(d->flags & SD_F_MPSAFE) && mtx_owned(m->lock) != 0)
                dropmtx = 1;
        else
                dropmtx = 0;
 
        /* Allow the volume to be "changed" while muted. */
        if (muted & (1 << dev)) {
                m->level_muted[dev] = l | (r << 8);
                return (0);
        }
        MIXER_SET_UNLOCK(m, dropmtx);
 
        /* TODO: recursive handling */
        parent = m->parent[dev];
        if (parent >= SOUND_MIXER_NRDEVICES)
                parent = SOUND_MIXER_NONE;
        if (parent == SOUND_MIXER_NONE)
                child = m->child[dev];
 
        if (parent != SOUND_MIXER_NONE) {
                tl = (l * (m->level[parent] & 0x00ff)) / 100;
                tr = (r * ((m->level[parent] & 0xff00) >> 8)) / 100;
                if (dev == SOUND_MIXER_PCM && (d->flags & SD_F_SOFTPCMVOL))
                        (void)mixer_set_softpcmvol(m, d, tl, tr);
                else if (realdev != SOUND_MIXER_NONE &&
                    MIXER_SET(m, realdev, tl, tr) < 0) {
                        MIXER_SET_LOCK(m, dropmtx);
                        return (-1);
                }
        } else if (child != 0) {
                for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
                        if (!(child & (1 << i)) || m->parent[i] != dev)
                                continue;
                        realdev = m->realdev[i];
                        tl = (l * (m->level[i] & 0x00ff)) / 100;
                        tr = (r * ((m->level[i] & 0xff00) >> 8)) / 100;
                        if (i == SOUND_MIXER_PCM &&
                            (d->flags & SD_F_SOFTPCMVOL))
                                (void)mixer_set_softpcmvol(m, d, tl, tr);
                        else if (realdev != SOUND_MIXER_NONE)
                                MIXER_SET(m, realdev, tl, tr);
                }
                realdev = m->realdev[dev];
                if (realdev != SOUND_MIXER_NONE &&
                    MIXER_SET(m, realdev, l, r) < 0) {
                        MIXER_SET_LOCK(m, dropmtx);
                        return (-1);
                }
        } else {
                if (dev == SOUND_MIXER_PCM && (d->flags & SD_F_SOFTPCMVOL))
                        (void)mixer_set_softpcmvol(m, d, l, r);
                else if ((dev == SOUND_MIXER_TREBLE ||
                    dev == SOUND_MIXER_BASS) && (d->flags & SD_F_EQ))
                        (void)mixer_set_eq(m, d, dev, (l + r) >> 1);
                else if (realdev != SOUND_MIXER_NONE &&
                    MIXER_SET(m, realdev, l, r) < 0) {
                        MIXER_SET_LOCK(m, dropmtx);
                        return (-1);
                }
        }
 
        MIXER_SET_LOCK(m, dropmtx);
 
        m->level[dev] = l | (r << 8);
        m->modify_counter++;
 
        return (0);
}
 
static int
mixer_get(struct snd_mixer *mixer, int dev)
{
        if ((dev < SOUND_MIXER_NRDEVICES) && (mixer->devs & (1 << dev))) {
                if (mixer->mutedevs & (1 << dev))
                        return (mixer->level_muted[dev]);
                else
                        return (mixer->level[dev]);
        } else {
                return (-1);
        }
}
 
void
mix_setmutedevs(struct snd_mixer *mixer, u_int32_t mutedevs)
{
        u_int32_t delta;
 
        /* Filter out invalid values. */
        mutedevs &= mixer->devs;
        delta = (mixer->mutedevs ^ mutedevs) & mixer->devs;
        mixer->mutedevs = mutedevs;
 
        for (int i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
                if (!(delta & (1 << i)))
                        continue;
                if (mutedevs & (1 << i)) {
                        mixer->level_muted[i] = mixer->level[i];
                        mixer_set(mixer, i, 0, 0);
                } else {
                        mixer_set(mixer, i, 0, mixer->level_muted[i]);
                }
        }
}
 
static int
mixer_setrecsrc(struct snd_mixer *mixer, u_int32_t src)
{
        struct snddev_info *d;
        u_int32_t recsrc;
        int dropmtx;
 
        d = device_get_softc(mixer->dev);
        if (d == NULL)
                return -1;
        if (!(d->flags & SD_F_MPSAFE) && mtx_owned(mixer->lock) != 0)
                dropmtx = 1;
        else
                dropmtx = 0;
        src &= mixer->recdevs;
        if (src == 0)
                src = mixer->recdevs & SOUND_MASK_MIC;
        if (src == 0)
                src = mixer->recdevs & SOUND_MASK_MONITOR;
        if (src == 0)
                src = mixer->recdevs & SOUND_MASK_LINE;
        if (src == 0 && mixer->recdevs != 0)
                src = (1 << (ffs(mixer->recdevs) - 1));
        /* It is safe to drop this mutex due to Giant. */
        MIXER_SET_UNLOCK(mixer, dropmtx);
        recsrc = MIXER_SETRECSRC(mixer, src);
        MIXER_SET_LOCK(mixer, dropmtx);
 
        mixer->recsrc = recsrc;
 
        return 0;
}
 
static int
mixer_getrecsrc(struct snd_mixer *mixer)
{
        return mixer->recsrc;
}
 
static int
mixer_get_recroute(struct snd_mixer *m, int *route)
{
        int i, cnt;
 
        cnt = 0;
 
        for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
                if ((1 << i) == m->recsrc)
                        break;
                if ((1 << i) & m->recdevs)
                        ++cnt;
        }
 
        if (i == SOUND_MIXER_NRDEVICES)
                return EIDRM;
 
        *route = cnt;
        return 0;
}
 
static int
mixer_set_recroute(struct snd_mixer *m, int route)
{
        int i, cnt, ret;
 
        ret = 0;
        cnt = 0;
 
        for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
                if ((1 << i) & m->recdevs) {
                        if (route == cnt)
                                break;
                        ++cnt;
                }
        }
 
        if (i == SOUND_MIXER_NRDEVICES)
                ret = EINVAL;
        else
                ret = mixer_setrecsrc(m, (1 << i));
 
        return ret;
}
 
void
mix_setdevs(struct snd_mixer *m, u_int32_t v)
{
        struct snddev_info *d;
        int i;
 
        if (m == NULL)
                return;
 
        d = device_get_softc(m->dev);
        if (d != NULL && (d->flags & SD_F_SOFTPCMVOL))
                v |= SOUND_MASK_PCM;
        if (d != NULL && (d->flags & SD_F_EQ))
                v |= SOUND_MASK_TREBLE | SOUND_MASK_BASS;
        for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
                if (m->parent[i] < SOUND_MIXER_NRDEVICES)
                        v |= 1 << m->parent[i];
                v |= m->child[i];
        }
        m->devs = v;
}
 
void
mix_setrecdevs(struct snd_mixer *m, u_int32_t v)
{
        oss_mixer_enuminfo *ei;
        char *loc;
        int i, nvalues, nwrote, nleft, ncopied;
 
        ei = &m->enuminfo;
 
        nvalues = 0;
        nwrote = 0;
        nleft = sizeof(ei->strings);
        loc = ei->strings;
 
        for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
                if ((1 << i) & v) {
                        ei->strindex[nvalues] = nwrote;
                        ncopied = strlcpy(loc, snd_mixernames[i], nleft) + 1;
                            /* strlcpy retval doesn't include terminator */
 
                        nwrote += ncopied;
                        nleft -= ncopied;
                        nvalues++;
 
                        /*
                         * XXX I don't think this should ever be possible.
                         * Even with a move to dynamic device/channel names,
                         * each label is limited to ~16 characters, so that'd
                         * take a LOT to fill this buffer.
                         */
                        if ((nleft <= 0) || (nvalues >= OSS_ENUM_MAXVALUE)) {
                                device_printf(m->dev,
                                    "mix_setrecdevs:  Not enough room to store device names--please file a bug report.\n");
                                device_printf(m->dev, 
                                    "mix_setrecdevs:  Please include details about your sound hardware, OS version, etc.\n");
                                break;
                        }
 
                        loc = &ei->strings[nwrote];
                }
        }
 
        /*
         * NB:  The SNDCTL_DSP_GET_RECSRC_NAMES ioctl ignores the dev
         *      and ctrl fields.
         */
        ei->nvalues = nvalues;
        m->recdevs = v;
}
 
void
mix_setparentchild(struct snd_mixer *m, u_int32_t parent, u_int32_t childs)
{
        u_int32_t mask = 0;
        int i;
 
        if (m == NULL || parent >= SOUND_MIXER_NRDEVICES)
                return;
        for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
                if (i == parent)
                        continue;
                if (childs & (1 << i)) {
                        mask |= 1 << i;
                        if (m->parent[i] < SOUND_MIXER_NRDEVICES)
                                m->child[m->parent[i]] &= ~(1 << i);
                        m->parent[i] = parent;
                        m->child[i] = 0;
                }
        }
        mask &= ~(1 << parent);
        m->child[parent] = mask;
}
 
void
mix_setrealdev(struct snd_mixer *m, u_int32_t dev, u_int32_t realdev)
{
        if (m == NULL || dev >= SOUND_MIXER_NRDEVICES ||
            !(realdev == SOUND_MIXER_NONE || realdev < SOUND_MIXER_NRDEVICES))
                return;
        m->realdev[dev] = realdev;
}
 
u_int32_t
mix_getparent(struct snd_mixer *m, u_int32_t dev)
{
        if (m == NULL || dev >= SOUND_MIXER_NRDEVICES)
                return SOUND_MIXER_NONE;
        return m->parent[dev];
}
 
u_int32_t
mix_getchild(struct snd_mixer *m, u_int32_t dev)
{
        if (m == NULL || dev >= SOUND_MIXER_NRDEVICES)
                return 0;
        return m->child[dev];
}
 
u_int32_t
mix_getdevs(struct snd_mixer *m)
{
        return m->devs;
}
 
u_int32_t
mix_getmutedevs(struct snd_mixer *m)
{
        return m->mutedevs;
}
 
u_int32_t
mix_getrecdevs(struct snd_mixer *m)
{
        return m->recdevs;
}
 
void *
mix_getdevinfo(struct snd_mixer *m)
{
        return m->devinfo;
}
 
static struct snd_mixer *
mixer_obj_create(device_t dev, kobj_class_t cls, void *devinfo,
    int type, const char *desc)
{
        struct snd_mixer *m;
        int i;
 
        KASSERT(dev != NULL && cls != NULL && devinfo != NULL,
            ("%s(): NULL data dev=%p cls=%p devinfo=%p",
            __func__, dev, cls, devinfo));
        KASSERT(type == MIXER_TYPE_PRIMARY || type == MIXER_TYPE_SECONDARY,
            ("invalid mixer type=%d", type));
 
        m = (struct snd_mixer *)kobj_create(cls, M_MIXER, M_WAITOK | M_ZERO);
        snprintf(m->name, sizeof(m->name), "%s:mixer",
            device_get_nameunit(dev));
        if (desc != NULL) {
                strlcat(m->name, ":", sizeof(m->name));
                strlcat(m->name, desc, sizeof(m->name));
        }
        m->lock = snd_mtxcreate(m->name, (type == MIXER_TYPE_PRIMARY) ?
            "primary pcm mixer" : "secondary pcm mixer");
        m->type = type;
        m->devinfo = devinfo;
        m->busy = 0;
        m->dev = dev;
        for (i = 0; i < (sizeof(m->parent) / sizeof(m->parent[0])); i++) {
                m->parent[i] = SOUND_MIXER_NONE;
                m->child[i] = 0;
                m->realdev[i] = i;
        }
 
        if (MIXER_INIT(m)) {
                snd_mtxlock(m->lock);
                snd_mtxfree(m->lock);
                kobj_delete((kobj_t)m, M_MIXER);
                return (NULL);
        }
 
        return (m);
}
 
int
mixer_delete(struct snd_mixer *m)
{
        KASSERT(m != NULL, ("NULL snd_mixer"));
        KASSERT(m->type == MIXER_TYPE_SECONDARY,
            ("%s(): illegal mixer type=%d", __func__, m->type));
 
        /* mixer uninit can sleep --hps */
 
        MIXER_UNINIT(m);
 
        snd_mtxfree(m->lock);
        kobj_delete((kobj_t)m, M_MIXER);
 
        --mixer_count;
 
        return (0);
}
 
struct snd_mixer *
mixer_create(device_t dev, kobj_class_t cls, void *devinfo, const char *desc)
{
        struct snd_mixer *m;
 
        m = mixer_obj_create(dev, cls, devinfo, MIXER_TYPE_SECONDARY, desc);
 
        if (m != NULL)
                ++mixer_count;
 
        return (m);
}
 
int
mixer_init(device_t dev, kobj_class_t cls, void *devinfo)
{
        struct snddev_info *snddev;
        struct snd_mixer *m;
        u_int16_t v;
        struct cdev *pdev;
        int i, unit, devunit, val;
 
        snddev = device_get_softc(dev);
        if (snddev == NULL)
                return (-1);
 
        if (resource_int_value(device_get_name(dev),
            device_get_unit(dev), "eq", &val) == 0 && val != 0) {
                snddev->flags |= SD_F_EQ;
                if ((val & SD_F_EQ_MASK) == val)
                        snddev->flags |= val;
                else
                        snddev->flags |= SD_F_EQ_DEFAULT;
                snddev->eqpreamp = 0;
        }
 
        m = mixer_obj_create(dev, cls, devinfo, MIXER_TYPE_PRIMARY, NULL);
        if (m == NULL)
                return (-1);
 
        for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
                v = snd_mixerdefaults[i];
 
                if (resource_int_value(device_get_name(dev),
                    device_get_unit(dev), snd_mixernames[i], &val) == 0) {
                        if (val >= 0 && val <= 100) {
                                v = (u_int16_t) val;
                        }
                }
 
                mixer_set(m, i, 0, v | (v << 8));
        }
 
        mixer_setrecsrc(m, 0); /* Set default input. */
 
        unit = device_get_unit(dev);
        devunit = snd_mkunit(unit, SND_DEV_CTL, 0);
        pdev = make_dev(&mixer_cdevsw, PCMMINOR(devunit),
                 UID_ROOT, GID_WHEEL, 0666, "mixer%d", unit);
        pdev->si_drv1 = m;
        snddev->mixer_dev = pdev;
 
        ++mixer_count;
 
        if (bootverbose) {
                for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
                        if (!(m->devs & (1 << i)))
                                continue;
                        if (m->realdev[i] != i) {
                                device_printf(dev, "Mixer \"%s\" -> \"%s\":",
                                    snd_mixernames[i],
                                    (m->realdev[i] < SOUND_MIXER_NRDEVICES) ?
                                    snd_mixernames[m->realdev[i]] : "none");
                        } else {
                                device_printf(dev, "Mixer \"%s\":",
                                    snd_mixernames[i]);
                        }
                        if (m->parent[i] < SOUND_MIXER_NRDEVICES)
                                printf(" parent=\"%s\"",
                                    snd_mixernames[m->parent[i]]);
                        if (m->child[i] != 0)
                                printf(" child=0x%08x", m->child[i]);
                        printf("\n");
                }
                if (snddev->flags & SD_F_SOFTPCMVOL)
                        device_printf(dev, "Soft PCM mixer ENABLED\n");
                if (snddev->flags & SD_F_EQ)
                        device_printf(dev, "EQ Treble/Bass ENABLED\n");
        }
 
        return (0);
}
 
int
mixer_uninit(device_t dev)
{
        int i;
        struct snddev_info *d;
        struct snd_mixer *m;
        struct cdev *pdev;
 
        d = device_get_softc(dev);
        pdev = mixer_get_devt(dev);
        if (d == NULL || pdev == NULL || pdev->si_drv1 == NULL)
                return EBADF;
 
        m = pdev->si_drv1;
        KASSERT(m != NULL, ("NULL snd_mixer"));
        KASSERT(m->type == MIXER_TYPE_PRIMARY,
            ("%s(): illegal mixer type=%d", __func__, m->type));
 
        snd_mtxlock(m->lock);
 
        if (m->busy) {
                snd_mtxunlock(m->lock);
                return EBUSY;
        }
 
        /* destroy dev can sleep --hps */
 
        snd_mtxunlock(m->lock);
 
        pdev->si_drv1 = NULL;
        destroy_dev(pdev);
 
        snd_mtxlock(m->lock);
 
        for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
                mixer_set(m, i, 0, 0);
 
        mixer_setrecsrc(m, SOUND_MASK_MIC);
 
        snd_mtxunlock(m->lock);
 
        /* mixer uninit can sleep --hps */
 
        MIXER_UNINIT(m);
 
        snd_mtxfree(m->lock);
        kobj_delete((kobj_t)m, M_MIXER);
 
        d->mixer_dev = NULL;
 
        --mixer_count;
 
        return 0;
}
 
int
mixer_reinit(device_t dev)
{
        struct snd_mixer *m;
        struct cdev *pdev;
        int i;
 
        pdev = mixer_get_devt(dev);
        m = pdev->si_drv1;
        snd_mtxlock(m->lock);
 
        i = MIXER_REINIT(m);
        if (i) {
                snd_mtxunlock(m->lock);
                return i;
        }
 
        for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
                if (m->mutedevs & (1 << i))
                        mixer_set(m, i, 0, 0);
                else
                        mixer_set(m, i, 0, m->level[i]);
        }
 
        mixer_setrecsrc(m, m->recsrc);
        snd_mtxunlock(m->lock);
 
        return 0;
}
 
static int
sysctl_hw_snd_hwvol_mixer(SYSCTL_HANDLER_ARGS)
{
        char devname[32];
        int error, dev;
        struct snd_mixer *m;
 
        m = oidp->oid_arg1;
        snd_mtxlock(m->lock);
        strlcpy(devname, snd_mixernames[m->hwvol_mixer], sizeof(devname));
        snd_mtxunlock(m->lock);
        error = sysctl_handle_string(oidp, &devname[0], sizeof(devname), req);
        snd_mtxlock(m->lock);
        if (error == 0 && req->newptr != NULL) {
                dev = mixer_lookup(devname);
                if (dev == -1) {
                        snd_mtxunlock(m->lock);
                        return EINVAL;
                } else {
                        m->hwvol_mixer = dev;
                }
        }
        snd_mtxunlock(m->lock);
        return error;
}
 
int
mixer_hwvol_init(device_t dev)
{
        struct snd_mixer *m;
        struct cdev *pdev;
 
        pdev = mixer_get_devt(dev);
        m = pdev->si_drv1;
 
        m->hwvol_mixer = SOUND_MIXER_VOLUME;
        m->hwvol_step = 5;
        SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
            SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
            OID_AUTO, "hwvol_step", CTLFLAG_RWTUN, &m->hwvol_step, 0, "");
        SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
            SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
            "hwvol_mixer", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
            m, 0, sysctl_hw_snd_hwvol_mixer, "A", "");
        return 0;
}
 
void
mixer_hwvol_mute_locked(struct snd_mixer *m)
{
        mix_setmutedevs(m, m->mutedevs ^ (1 << m->hwvol_mixer));
}
 
void
mixer_hwvol_mute(device_t dev)
{
        struct snd_mixer *m;
        struct cdev *pdev;
 
        pdev = mixer_get_devt(dev);
        m = pdev->si_drv1;
        snd_mtxlock(m->lock);
        mixer_hwvol_mute_locked(m);
        snd_mtxunlock(m->lock);
}
 
void
mixer_hwvol_step_locked(struct snd_mixer *m, int left_step, int right_step)
{
        int level, left, right;
 
        level = mixer_get(m, m->hwvol_mixer);
 
        if (level != -1) {
                left = level & 0xff;
                right = (level >> 8) & 0xff;
                left += left_step * m->hwvol_step;
                if (left < 0)
                        left = 0;
                else if (left > 100)
                        left = 100;
                right += right_step * m->hwvol_step;
                if (right < 0)
                        right = 0;
                else if (right > 100)
                        right = 100;
 
                mixer_set(m, m->hwvol_mixer, m->mutedevs, left | right << 8);
        }
}
 
void
mixer_hwvol_step(device_t dev, int left_step, int right_step)
{
        struct snd_mixer *m;
        struct cdev *pdev;
 
        pdev = mixer_get_devt(dev);
        m = pdev->si_drv1;
        snd_mtxlock(m->lock);
        mixer_hwvol_step_locked(m, left_step, right_step);
        snd_mtxunlock(m->lock);
}
 
int
mixer_busy(struct snd_mixer *m)
{
        KASSERT(m != NULL, ("NULL snd_mixer"));
 
        return (m->busy);
}
 
int
mix_set(struct snd_mixer *m, u_int dev, u_int left, u_int right)
{
        int ret;
 
        KASSERT(m != NULL, ("NULL snd_mixer"));
 
        snd_mtxlock(m->lock);
        ret = mixer_set(m, dev, m->mutedevs, left | (right << 8));
        snd_mtxunlock(m->lock);
 
        return ((ret != 0) ? ENXIO : 0);
}
 
int
mix_get(struct snd_mixer *m, u_int dev)
{
        int ret;
 
        KASSERT(m != NULL, ("NULL snd_mixer"));
 
        snd_mtxlock(m->lock);
        ret = mixer_get(m, dev);
        snd_mtxunlock(m->lock);
 
        return (ret);
}
 
int
mix_setrecsrc(struct snd_mixer *m, u_int32_t src)
{
        int ret;
 
        KASSERT(m != NULL, ("NULL snd_mixer"));
 
        snd_mtxlock(m->lock);
        ret = mixer_setrecsrc(m, src);
        snd_mtxunlock(m->lock);
 
        return ((ret != 0) ? ENXIO : 0);
}
 
u_int32_t
mix_getrecsrc(struct snd_mixer *m)
{
        u_int32_t ret;
 
        KASSERT(m != NULL, ("NULL snd_mixer"));
 
        snd_mtxlock(m->lock);
        ret = mixer_getrecsrc(m);
        snd_mtxunlock(m->lock);
 
        return (ret);
}
 
int
mix_get_type(struct snd_mixer *m)
{
        KASSERT(m != NULL, ("NULL snd_mixer"));
 
        return (m->type);
}
 
device_t
mix_get_dev(struct snd_mixer *m)
{
        KASSERT(m != NULL, ("NULL snd_mixer"));
 
        return (m->dev);
}
 
/* ----------------------------------------------------------------------- */
 
static int
mixer_open(struct cdev *i_dev, int flags, int mode, struct thread *td)
{
        struct snddev_info *d;
        struct snd_mixer *m;
 
        if (i_dev == NULL || i_dev->si_drv1 == NULL)
                return (EBADF);
 
        m = i_dev->si_drv1;
        d = device_get_softc(m->dev);
        if (PCM_DETACHING(d) || !PCM_REGISTERED(d))
                return (EBADF);
 
        /* XXX Need Giant magic entry ??? */
 
        snd_mtxlock(m->lock);
        m->busy = 1;
        snd_mtxunlock(m->lock);
 
        return (0);
}
 
static int
mixer_close(struct cdev *i_dev, int flags, int mode, struct thread *td)
{
        struct snddev_info *d;
        struct snd_mixer *m;
        int ret;
 
        if (i_dev == NULL || i_dev->si_drv1 == NULL)
                return (EBADF);
 
        m = i_dev->si_drv1;
        d = device_get_softc(m->dev);
        if (!PCM_REGISTERED(d))
                return (EBADF);
 
        /* XXX Need Giant magic entry ??? */
 
        snd_mtxlock(m->lock);
        ret = (m->busy == 0) ? EBADF : 0;
        m->busy = 0;
        snd_mtxunlock(m->lock);
 
        return (ret);
}
 
static int
mixer_ioctl_channel(struct cdev *dev, u_long cmd, caddr_t arg, int mode,
    struct thread *td, int from)
{
        struct snddev_info *d;
        struct snd_mixer *m;
        struct pcm_channel *c, *rdch, *wrch;
        pid_t pid;
        int j, ret;
 
        if (td == NULL || td->td_proc == NULL)
                return (-1);
 
        m = dev->si_drv1;
        d = device_get_softc(m->dev);
        j = cmd & 0xff;
 
        switch (j) {
        case SOUND_MIXER_PCM:
        case SOUND_MIXER_RECLEV:
        case SOUND_MIXER_DEVMASK:
        case SOUND_MIXER_CAPS:
        case SOUND_MIXER_STEREODEVS:
                break;
        default:
                return (-1);
                break;
        }
 
        pid = td->td_proc->p_pid;
        rdch = NULL;
        wrch = NULL;
        c = NULL;
        ret = -1;
 
        /*
         * This is unfair. Imagine single proc opening multiple
         * instances of same direction. What we do right now
         * is looking for the first matching proc/pid, and just
         * that. Nothing more. Consider it done.
         *
         * The better approach of controlling specific channel
         * pcm or rec volume is by doing mixer ioctl
         * (SNDCTL_DSP_[SET|GET][PLAY|REC]VOL / SOUND_MIXER_[PCM|RECLEV]
         * on its open fd, rather than cracky mixer bypassing here.
         */
        CHN_FOREACH(c, d, channels.pcm.opened) {
                CHN_LOCK(c);
                if (c->pid != pid ||
                    !(c->feederflags & (1 << FEEDER_VOLUME))) {
                        CHN_UNLOCK(c);
                        continue;
                }
                if (rdch == NULL && c->direction == PCMDIR_REC) {
                        rdch = c;
                        if (j == SOUND_MIXER_RECLEV)
                                goto mixer_ioctl_channel_proc;
                } else if (wrch == NULL && c->direction == PCMDIR_PLAY) {
                        wrch = c;
                        if (j == SOUND_MIXER_PCM)
                                goto mixer_ioctl_channel_proc;
                }
                CHN_UNLOCK(c);
                if (rdch != NULL && wrch != NULL)
                        break;
        }
 
        if (rdch == NULL && wrch == NULL)
                return (-1);
 
        if ((j == SOUND_MIXER_DEVMASK || j == SOUND_MIXER_CAPS ||
            j == SOUND_MIXER_STEREODEVS) &&
            (cmd & ~0xff) == MIXER_READ(0)) {
                snd_mtxlock(m->lock);
                *(int *)arg = mix_getdevs(m);
                snd_mtxunlock(m->lock);
                if (rdch != NULL)
                        *(int *)arg |= SOUND_MASK_RECLEV;
                if (wrch != NULL)
                        *(int *)arg |= SOUND_MASK_PCM;
                ret = 0;
        }
 
        return (ret);
 
mixer_ioctl_channel_proc:
 
        KASSERT(c != NULL, ("%s(): NULL channel", __func__));
        CHN_LOCKASSERT(c);
 
        if ((cmd & ~0xff) == MIXER_WRITE(0)) {
                int left, right, center;
 
                left = *(int *)arg & 0x7f;
                right = (*(int *)arg >> 8) & 0x7f;
                center = (left + right) >> 1;
                chn_setvolume_multi(c, SND_VOL_C_PCM, left, right, center);
        } else if ((cmd & ~0xff) == MIXER_READ(0)) {
                *(int *)arg = CHN_GETVOLUME(c, SND_VOL_C_PCM, SND_CHN_T_FL);
                *(int *)arg |=
                    CHN_GETVOLUME(c, SND_VOL_C_PCM, SND_CHN_T_FR) << 8;
        }
 
        CHN_UNLOCK(c);
 
        return (0);
}
 
static int
mixer_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
    struct thread *td)
{
        struct snddev_info *d;
        int ret;
 
        if (i_dev == NULL || i_dev->si_drv1 == NULL)
                return (EBADF);
 
        d = device_get_softc(((struct snd_mixer *)i_dev->si_drv1)->dev);
        if (PCM_DETACHING(d) || !PCM_REGISTERED(d))
                return (EBADF);
 
        PCM_GIANT_ENTER(d);
        PCM_ACQUIRE_QUICK(d);
 
        ret = -1;
 
        if (mixer_bypass != 0 && (d->flags & SD_F_VPC))
                ret = mixer_ioctl_channel(i_dev, cmd, arg, mode, td,
                    MIXER_CMD_CDEV);
 
        if (ret == -1)
                ret = mixer_ioctl_cmd(i_dev, cmd, arg, mode, td,
                    MIXER_CMD_CDEV);
 
        PCM_RELEASE_QUICK(d);
        PCM_GIANT_LEAVE(d);
 
        return (ret);
}
 
static void
mixer_mixerinfo(struct snd_mixer *m, mixer_info *mi)
{
        bzero((void *)mi, sizeof(*mi));
        strlcpy(mi->id, m->name, sizeof(mi->id));
        strlcpy(mi->name, device_get_desc(m->dev), sizeof(mi->name));
        mi->modify_counter = m->modify_counter;
}
 
/*
 * XXX Make sure you can guarantee concurrency safety before calling this
 *     function, be it through Giant, PCM_*, etc !
 */
int
mixer_ioctl_cmd(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
    struct thread *td, int from)
{
        struct snd_mixer *m;
        int ret = EINVAL, *arg_i = (int *)arg;
        int v = -1, j = cmd & 0xff;
 
        /*
         * Certain ioctls may be made on any type of device (audio, mixer,
         * and MIDI).  Handle those special cases here.
         */
        if (IOCGROUP(cmd) == 'X') {
                switch (cmd) {
                case SNDCTL_SYSINFO:
                        sound_oss_sysinfo((oss_sysinfo *)arg);
                        return (0);
                case SNDCTL_CARDINFO:
                        return (sound_oss_card_info((oss_card_info *)arg));
                case SNDCTL_AUDIOINFO:
                case SNDCTL_AUDIOINFO_EX:
                case SNDCTL_ENGINEINFO:
                        return (dsp_oss_audioinfo(i_dev, (oss_audioinfo *)arg));
                case SNDCTL_MIXERINFO:
                        return (mixer_oss_mixerinfo(i_dev, (oss_mixerinfo *)arg));
                }
                return (EINVAL);
        }
 
        m = i_dev->si_drv1;
 
        if (m == NULL)
                return (EBADF);
 
        snd_mtxlock(m->lock);
        if (from == MIXER_CMD_CDEV && !m->busy) {
                snd_mtxunlock(m->lock);
                return (EBADF);
        }
        switch (cmd) {
        case SNDCTL_DSP_GET_RECSRC_NAMES:
                bcopy((void *)&m->enuminfo, arg, sizeof(oss_mixer_enuminfo));
                ret = 0;
                goto done;
        case SNDCTL_DSP_GET_RECSRC:
                ret = mixer_get_recroute(m, arg_i);
                goto done;
        case SNDCTL_DSP_SET_RECSRC:
                ret = mixer_set_recroute(m, *arg_i);
                goto done;
        case OSS_GETVERSION:
                *arg_i = SOUND_VERSION;
                ret = 0;
                goto done;
        case SOUND_MIXER_INFO:
                mixer_mixerinfo(m, (mixer_info *)arg);
                ret = 0;
                goto done;
        }
        if ((cmd & ~0xff) == MIXER_WRITE(0)) {
                switch (j) {
                case SOUND_MIXER_RECSRC:
                        ret = mixer_setrecsrc(m, *arg_i);
                        break;
                case SOUND_MIXER_MUTE:
                        mix_setmutedevs(m, *arg_i);
                        ret = 0;
                        break;
                default:
                        ret = mixer_set(m, j, m->mutedevs, *arg_i);
                        break;
                }
                snd_mtxunlock(m->lock);
                return ((ret == 0) ? 0 : ENXIO);
        }
        if ((cmd & ~0xff) == MIXER_READ(0)) {
                switch (j) {
                case SOUND_MIXER_DEVMASK:
                case SOUND_MIXER_CAPS:
                case SOUND_MIXER_STEREODEVS:
                        v = mix_getdevs(m);
                        break;
                case SOUND_MIXER_MUTE:
                        v = mix_getmutedevs(m);
                        break;
                case SOUND_MIXER_RECMASK:
                        v = mix_getrecdevs(m);
                        break;
                case SOUND_MIXER_RECSRC:
                        v = mixer_getrecsrc(m);
                        break;
                default:
                        v = mixer_get(m, j);
                        break;
                }
                *arg_i = v;
                snd_mtxunlock(m->lock);
                return ((v != -1) ? 0 : ENXIO);
        }
done:
        snd_mtxunlock(m->lock);
        return (ret);
}
 
static void
mixer_clone(void *arg,
    struct ucred *cred,
    char *name, int namelen, struct cdev **dev)
{
        struct snddev_info *d;
 
        if (*dev != NULL)
                return;
        if (strcmp(name, "mixer") == 0) {
                d = devclass_get_softc(pcm_devclass, snd_unit);
                if (PCM_REGISTERED(d) && d->mixer_dev != NULL) {
                        *dev = d->mixer_dev;
                        dev_ref(*dev);
                }
        }
}
 
static void
mixer_sysinit(void *p)
{
        if (mixer_ehtag != NULL)
                return;
        mixer_ehtag = EVENTHANDLER_REGISTER(dev_clone, mixer_clone, 0, 1000);
}
 
static void
mixer_sysuninit(void *p)
{
        if (mixer_ehtag == NULL)
                return;
        EVENTHANDLER_DEREGISTER(dev_clone, mixer_ehtag);
        mixer_ehtag = NULL;
}
 
SYSINIT(mixer_sysinit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysinit, NULL);
SYSUNINIT(mixer_sysuninit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysuninit, NULL);
 
int
mixer_oss_mixerinfo(struct cdev *i_dev, oss_mixerinfo *mi)
{
        struct snddev_info *d;
        struct snd_mixer *m;
        int nmix, i;
 
        /*
         * If probing the device handling the ioctl, make sure it's a mixer
         * device.  (This ioctl is valid on audio, mixer, and midi devices.)
         */
        if (mi->dev == -1 && i_dev->si_devsw != &mixer_cdevsw)
                return (EINVAL);
 
        d = NULL;
        m = NULL;
        nmix = 0;
 
        /*
         * There's a 1:1 relationship between mixers and PCM devices, so
         * begin by iterating over PCM devices and search for our mixer.
         */
        for (i = 0; pcm_devclass != NULL &&
            i < devclass_get_maxunit(pcm_devclass); i++) {
                d = devclass_get_softc(pcm_devclass, i);
                if (PCM_DETACHING(d) || !PCM_REGISTERED(d))
                        continue;
 
                /* XXX Need Giant magic entry */
 
                /* See the note in function docblock. */
                PCM_UNLOCKASSERT(d);
                PCM_LOCK(d);
 
                if (d->mixer_dev != NULL && d->mixer_dev->si_drv1 != NULL &&
                    ((mi->dev == -1 && d->mixer_dev == i_dev) ||
                    mi->dev == nmix)) {
                        m = d->mixer_dev->si_drv1;
                        mtx_lock(m->lock);
 
                        /*
                         * At this point, the following synchronization stuff
                         * has happened:
                         * - a specific PCM device is locked.
                         * - a specific mixer device has been locked, so be
                         *   sure to unlock when existing.
                         */
                        bzero((void *)mi, sizeof(*mi));
                        mi->dev = nmix;
                        snprintf(mi->id, sizeof(mi->id), "mixer%d", i);
                        strlcpy(mi->name, m->name, sizeof(mi->name));
                        mi->modify_counter = m->modify_counter;
                        mi->card_number = i;
                        /*
                         * Currently, FreeBSD assumes 1:1 relationship between
                         * a pcm and mixer devices, so this is hardcoded to 0.
                         */
                        mi->port_number = 0;
 
                        mi->enabled = device_is_attached(m->dev) ? 1 : 0;
                        mtx_unlock(m->lock);
                } else
                        ++nmix;
 
                PCM_UNLOCK(d);
 
                if (m != NULL)
                        return (0);
        }
 
        return (EINVAL);
}
 
/*
 * Allow the sound driver to use the mixer lock to protect its mixer
 * data:
 */
struct mtx *
mixer_get_lock(struct snd_mixer *m)
{
        if (m->lock == NULL) {
                return (&Giant);
        }
        return (m->lock);
}
 
int
mix_get_locked(struct snd_mixer *m, u_int dev, int *pleft, int *pright)
{
        int level;
 
        level = mixer_get(m, dev);
        if (level < 0) {
                *pright = *pleft = -1;
                return (-1);
        }
 
        *pleft = level & 0xFF;
        *pright = (level >> 8) & 0xFF;
 
        return (0);
}
 
int
mix_set_locked(struct snd_mixer *m, u_int dev, int left, int right)
{
        int level;
 
        level = (left & 0xFF) | ((right & 0xFF) << 8);
 
        return (mixer_set(m, dev, m->mutedevs, level));
}