/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * 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>
 * Portions Copyright (c) Luigi Rizzo <luigi@FreeBSD.org> - 1997-99
 * All rights reserved.
 * Copyright (c) 2024-2025 The FreeBSD Foundation
 *
 * Portions of this software were developed by Christos Margiolis
 * <christos@FreeBSD.org> under sponsorship from the FreeBSD Foundation.
 *
 * 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 <dev/sound/pcm/vchan.h>

#include "feeder_if.h"

int report_soft_formats = 1;
SYSCTL_INT(_hw_snd, OID_AUTO, report_soft_formats, CTLFLAG_RW,
        &report_soft_formats, 0, "report software-emulated formats");

int report_soft_matrix = 1;
SYSCTL_INT(_hw_snd, OID_AUTO, report_soft_matrix, CTLFLAG_RW,
        &report_soft_matrix, 0, "report software-emulated channel matrixing");

int chn_latency = CHN_LATENCY_DEFAULT;

static int
sysctl_hw_snd_latency(SYSCTL_HANDLER_ARGS)
{
        int err, val;

        val = chn_latency;
        err = sysctl_handle_int(oidp, &val, 0, req);
        if (err != 0 || req->newptr == NULL)
                return err;
        if (val < CHN_LATENCY_MIN || val > CHN_LATENCY_MAX)
                err = EINVAL;
        else
                chn_latency = val;

        return err;
}
SYSCTL_PROC(_hw_snd, OID_AUTO, latency,
    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, 0, sizeof(int),
    sysctl_hw_snd_latency, "I",
    "buffering latency (0=low ... 10=high)");

int chn_latency_profile = CHN_LATENCY_PROFILE_DEFAULT;

static int
sysctl_hw_snd_latency_profile(SYSCTL_HANDLER_ARGS)
{
        int err, val;

        val = chn_latency_profile;
        err = sysctl_handle_int(oidp, &val, 0, req);
        if (err != 0 || req->newptr == NULL)
                return err;
        if (val < CHN_LATENCY_PROFILE_MIN || val > CHN_LATENCY_PROFILE_MAX)
                err = EINVAL;
        else
                chn_latency_profile = val;

        return err;
}
SYSCTL_PROC(_hw_snd, OID_AUTO, latency_profile,
    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, 0, sizeof(int),
    sysctl_hw_snd_latency_profile, "I",
    "buffering latency profile (0=aggressive 1=safe)");

static int chn_timeout = CHN_TIMEOUT;

static int
sysctl_hw_snd_timeout(SYSCTL_HANDLER_ARGS)
{
        int err, val;

        val = chn_timeout;
        err = sysctl_handle_int(oidp, &val, 0, req);
        if (err != 0 || req->newptr == NULL)
                return err;
        if (val < CHN_TIMEOUT_MIN || val > CHN_TIMEOUT_MAX)
                err = EINVAL;
        else
                chn_timeout = val;

        return err;
}
SYSCTL_PROC(_hw_snd, OID_AUTO, timeout,
    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, 0, sizeof(int),
    sysctl_hw_snd_timeout, "I",
    "interrupt timeout (1 - 10) seconds");

static int chn_vpc_autoreset = 1;
SYSCTL_INT(_hw_snd, OID_AUTO, vpc_autoreset, CTLFLAG_RWTUN,
        &chn_vpc_autoreset, 0, "automatically reset channels volume to 0db");

static int chn_vol_0db_pcm = SND_VOL_0DB_PCM;

static void
chn_vpc_proc(int reset, int db)
{
        struct snddev_info *d;
        struct pcm_channel *c;
        int i;

        bus_topo_lock();
        for (i = 0; pcm_devclass != NULL &&
            i < devclass_get_maxunit(pcm_devclass); i++) {
                d = devclass_get_softc(pcm_devclass, i);
                if (!PCM_REGISTERED(d))
                        continue;
                PCM_LOCK(d);
                PCM_WAIT(d);
                PCM_ACQUIRE(d);
                CHN_FOREACH(c, d, channels.pcm) {
                        CHN_LOCK(c);
                        chn_setvolume_matrix(c, SND_VOL_C_PCM, SND_CHN_T_VOL_0DB, db);
                        if (reset != 0)
                                chn_vpc_reset(c, SND_VOL_C_PCM, 1);
                        CHN_UNLOCK(c);
                }
                PCM_RELEASE(d);
                PCM_UNLOCK(d);
        }
        bus_topo_unlock();
}

static int
sysctl_hw_snd_vpc_0db(SYSCTL_HANDLER_ARGS)
{
        int err, val;

        val = chn_vol_0db_pcm;
        err = sysctl_handle_int(oidp, &val, 0, req);
        if (err != 0 || req->newptr == NULL)
                return (err);
        if (val < SND_VOL_0DB_MIN || val > SND_VOL_0DB_MAX)
                return (EINVAL);

        chn_vol_0db_pcm = val;
        chn_vpc_proc(0, val);

        return (0);
}
SYSCTL_PROC(_hw_snd, OID_AUTO, vpc_0db,
    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, 0, sizeof(int),
    sysctl_hw_snd_vpc_0db, "I",
    "0db relative level");

static int
sysctl_hw_snd_vpc_reset(SYSCTL_HANDLER_ARGS)
{
        int err, val;

        val = 0;
        err = sysctl_handle_int(oidp, &val, 0, req);
        if (err != 0 || req->newptr == NULL || val == 0)
                return (err);

        chn_vol_0db_pcm = SND_VOL_0DB_PCM;
        chn_vpc_proc(1, SND_VOL_0DB_PCM);

        return (0);
}
SYSCTL_PROC(_hw_snd, OID_AUTO, vpc_reset,
    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, 0, sizeof(int),
    sysctl_hw_snd_vpc_reset, "I",
    "reset volume on all channels");

static int chn_usefrags = 0;
static int chn_syncdelay = -1;

SYSCTL_INT(_hw_snd, OID_AUTO, usefrags, CTLFLAG_RWTUN,
        &chn_usefrags, 0, "prefer setfragments() over setblocksize()");
SYSCTL_INT(_hw_snd, OID_AUTO, syncdelay, CTLFLAG_RWTUN,
        &chn_syncdelay, 0,
        "append (0-1000) millisecond trailing buffer delay on each sync");

/**
 * @brief Channel sync group lock
 *
 * Clients should acquire this lock @b without holding any channel locks
 * before touching syncgroups or the main syncgroup list.
 */
struct mtx snd_pcm_syncgroups_mtx;
MTX_SYSINIT(pcm_syncgroup, &snd_pcm_syncgroups_mtx, "PCM channel sync group lock", MTX_DEF);
/**
 * @brief syncgroups' master list
 *
 * Each time a channel syncgroup is created, it's added to this list.  This
 * list should only be accessed with @sa snd_pcm_syncgroups_mtx held.
 *
 * See SNDCTL_DSP_SYNCGROUP for more information.
 */
struct pcm_synclist snd_pcm_syncgroups = SLIST_HEAD_INITIALIZER(snd_pcm_syncgroups);

static void
chn_lockinit(struct pcm_channel *c, int dir)
{
        switch (dir) {
        case PCMDIR_PLAY:
                mtx_init(&c->lock, c->name, "pcm play channel", MTX_DEF);
                cv_init(&c->intr_cv, "pcmwr");
                break;
        case PCMDIR_PLAY_VIRTUAL:
                mtx_init(&c->lock, c->name, "pcm virtual play channel",
                    MTX_DEF);
                cv_init(&c->intr_cv, "pcmwrv");
                break;
        case PCMDIR_REC:
                mtx_init(&c->lock, c->name, "pcm record channel", MTX_DEF);
                cv_init(&c->intr_cv, "pcmrd");
                break;
        case PCMDIR_REC_VIRTUAL:
                mtx_init(&c->lock, c->name, "pcm virtual record channel",
                    MTX_DEF);
                cv_init(&c->intr_cv, "pcmrdv");
                break;
        default:
                panic("%s(): Invalid direction=%d", __func__, dir);
                break;
        }

        cv_init(&c->cv, "pcmchn");
}

static void
chn_lockdestroy(struct pcm_channel *c)
{
        CHN_LOCKASSERT(c);

        CHN_BROADCAST(&c->cv);
        CHN_BROADCAST(&c->intr_cv);

        cv_destroy(&c->cv);
        cv_destroy(&c->intr_cv);

        mtx_destroy(&c->lock);
}

/**
 * @brief Determine channel is ready for I/O
 *
 * @retval 1 = ready for I/O
 * @retval 0 = not ready for I/O
 */
int
chn_polltrigger(struct pcm_channel *c)
{
        struct snd_dbuf *bs = c->bufsoft;
        u_int delta;

        CHN_LOCKASSERT(c);

        if (c->flags & CHN_F_MMAP) {
                if (bs->prev_total < c->lw)
                        delta = c->lw;
                else
                        delta = bs->total - bs->prev_total;
        } else {
                if (c->direction == PCMDIR_PLAY)
                        delta = sndbuf_getfree(bs);
                else
                        delta = sndbuf_getready(bs);
        }

        return ((delta < c->lw) ? 0 : 1);
}

static void
chn_pollreset(struct pcm_channel *c)
{

        CHN_LOCKASSERT(c);
        c->bufsoft->prev_total = c->bufsoft->total;
}

static void
chn_wakeup(struct pcm_channel *c)
{
        struct snd_dbuf *bs;
        struct pcm_channel *ch;

        CHN_LOCKASSERT(c);

        bs = c->bufsoft;

        if (CHN_EMPTY(c, children.busy)) {
                KNOTE_LOCKED(&bs->sel.si_note, 0);
                if (SEL_WAITING(&bs->sel) && chn_polltrigger(c))
                        selwakeuppri(&bs->sel, PRIBIO);
                CHN_BROADCAST(&c->intr_cv);
        } else {
                CHN_FOREACH(ch, c, children.busy) {
                        CHN_LOCK(ch);
                        chn_wakeup(ch);
                        CHN_UNLOCK(ch);
                }
        }
}

static int
chn_sleep(struct pcm_channel *c, int timeout)
{
        int ret;

        CHN_LOCKASSERT(c);

        if (c->flags & CHN_F_DEAD)
                return (EINVAL);

        c->sleeping++;
        ret = cv_timedwait_sig(&c->intr_cv, &c->lock, timeout);
        c->sleeping--;

        return ((c->flags & CHN_F_DEAD) ? EINVAL : ret);
}

/*
 * chn_dmaupdate() tracks the status of a dma transfer,
 * updating pointers.
 */

static unsigned int
chn_dmaupdate(struct pcm_channel *c)
{
        struct snd_dbuf *b = c->bufhard;
        unsigned int delta, old, hwptr, amt;

        KASSERT(b->bufsize > 0, ("bufsize == 0"));
        CHN_LOCKASSERT(c);

        old = b->hp;
        hwptr = chn_getptr(c);
        delta = (b->bufsize + hwptr - old) % b->bufsize;
        b->hp = hwptr;

        if (c->direction == PCMDIR_PLAY) {
                amt = min(delta, sndbuf_getready(b));
                amt -= amt % b->align;
                if (amt > 0)
                        sndbuf_dispose(b, NULL, amt);
        } else {
                amt = min(delta, sndbuf_getfree(b));
                amt -= amt % b->align;
                if (amt > 0)
                       sndbuf_acquire(b, NULL, amt);
        }
        if (snd_verbose > 3 && CHN_STARTED(c) && delta == 0) {
                device_printf(c->dev, "WARNING: %s DMA completion "
                        "too fast/slow ! hwptr=%u, old=%u "
                        "delta=%u amt=%u ready=%u free=%u\n",
                        CHN_DIRSTR(c), hwptr, old, delta, amt,
                        sndbuf_getready(b), sndbuf_getfree(b));
        }

        return delta;
}

static void
chn_wrfeed(struct pcm_channel *c)
{
        struct snd_dbuf *b = c->bufhard;
        struct snd_dbuf *bs = c->bufsoft;
        unsigned int amt, want, wasfree;

        CHN_LOCKASSERT(c);

        if ((c->flags & CHN_F_MMAP) && !(c->flags & CHN_F_CLOSING))
                sndbuf_acquire(bs, NULL, sndbuf_getfree(bs));

        wasfree = sndbuf_getfree(b);
        want = min(b->bufsize, imax(0, sndbuf_xbytes(bs->bufsize, bs, b) -
             sndbuf_getready(b)));
        amt = min(wasfree, want);
        if (amt > 0)
                sndbuf_feed(bs, b, c, c->feeder, amt);

        /*
         * Possible xruns. There should be no empty space left in buffer.
         */
        if (sndbuf_getready(b) < want)
                c->xruns++;

        if (sndbuf_getfree(b) < wasfree)
                chn_wakeup(c);
}

static void
chn_wrintr(struct pcm_channel *c)
{

        CHN_LOCKASSERT(c);
        /* update pointers in primary buffer */
        chn_dmaupdate(c);
        /* ...and feed from secondary to primary */
        chn_wrfeed(c);
        /* tell the driver we've updated the primary buffer */
        chn_trigger(c, PCMTRIG_EMLDMAWR);
}

/*
 * user write routine - uiomove data into secondary buffer, trigger if necessary
 * if blocking, sleep, rinse and repeat.
 *
 * called externally, so must handle locking
 */

int
chn_write(struct pcm_channel *c, struct uio *buf)
{
        struct snd_dbuf *bs = c->bufsoft;
        void *off;
        int ret, timeout, sz, p;

        CHN_LOCKASSERT(c);

        ret = 0;
        timeout = chn_timeout * hz;

        while (ret == 0 && buf->uio_resid > 0) {
                p = sndbuf_getfreeptr(bs);
                sz = min(buf->uio_resid, sndbuf_getfree(bs));
                sz = min(sz, bs->bufsize - p);
                if (sz > 0) {
                        off = sndbuf_getbufofs(bs, p);
                        sndbuf_acquire(bs, NULL, sz);
                        CHN_UNLOCK(c);
                        ret = uiomove(off, sz, buf);
                        CHN_LOCK(c);
                        if (ret != 0)
                                break;
                        if (CHN_STOPPED(c) && !(c->flags & CHN_F_NOTRIGGER)) {
                                ret = chn_start(c, 0);
                                if (ret != 0)
                                        c->flags |= CHN_F_DEAD;
                        }
                } else if (c->flags & (CHN_F_NBIO | CHN_F_NOTRIGGER)) {
                        /**
                         * @todo Evaluate whether EAGAIN is truly desirable.
                         *       4Front drivers behave like this, but I'm
                         *       not sure if it at all violates the "write
                         *       should be allowed to block" model.
                         *
                         *       The idea is that, while set with CHN_F_NOTRIGGER,
                         *       a channel isn't playing, *but* without this we
                         *       end up with "interrupt timeout / channel dead".
                         */
                        ret = EAGAIN;
                } else {
                        ret = chn_sleep(c, timeout);
                        if (ret == ERESTART || ret == EINTR)
                                c->flags |= CHN_F_ABORTING;
                }
        }

        return (ret);
}

/*
 * Feed new data from the read buffer. Can be called in the bottom half.
 */
static void
chn_rdfeed(struct pcm_channel *c)
{
        struct snd_dbuf *b = c->bufhard;
        struct snd_dbuf *bs = c->bufsoft;
        unsigned int amt;

        CHN_LOCKASSERT(c);

        if (c->flags & CHN_F_MMAP)
                sndbuf_dispose(bs, NULL, sndbuf_getready(bs));

        amt = sndbuf_getfree(bs);
        if (amt > 0)
                sndbuf_feed(b, bs, c, c->feeder, amt);

        amt = sndbuf_getready(b);
        if (amt > 0) {
                c->xruns++;
                sndbuf_dispose(b, NULL, amt);
        }

        if (sndbuf_getready(bs) > 0)
                chn_wakeup(c);
}

/* read interrupt routine. Must be called with interrupts blocked. */
static void
chn_rdintr(struct pcm_channel *c)
{

        CHN_LOCKASSERT(c);
        /* tell the driver to update the primary buffer if non-dma */
        chn_trigger(c, PCMTRIG_EMLDMARD);
        /* update pointers in primary buffer */
        chn_dmaupdate(c);
        /* ...and feed from primary to secondary */
        chn_rdfeed(c);
}

/*
 * user read routine - trigger if necessary, uiomove data from secondary buffer
 * if blocking, sleep, rinse and repeat.
 *
 * called externally, so must handle locking
 */

int
chn_read(struct pcm_channel *c, struct uio *buf)
{
        struct snd_dbuf *bs = c->bufsoft;
        void *off;
        int ret, timeout, sz, p;

        CHN_LOCKASSERT(c);

        if (CHN_STOPPED(c) && !(c->flags & CHN_F_NOTRIGGER)) {
                ret = chn_start(c, 0);
                if (ret != 0) {
                        c->flags |= CHN_F_DEAD;
                        return (ret);
                }
        }

        ret = 0;
        timeout = chn_timeout * hz;

        while (ret == 0 && buf->uio_resid > 0) {
                p = sndbuf_getreadyptr(bs);
                sz = min(buf->uio_resid, sndbuf_getready(bs));
                sz = min(sz, bs->bufsize - p);
                if (sz > 0) {
                        off = sndbuf_getbufofs(bs, p);
                        sndbuf_dispose(bs, NULL, sz);
                        CHN_UNLOCK(c);
                        ret = uiomove(off, sz, buf);
                        CHN_LOCK(c);
                        if (ret != 0)
                                break;
                } else if (c->flags & (CHN_F_NBIO | CHN_F_NOTRIGGER))
                        ret = EAGAIN;
                else {
                        ret = chn_sleep(c, timeout);
                        if (ret == ERESTART || ret == EINTR)
                                c->flags |= CHN_F_ABORTING;
                }
        }

        return (ret);
}

void
chn_intr(struct pcm_channel *c)
{
        CHN_LOCK(c);
        c->interrupts++;
        if (c->direction == PCMDIR_PLAY)
                chn_wrintr(c);
        else
                chn_rdintr(c);
        CHN_UNLOCK(c);
}

u_int32_t
chn_start(struct pcm_channel *c, int force)
{
        u_int32_t i, j;
        struct snd_dbuf *b = c->bufhard;
        struct snd_dbuf *bs = c->bufsoft;
        int err;

        CHN_LOCKASSERT(c);
        /* if we're running, or if we're prevented from triggering, bail */
        if (CHN_STARTED(c) || ((c->flags & CHN_F_NOTRIGGER) && !force))
                return (EINVAL);

        err = 0;

        if (force) {
                i = 1;
                j = 0;
        } else {
                if (c->direction == PCMDIR_REC) {
                        i = sndbuf_getfree(bs);
                        j = (i > 0) ? 1 : sndbuf_getready(b);
                } else {
                        if (sndbuf_getfree(bs) == 0) {
                                i = 1;
                                j = 0;
                        } else {
                                struct snd_dbuf *pb;

                                pb = CHN_BUF_PARENT(c, b);
                                i = sndbuf_xbytes(sndbuf_getready(bs), bs, pb);
                                j = pb->align;
                        }
                }
                if (snd_verbose > 3 && CHN_EMPTY(c, children))
                        device_printf(c->dev, "%s(): %s (%s) threshold "
                            "i=%d j=%d\n", __func__, CHN_DIRSTR(c),
                            (c->flags & CHN_F_VIRTUAL) ? "virtual" :
                            "hardware", i, j);
        }

        if (i >= j) {
                c->flags |= CHN_F_TRIGGERED;
                sndbuf_setrun(b, 1);
                if (c->flags & CHN_F_CLOSING)
                        c->feedcount = 2;
                else {
                        c->feedcount = 0;
                        c->interrupts = 0;
                        c->xruns = 0;
                }
                if (c->parentchannel == NULL) {
                        if (c->direction == PCMDIR_PLAY)
                                sndbuf_fillsilence_rl(b,
                                    sndbuf_xbytes(bs->bufsize, bs, b));
                        if (snd_verbose > 3)
                                device_printf(c->dev,
                                    "%s(): %s starting! (%s/%s) "
                                    "(ready=%d force=%d i=%d j=%d "
                                    "intrtimeout=%u latency=%dms)\n",
                                    __func__,
                                    (c->flags & CHN_F_HAS_VCHAN) ?
                                    "VCHAN PARENT" : "HW", CHN_DIRSTR(c),
                                    (c->flags & CHN_F_CLOSING) ? "closing" :
                                    "running",
                                    sndbuf_getready(b),
                                    force, i, j, c->timeout,
                                    (b->bufsize * 1000) /
                                    (b->align * b->spd));
                }
                err = chn_trigger(c, PCMTRIG_START);
        }

        return (err);
}

void
chn_resetbuf(struct pcm_channel *c)
{
        struct snd_dbuf *b = c->bufhard;
        struct snd_dbuf *bs = c->bufsoft;

        c->blocks = 0;
        sndbuf_reset(b);
        sndbuf_reset(bs);
}

/*
 * chn_sync waits until the space in the given channel goes above
 * a threshold. The threshold is checked against fl or rl respectively.
 * Assume that the condition can become true, do not check here...
 */
int
chn_sync(struct pcm_channel *c, int threshold)
{
        struct snd_dbuf *b, *bs;
        int ret, count, hcount, minflush, resid, residp, syncdelay, blksz;
        u_int32_t cflag;

        CHN_LOCKASSERT(c);

        if (c->direction != PCMDIR_PLAY)
                return (EINVAL);

        bs = c->bufsoft;

        if ((c->flags & (CHN_F_DEAD | CHN_F_ABORTING)) ||
            (threshold < 1 && sndbuf_getready(bs) < 1))
                return (0);

        /* if we haven't yet started and nothing is buffered, else start*/
        if (CHN_STOPPED(c)) {
                if (threshold > 0 || sndbuf_getready(bs) > 0) {
                        ret = chn_start(c, 1);
                        if (ret != 0)
                                return (ret);
                } else
                        return (0);
        }

        b = CHN_BUF_PARENT(c, c->bufhard);

        minflush = threshold + sndbuf_xbytes(sndbuf_getready(b), b, bs);

        syncdelay = chn_syncdelay;

        if (syncdelay < 0 && (threshold > 0 || sndbuf_getready(bs) > 0))
                minflush += sndbuf_xbytes(b->bufsize, b, bs);

        /*
         * Append (0-1000) millisecond trailing buffer (if needed)
         * for slower / high latency hardwares (notably USB audio)
         * to avoid audible truncation.
         */
        if (syncdelay > 0)
                minflush += (bs->align * bs->spd *
                    ((syncdelay > 1000) ? 1000 : syncdelay)) / 1000;

        minflush -= minflush % bs->align;

        if (minflush > 0) {
                threshold = min(minflush, sndbuf_getfree(bs));
                sndbuf_clear(bs, threshold);
                sndbuf_acquire(bs, NULL, threshold);
                minflush -= threshold;
        }

        resid = sndbuf_getready(bs);
        residp = resid;
        blksz = b->blksz;
        if (blksz < 1) {
                device_printf(c->dev,
                    "%s(): WARNING: blksz < 1 ! maxsize=%d [%d/%d/%d]\n",
                    __func__, b->maxsize, b->bufsize,
                    b->blksz, b->blkcnt);
                if (b->blkcnt > 0)
                        blksz = b->bufsize / b->blkcnt;
                if (blksz < 1)
                        blksz = 1;
        }
        count = sndbuf_xbytes(minflush + resid, bs, b) / blksz;
        hcount = count;
        ret = 0;

        if (snd_verbose > 3)
                device_printf(c->dev, "%s(): [begin] timeout=%d count=%d "
                    "minflush=%d resid=%d\n", __func__, c->timeout, count,
                    minflush, resid);

        cflag = c->flags & CHN_F_CLOSING;
        c->flags |= CHN_F_CLOSING;
        while (count > 0 && (resid > 0 || minflush > 0)) {
                ret = chn_sleep(c, c->timeout);
                if (ret == ERESTART || ret == EINTR) {
                        c->flags |= CHN_F_ABORTING;
                        break;
                } else if (ret == 0 || ret == EAGAIN) {
                        resid = sndbuf_getready(bs);
                        if (resid == residp) {
                                --count;
                                if (snd_verbose > 3)
                                        device_printf(c->dev,
                                            "%s(): [stalled] timeout=%d "
                                            "count=%d hcount=%d "
                                            "resid=%d minflush=%d\n",
                                            __func__, c->timeout, count,
                                            hcount, resid, minflush);
                        } else if (resid < residp && count < hcount) {
                                ++count;
                                if (snd_verbose > 3)
                                        device_printf(c->dev,
                                            "%s((): [resume] timeout=%d "
                                            "count=%d hcount=%d "
                                            "resid=%d minflush=%d\n",
                                            __func__, c->timeout, count,
                                            hcount, resid, minflush);
                        }
                        if (minflush > 0 && sndbuf_getfree(bs) > 0) {
                                threshold = min(minflush,
                                    sndbuf_getfree(bs));
                                sndbuf_clear(bs, threshold);
                                sndbuf_acquire(bs, NULL, threshold);
                                resid = sndbuf_getready(bs);
                                minflush -= threshold;
                        }
                        residp = resid;
                } else
                        break;
        }
        c->flags &= ~CHN_F_CLOSING;
        c->flags |= cflag;

        if (snd_verbose > 3)
                device_printf(c->dev,
                    "%s(): timeout=%d count=%d hcount=%d resid=%d residp=%d "
                    "minflush=%d ret=%d\n",
                    __func__, c->timeout, count, hcount, resid, residp,
                    minflush, ret);

        return (0);
}

/* called externally, handle locking */
int
chn_poll(struct pcm_channel *c, int ev, struct thread *td)
{
        struct snd_dbuf *bs = c->bufsoft;
        int ret;

        CHN_LOCKASSERT(c);

        if (!(c->flags & (CHN_F_MMAP | CHN_F_TRIGGERED))) {
                ret = chn_start(c, 1);
                if (ret != 0)
                        return (0);
        }

        ret = 0;
        if (chn_polltrigger(c)) {
                chn_pollreset(c);
                ret = ev;
        } else
                selrecord(td, &bs->sel);

        return (ret);
}

/*
 * chn_abort terminates a running dma transfer.  it may sleep up to 200ms.
 * it returns the number of bytes that have not been transferred.
 *
 * called from: dsp_close, dsp_ioctl, with channel locked
 */
int
chn_abort(struct pcm_channel *c)
{
        int missing = 0;
        struct snd_dbuf *b = c->bufhard;
        struct snd_dbuf *bs = c->bufsoft;

        CHN_LOCKASSERT(c);
        if (CHN_STOPPED(c))
                return 0;
        c->flags |= CHN_F_ABORTING;

        c->flags &= ~CHN_F_TRIGGERED;
        /* kill the channel */
        chn_trigger(c, PCMTRIG_ABORT);
        sndbuf_setrun(b, 0);
        if (!(c->flags & CHN_F_VIRTUAL))
                chn_dmaupdate(c);
        missing = sndbuf_getready(bs);

        c->flags &= ~CHN_F_ABORTING;
        return missing;
}

/*
 * this routine tries to flush the dma transfer. It is called
 * on a close of a playback channel.
 * first, if there is data in the buffer, but the dma has not yet
 * begun, we need to start it.
 * next, we wait for the play buffer to drain
 * finally, we stop the dma.
 *
 * called from: dsp_close, not valid for record channels.
 */

int
chn_flush(struct pcm_channel *c)
{
        struct snd_dbuf *b = c->bufhard;

        CHN_LOCKASSERT(c);
        KASSERT(c->direction == PCMDIR_PLAY, ("chn_flush on bad channel"));
        DEB(printf("chn_flush: c->flags 0x%08x\n", c->flags));

        c->flags |= CHN_F_CLOSING;
        chn_sync(c, 0);
        c->flags &= ~CHN_F_TRIGGERED;
        /* kill the channel */
        chn_trigger(c, PCMTRIG_ABORT);
        sndbuf_setrun(b, 0);

        c->flags &= ~CHN_F_CLOSING;
        return 0;
}

int
snd_fmtvalid(uint32_t fmt, uint32_t *fmtlist)
{
        int i;

        for (i = 0; fmtlist[i] != 0; i++) {
                if (fmt == fmtlist[i] ||
                    ((fmt & AFMT_PASSTHROUGH) &&
                    (AFMT_ENCODING(fmt) & fmtlist[i])))
                        return (1);
        }

        return (0);
}

static const struct {
        char *name, *alias1, *alias2;
        uint32_t afmt;
} afmt_tab[] = {
        {  "alaw",  NULL, NULL, AFMT_A_LAW  },
        { "mulaw",  NULL, NULL, AFMT_MU_LAW },
        {    "u8",   "8", NULL, AFMT_U8     },
        {    "s8",  NULL, NULL, AFMT_S8     },
        {   "ac3",  NULL, NULL, AFMT_AC3    },
#if BYTE_ORDER == LITTLE_ENDIAN
        { "s16le", "s16", "16", AFMT_S16_LE },
        { "s16be",  NULL, NULL, AFMT_S16_BE },
        { "s24le", "s24", "24", AFMT_S24_LE },
        { "s24be",  NULL, NULL, AFMT_S24_BE },
        { "s32le", "s32", "32", AFMT_S32_LE },
        { "s32be",  NULL, NULL, AFMT_S32_BE },
        { "f32le", "f32", NULL, AFMT_F32_LE },
        { "f32be",  NULL, NULL, AFMT_F32_BE },
        { "u16le", "u16", NULL, AFMT_U16_LE },
        { "u16be",  NULL, NULL, AFMT_U16_BE },
        { "u24le", "u24", NULL, AFMT_U24_LE },
        { "u24be",  NULL, NULL, AFMT_U24_BE },
        { "u32le", "u32", NULL, AFMT_U32_LE },
        { "u32be",  NULL, NULL, AFMT_U32_BE },
#else
        { "s16le",  NULL, NULL, AFMT_S16_LE },
        { "s16be", "s16", "16", AFMT_S16_BE },
        { "s24le",  NULL, NULL, AFMT_S24_LE },
        { "s24be", "s24", "24", AFMT_S24_BE },
        { "s32le",  NULL, NULL, AFMT_S32_LE },
        { "s32be", "s32", "32", AFMT_S32_BE },
        { "f32le",  NULL, NULL, AFMT_F32_LE },
        { "f32be", "f32", NULL, AFMT_F32_BE },
        { "u16le",  NULL, NULL, AFMT_U16_LE },
        { "u16be", "u16", NULL, AFMT_U16_BE },
        { "u24le",  NULL, NULL, AFMT_U24_LE },
        { "u24be", "u24", NULL, AFMT_U24_BE },
        { "u32le",  NULL, NULL, AFMT_U32_LE },
        { "u32be", "u32", NULL, AFMT_U32_BE },
#endif
        {    NULL,  NULL, NULL, 0           }
};

uint32_t
snd_str2afmt(const char *req)
{
        int ext;
        int ch;
        int i;
        char b1[8];
        char b2[8];

        memset(b1, 0, sizeof(b1));
        memset(b2, 0, sizeof(b2));

        i = sscanf(req, "%5[^:]:%6s", b1, b2);

        if (i == 1) {
                if (strlen(req) != strlen(b1))
                        return (0);
                strlcpy(b2, "2.0", sizeof(b2));
        } else if (i == 2) {
                if (strlen(req) != (strlen(b1) + 1 + strlen(b2)))
                        return (0);
        } else
                return (0);

        i = sscanf(b2, "%d.%d", &ch, &ext);

        if (i == 0) {
                if (strcasecmp(b2, "mono") == 0) {
                        ch = 1;
                        ext = 0;
                } else if (strcasecmp(b2, "stereo") == 0) {
                        ch = 2;
                        ext = 0;
                } else if (strcasecmp(b2, "quad") == 0) {
                        ch = 4;
                        ext = 0;
                } else
                        return (0);
        } else if (i == 1) {
                if (ch < 1 || ch > AFMT_CHANNEL_MAX)
                        return (0);
                ext = 0;
        } else if (i == 2) {
                if (ext < 0 || ext > AFMT_EXTCHANNEL_MAX)
                        return (0);
                if (ch < 1 || (ch + ext) > AFMT_CHANNEL_MAX)
                        return (0);
        } else
                return (0);

        for (i = 0; afmt_tab[i].name != NULL; i++) {
                if (strcasecmp(afmt_tab[i].name, b1) != 0) {
                        if (afmt_tab[i].alias1 == NULL)
                                continue;
                        if (strcasecmp(afmt_tab[i].alias1, b1) != 0) {
                                if (afmt_tab[i].alias2 == NULL)
                                        continue;
                                if (strcasecmp(afmt_tab[i].alias2, b1) != 0)
                                        continue;
                        }
                }
                /* found a match */
                return (SND_FORMAT(afmt_tab[i].afmt, ch + ext, ext));   
        }
        /* not a valid format */
        return (0);
}

uint32_t
snd_afmt2str(uint32_t afmt, char *buf, size_t len)
{
        uint32_t enc;
        uint32_t ext;
        uint32_t ch;
        int i;

        if (buf == NULL || len < AFMTSTR_LEN)
                return (0);

        memset(buf, 0, len);

        enc = AFMT_ENCODING(afmt);
        ch = AFMT_CHANNEL(afmt);
        ext = AFMT_EXTCHANNEL(afmt);
        /* check there is at least one channel */
        if (ch <= ext)
                return (0);
        for (i = 0; afmt_tab[i].name != NULL; i++) {
                if (enc != afmt_tab[i].afmt)
                        continue;
                /* found a match */
                snprintf(buf, len, "%s:%d.%d",
                    afmt_tab[i].name, ch - ext, ext);
                return (SND_FORMAT(enc, ch, ext));
        }
        return (0);
}

int
chn_reset(struct pcm_channel *c, uint32_t fmt, uint32_t spd)
{
        int err;

        CHN_LOCKASSERT(c);
        c->feedcount = 0;
        c->flags &= CHN_F_RESET;
        c->interrupts = 0;
        c->timeout = 1;
        c->xruns = 0;

        c->flags |= (pcm_getflags(c->dev) & SD_F_BITPERFECT) ?
            CHN_F_BITPERFECT : 0;

        if ((err = CHANNEL_RESET(c->methods, c->devinfo)))
                return (err);

        if (fmt != 0 && spd != 0) {
                if ((err = chn_setparam(c, fmt, spd)))
                        return (err);
                fmt = 0;
                spd = 0;
        }
        if (fmt != 0 && (err = chn_setformat(c, fmt)))
                return (err);
        if (spd != 0 && (err = chn_setspeed(c, spd)))
                return (err);

        if ((err = chn_setlatency(c, chn_latency)))
                return (err);

        chn_resetbuf(c);

        return (CHANNEL_RESETDONE(c->methods, c->devinfo));
}

static struct unrhdr *
chn_getunr(struct snddev_info *d, int type)
{
        switch (type) {
        case PCMDIR_PLAY:
                return (d->p_unr);
        case PCMDIR_PLAY_VIRTUAL:
                return (d->vp_unr);
        case PCMDIR_REC:
                return (d->r_unr);
        case PCMDIR_REC_VIRTUAL:
                return (d->vr_unr);
        default:
                __assert_unreachable();
        }

}

char *
chn_mkname(char *buf, size_t len, struct pcm_channel *c)
{
        const char *str;

        KASSERT(buf != NULL && len != 0,
            ("%s(): bogus buf=%p len=%zu", __func__, buf, len));

        switch (c->type) {
        case PCMDIR_PLAY:
                str = "play";
                break;
        case PCMDIR_PLAY_VIRTUAL:
                str = "virtual_play";
                break;
        case PCMDIR_REC:
                str = "record";
                break;
        case PCMDIR_REC_VIRTUAL:
                str = "virtual_record";
                break;
        default:
                __assert_unreachable();
        }

        snprintf(buf, len, "dsp%d.%s.%d",
            device_get_unit(c->dev), str, c->unit);

        return (buf);
}

struct pcm_channel *
chn_init(struct snddev_info *d, struct pcm_channel *parent, kobj_class_t cls,
    int dir, void *devinfo)
{
        struct pcm_channel *c;
        struct snd_dbuf *b, *bs;
        char buf[CHN_NAMELEN];
        int err, i, direction, *vchanrate, *vchanformat;

        PCM_BUSYASSERT(d);
        PCM_LOCKASSERT(d);

        switch (dir) {
        case PCMDIR_PLAY:
                d->playcount++;
                /* FALLTHROUGH */
        case PCMDIR_PLAY_VIRTUAL:
                if (dir == PCMDIR_PLAY_VIRTUAL)
                        d->pvchancount++;
                direction = PCMDIR_PLAY;
                vchanrate = &d->pvchanrate;
                vchanformat = &d->pvchanformat;
                break;
        case PCMDIR_REC:
                d->reccount++;
                /* FALLTHROUGH */
        case PCMDIR_REC_VIRTUAL:
                if (dir == PCMDIR_REC_VIRTUAL)
                        d->rvchancount++;
                direction = PCMDIR_REC;
                vchanrate = &d->rvchanrate;
                vchanformat = &d->rvchanformat;
                break;
        default:
                device_printf(d->dev,
                    "%s(): invalid channel direction: %d\n",
                    __func__, dir);
                return (NULL);
        }

        PCM_UNLOCK(d);
        b = NULL;
        bs = NULL;

        c = malloc(sizeof(*c), M_DEVBUF, M_WAITOK | M_ZERO);
        c->methods = kobj_create(cls, M_DEVBUF, M_WAITOK | M_ZERO);
        chn_lockinit(c, dir);
        CHN_INIT(c, children);
        CHN_INIT(c, children.busy);
        c->direction = direction;
        c->type = dir;
        c->unit = alloc_unr(chn_getunr(d, c->type));
        c->format = SND_FORMAT(AFMT_S16_LE, 2, 0);
        c->speed = 48000;
        c->pid = -1;
        c->latency = -1;
        c->timeout = 1;
        strlcpy(c->comm, CHN_COMM_UNUSED, sizeof(c->comm));
        c->parentsnddev = d;
        c->parentchannel = parent;
        c->dev = d->dev;
        c->trigger = PCMTRIG_STOP;
        strlcpy(c->name, chn_mkname(buf, sizeof(buf), c), sizeof(c->name));

        c->matrix = *feeder_matrix_id_map(SND_CHN_MATRIX_1_0);
        c->matrix.id = SND_CHN_MATRIX_PCMCHANNEL;

        for (i = 0; i < SND_CHN_T_MAX; i++)
                c->volume[SND_VOL_C_MASTER][i] = SND_VOL_0DB_MASTER;

        c->volume[SND_VOL_C_MASTER][SND_CHN_T_VOL_0DB] = SND_VOL_0DB_MASTER;
        c->volume[SND_VOL_C_PCM][SND_CHN_T_VOL_0DB] = chn_vol_0db_pcm;

        CHN_LOCK(c);
        chn_vpc_reset(c, SND_VOL_C_PCM, 1);
        CHN_UNLOCK(c);

        b = sndbuf_create(c, "primary");
        bs = sndbuf_create(c, "secondary");
        if (b == NULL || bs == NULL) {
                device_printf(d->dev, "%s(): failed to create %s buffer\n",
                    __func__, b == NULL ? "hardware" : "software");
                goto fail;
        }
        c->bufhard = b;
        c->bufsoft = bs;
        knlist_init_mtx(&bs->sel.si_note, &c->lock);

        c->devinfo = CHANNEL_INIT(c->methods, devinfo, b, c, direction);
        if (c->devinfo == NULL) {
                device_printf(d->dev, "%s(): CHANNEL_INIT() failed\n", __func__);
                goto fail;
        }

        if (b->bufsize == 0 && ((c->flags & CHN_F_VIRTUAL) == 0)) {
                device_printf(d->dev, "%s(): hardware buffer's size is 0\n",
                    __func__);
                goto fail;
        }

        sndbuf_setfmt(b, c->format);
        sndbuf_setspd(b, c->speed);
        sndbuf_setfmt(bs, c->format);
        sndbuf_setspd(bs, c->speed);
        sndbuf_setup(bs, NULL, 0);

        /**
         * @todo Should this be moved somewhere else?  The primary buffer
         *       is allocated by the driver or via DMA map setup, and tmpbuf
         *       seems to only come into existence in sndbuf_resize().
         */
        if (c->direction == PCMDIR_PLAY) {
                bs->sl = bs->maxsize;
                bs->shadbuf = malloc(bs->sl, M_DEVBUF, M_WAITOK);
        }

        if ((c->flags & CHN_F_VIRTUAL) == 0) {
                CHN_LOCK(c);
                err = chn_reset(c, c->format, c->speed);
                CHN_UNLOCK(c);
                if (err != 0)
                        goto fail;
        }

        PCM_LOCK(d);
        CHN_INSERT_SORT_ASCEND(d, c, channels.pcm);
        if ((c->flags & CHN_F_VIRTUAL) == 0) {
                CHN_INSERT_SORT_ASCEND(d, c, channels.pcm.primary);
                /* Initialize the *vchanrate/vchanformat parameters. */
                *vchanrate = c->bufsoft->spd;
                *vchanformat = c->bufsoft->fmt;
        }

        return (c);

fail:
        chn_kill(c);
        PCM_LOCK(d);

        return (NULL);
}

void
chn_kill(struct pcm_channel *c)
{
        struct snddev_info *d = c->parentsnddev;
        struct snd_dbuf *b = c->bufhard;
        struct snd_dbuf *bs = c->bufsoft;

        PCM_BUSYASSERT(c->parentsnddev);

        PCM_LOCK(d);
        CHN_REMOVE(d, c, channels.pcm);
        if ((c->flags & CHN_F_VIRTUAL) == 0)
                CHN_REMOVE(d, c, channels.pcm.primary);

        switch (c->type) {
        case PCMDIR_PLAY:
                d->playcount--;
                break;
        case PCMDIR_PLAY_VIRTUAL:
                d->pvchancount--;
                break;
        case PCMDIR_REC:
                d->reccount--;
                break;
        case PCMDIR_REC_VIRTUAL:
                d->rvchancount--;
                break;
        default:
                __assert_unreachable();
        }
        PCM_UNLOCK(d);

        if (CHN_STARTED(c)) {
                CHN_LOCK(c);
                chn_trigger(c, PCMTRIG_ABORT);
                CHN_UNLOCK(c);
        }
        free_unr(chn_getunr(d, c->type), c->unit);
        feeder_remove(c);
        if (c->devinfo)
                CHANNEL_FREE(c->methods, c->devinfo);
        if (bs) {
                knlist_clear(&bs->sel.si_note, 0);
                knlist_destroy(&bs->sel.si_note);
                sndbuf_destroy(bs);
        }
        if (b)
                sndbuf_destroy(b);
        CHN_LOCK(c);
        c->flags |= CHN_F_DEAD;
        chn_lockdestroy(c);
        kobj_delete(c->methods, M_DEVBUF);
        free(c, M_DEVBUF);
}

void
chn_shutdown(struct pcm_channel *c)
{
        CHN_LOCKASSERT(c);

        chn_wakeup(c);
        c->flags |= CHN_F_DEAD;
}

/* release a locked channel and unlock it */
int
chn_release(struct pcm_channel *c)
{
        PCM_BUSYASSERT(c->parentsnddev);
        CHN_LOCKASSERT(c);

        c->flags &= ~CHN_F_BUSY;
        c->pid = -1;
        strlcpy(c->comm, CHN_COMM_UNUSED, sizeof(c->comm));
        CHN_UNLOCK(c);

        return (0);
}

int
chn_setvolume_multi(struct pcm_channel *c, int vc, int left, int right,
    int center)
{
        int i, ret;

        ret = 0;

        for (i = 0; i < SND_CHN_T_MAX; i++) {
                if ((1 << i) & SND_CHN_LEFT_MASK)
                        ret |= chn_setvolume_matrix(c, vc, i, left);
                else if ((1 << i) & SND_CHN_RIGHT_MASK)
                        ret |= chn_setvolume_matrix(c, vc, i, right) << 8;
                else
                        ret |= chn_setvolume_matrix(c, vc, i, center) << 16;
        }

        return (ret);
}

int
chn_setvolume_matrix(struct pcm_channel *c, int vc, int vt, int val)
{
        int i;

        KASSERT(c != NULL && vc >= SND_VOL_C_MASTER && vc < SND_VOL_C_MAX &&
            (vc == SND_VOL_C_MASTER || (vc & 1)) &&
            (vt == SND_CHN_T_VOL_0DB || (vt >= SND_CHN_T_BEGIN &&
            vt <= SND_CHN_T_END)) && (vt != SND_CHN_T_VOL_0DB ||
            (val >= SND_VOL_0DB_MIN && val <= SND_VOL_0DB_MAX)),
            ("%s(): invalid volume matrix c=%p vc=%d vt=%d val=%d",
            __func__, c, vc, vt, val));
        CHN_LOCKASSERT(c);

        if (val < 0)
                val = 0;
        if (val > 100)
                val = 100;

        c->volume[vc][vt] = val;

        /*
         * Do relative calculation here and store it into class + 1
         * to ease the job of feeder_volume.
         */
        if (vc == SND_VOL_C_MASTER) {
                for (vc = SND_VOL_C_BEGIN; vc <= SND_VOL_C_END;
                    vc += SND_VOL_C_STEP)
                        c->volume[SND_VOL_C_VAL(vc)][vt] =
                            SND_VOL_CALC_VAL(c->volume, vc, vt);
        } else if (vc & 1) {
                if (vt == SND_CHN_T_VOL_0DB)
                        for (i = SND_CHN_T_BEGIN; i <= SND_CHN_T_END;
                            i += SND_CHN_T_STEP) {
                                c->volume[SND_VOL_C_VAL(vc)][i] =
                                    SND_VOL_CALC_VAL(c->volume, vc, i);
                        }
                else
                        c->volume[SND_VOL_C_VAL(vc)][vt] =
                            SND_VOL_CALC_VAL(c->volume, vc, vt);
        }

        return (val);
}

int
chn_getvolume_matrix(struct pcm_channel *c, int vc, int vt)
{
        KASSERT(c != NULL && vc >= SND_VOL_C_MASTER && vc < SND_VOL_C_MAX &&
            (vt == SND_CHN_T_VOL_0DB ||
            (vt >= SND_CHN_T_BEGIN && vt <= SND_CHN_T_END)),
            ("%s(): invalid volume matrix c=%p vc=%d vt=%d",
            __func__, c, vc, vt));
        CHN_LOCKASSERT(c);

        return (c->volume[vc][vt]);
}

int
chn_setmute_multi(struct pcm_channel *c, int vc, int mute)
{
        int i, ret;

        ret = 0;

        for (i = 0; i < SND_CHN_T_MAX; i++) {
                if ((1 << i) & SND_CHN_LEFT_MASK)
                        ret |= chn_setmute_matrix(c, vc, i, mute);
                else if ((1 << i) & SND_CHN_RIGHT_MASK)
                        ret |= chn_setmute_matrix(c, vc, i, mute) << 8;
                else
                        ret |= chn_setmute_matrix(c, vc, i, mute) << 16;
        }
        return (ret);
}

int
chn_setmute_matrix(struct pcm_channel *c, int vc, int vt, int mute)
{
        int i;

        KASSERT(c != NULL && vc >= SND_VOL_C_MASTER && vc < SND_VOL_C_MAX &&
            (vc == SND_VOL_C_MASTER || (vc & 1)) &&
            (vt == SND_CHN_T_VOL_0DB || (vt >= SND_CHN_T_BEGIN && vt <= SND_CHN_T_END)),
            ("%s(): invalid mute matrix c=%p vc=%d vt=%d mute=%d",
            __func__, c, vc, vt, mute));

        CHN_LOCKASSERT(c);

        mute = (mute != 0);

        c->muted[vc][vt] = mute;

        /*
         * Do relative calculation here and store it into class + 1
         * to ease the job of feeder_volume.
         */
        if (vc == SND_VOL_C_MASTER) {
                for (vc = SND_VOL_C_BEGIN; vc <= SND_VOL_C_END;
                    vc += SND_VOL_C_STEP)
                        c->muted[SND_VOL_C_VAL(vc)][vt] = mute;
        } else if (vc & 1) {
                if (vt == SND_CHN_T_VOL_0DB) {
                        for (i = SND_CHN_T_BEGIN; i <= SND_CHN_T_END;
                            i += SND_CHN_T_STEP) {
                                c->muted[SND_VOL_C_VAL(vc)][i] = mute;
                        }
                } else {
                        c->muted[SND_VOL_C_VAL(vc)][vt] = mute;
                }
        }
        return (mute);
}

int
chn_getmute_matrix(struct pcm_channel *c, int vc, int vt)
{
        KASSERT(c != NULL && vc >= SND_VOL_C_MASTER && vc < SND_VOL_C_MAX &&
            (vt == SND_CHN_T_VOL_0DB ||
            (vt >= SND_CHN_T_BEGIN && vt <= SND_CHN_T_END)),
            ("%s(): invalid mute matrix c=%p vc=%d vt=%d",
            __func__, c, vc, vt));
        CHN_LOCKASSERT(c);

        return (c->muted[vc][vt]);
}

struct pcmchan_matrix *
chn_getmatrix(struct pcm_channel *c)
{

        KASSERT(c != NULL, ("%s(): NULL channel", __func__));
        CHN_LOCKASSERT(c);

        if (!(c->format & AFMT_CONVERTIBLE))
                return (NULL);

        return (&c->matrix);
}

int
chn_setmatrix(struct pcm_channel *c, struct pcmchan_matrix *m)
{

        KASSERT(c != NULL && m != NULL,
            ("%s(): NULL channel or matrix", __func__));
        CHN_LOCKASSERT(c);

        if (!(c->format & AFMT_CONVERTIBLE))
                return (EINVAL);

        c->matrix = *m;
        c->matrix.id = SND_CHN_MATRIX_PCMCHANNEL;

        return (chn_setformat(c, SND_FORMAT(c->format, m->channels, m->ext)));
}

/*
 * XXX chn_oss_* exists for the sake of compatibility.
 */
int
chn_oss_getorder(struct pcm_channel *c, unsigned long long *map)
{

        KASSERT(c != NULL && map != NULL,
            ("%s(): NULL channel or map", __func__));
        CHN_LOCKASSERT(c);

        if (!(c->format & AFMT_CONVERTIBLE))
                return (EINVAL);

        return (feeder_matrix_oss_get_channel_order(&c->matrix, map));
}

int
chn_oss_setorder(struct pcm_channel *c, unsigned long long *map)
{
        struct pcmchan_matrix m;
        int ret;

        KASSERT(c != NULL && map != NULL,
            ("%s(): NULL channel or map", __func__));
        CHN_LOCKASSERT(c);

        if (!(c->format & AFMT_CONVERTIBLE))
                return (EINVAL);

        m = c->matrix;
        ret = feeder_matrix_oss_set_channel_order(&m, map);
        if (ret != 0)
                return (ret);

        return (chn_setmatrix(c, &m));
}

#define SND_CHN_OSS_FRONT       (SND_CHN_T_MASK_FL | SND_CHN_T_MASK_FR)
#define SND_CHN_OSS_SURR        (SND_CHN_T_MASK_SL | SND_CHN_T_MASK_SR)
#define SND_CHN_OSS_CENTER_LFE  (SND_CHN_T_MASK_FC | SND_CHN_T_MASK_LF)
#define SND_CHN_OSS_REAR        (SND_CHN_T_MASK_BL | SND_CHN_T_MASK_BR)

int
chn_oss_getmask(struct pcm_channel *c, uint32_t *retmask)
{
        struct pcmchan_matrix *m;
        struct pcmchan_caps *caps;
        uint32_t i, format;

        KASSERT(c != NULL && retmask != NULL,
            ("%s(): NULL channel or retmask", __func__));
        CHN_LOCKASSERT(c);

        caps = chn_getcaps(c);
        if (caps == NULL || caps->fmtlist == NULL)
                return (ENODEV);

        for (i = 0; caps->fmtlist[i] != 0; i++) {
                format = caps->fmtlist[i];
                if (!(format & AFMT_CONVERTIBLE)) {
                        *retmask |= DSP_BIND_SPDIF;
                        continue;
                }
                m = CHANNEL_GETMATRIX(c->methods, c->devinfo, format);
                if (m == NULL)
                        continue;
                if (m->mask & SND_CHN_OSS_FRONT)
                        *retmask |= DSP_BIND_FRONT;
                if (m->mask & SND_CHN_OSS_SURR)
                        *retmask |= DSP_BIND_SURR;
                if (m->mask & SND_CHN_OSS_CENTER_LFE)
                        *retmask |= DSP_BIND_CENTER_LFE;
                if (m->mask & SND_CHN_OSS_REAR)
                        *retmask |= DSP_BIND_REAR;
        }

        /* report software-supported binding mask */
        if (!CHN_BITPERFECT(c) && report_soft_matrix)
                *retmask |= DSP_BIND_FRONT | DSP_BIND_SURR |
                    DSP_BIND_CENTER_LFE | DSP_BIND_REAR;

        return (0);
}

void
chn_vpc_reset(struct pcm_channel *c, int vc, int force)
{
        int i;

        KASSERT(c != NULL && vc >= SND_VOL_C_BEGIN && vc <= SND_VOL_C_END,
            ("%s(): invalid reset c=%p vc=%d", __func__, c, vc));
        CHN_LOCKASSERT(c);

        if (force == 0 && chn_vpc_autoreset == 0)
                return;

        for (i = SND_CHN_T_BEGIN; i <= SND_CHN_T_END; i += SND_CHN_T_STEP)
                chn_setvolume_matrix(c, vc, i, c->volume[vc][SND_CHN_T_VOL_0DB]);
}

static u_int32_t
round_pow2(u_int32_t v)
{
        u_int32_t ret;

        if (v < 2)
                v = 2;
        ret = 0;
        while (v >> ret)
                ret++;
        ret = 1 << (ret - 1);
        while (ret < v)
                ret <<= 1;
        return ret;
}

static u_int32_t
round_blksz(u_int32_t v, int round)
{
        u_int32_t ret, tmp;

        if (round < 1)
                round = 1;

        ret = min(round_pow2(v), CHN_2NDBUFMAXSIZE >> 1);

        if (ret > v && (ret >> 1) > 0 && (ret >> 1) >= ((v * 3) >> 2))
                ret >>= 1;

        tmp = ret - (ret % round);
        while (tmp < 16 || tmp < round) {
                ret <<= 1;
                tmp = ret - (ret % round);
        }

        return ret;
}

/*
 * 4Front call it DSP Policy, while we call it "Latency Profile". The idea
 * is to keep 2nd buffer short so that it doesn't cause long queue during
 * buffer transfer.
 *
 *    Latency reference table for 48khz stereo 16bit: (PLAY)
 *
 *      +---------+------------+-----------+------------+
 *      | Latency | Blockcount | Blocksize | Buffersize |
 *      +---------+------------+-----------+------------+
 *      |     0   |       2    |   64      |    128     |
 *      +---------+------------+-----------+------------+
 *      |     1   |       4    |   128     |    512     |
 *      +---------+------------+-----------+------------+
 *      |     2   |       8    |   512     |    4096    |
 *      +---------+------------+-----------+------------+
 *      |     3   |      16    |   512     |    8192    |
 *      +---------+------------+-----------+------------+
 *      |     4   |      32    |   512     |    16384   |
 *      +---------+------------+-----------+------------+
 *      |     5   |      32    |   1024    |    32768   |
 *      +---------+------------+-----------+------------+
 *      |     6   |      16    |   2048    |    32768   |
 *      +---------+------------+-----------+------------+
 *      |     7   |       8    |   4096    |    32768   |
 *      +---------+------------+-----------+------------+
 *      |     8   |       4    |   8192    |    32768   |
 *      +---------+------------+-----------+------------+
 *      |     9   |       2    |   16384   |    32768   |
 *      +---------+------------+-----------+------------+
 *      |    10   |       2    |   32768   |    65536   |
 *      +---------+------------+-----------+------------+
 *
 * Recording need a different reference table. All we care is
 * gobbling up everything within reasonable buffering threshold.
 *
 *    Latency reference table for 48khz stereo 16bit: (REC)
 *
 *      +---------+------------+-----------+------------+
 *      | Latency | Blockcount | Blocksize | Buffersize |
 *      +---------+------------+-----------+------------+
 *      |     0   |     512    |   32      |    16384   |
 *      +---------+------------+-----------+------------+
 *      |     1   |     256    |   64      |    16384   |
 *      +---------+------------+-----------+------------+
 *      |     2   |     128    |   128     |    16384   |
 *      +---------+------------+-----------+------------+
 *      |     3   |      64    |   256     |    16384   |
 *      +---------+------------+-----------+------------+
 *      |     4   |      32    |   512     |    16384   |
 *      +---------+------------+-----------+------------+
 *      |     5   |      32    |   1024    |    32768   |
 *      +---------+------------+-----------+------------+
 *      |     6   |      16    |   2048    |    32768   |
 *      +---------+------------+-----------+------------+
 *      |     7   |       8    |   4096    |    32768   |
 *      +---------+------------+-----------+------------+
 *      |     8   |       4    |   8192    |    32768   |
 *      +---------+------------+-----------+------------+
 *      |     9   |       2    |   16384   |    32768   |
 *      +---------+------------+-----------+------------+
 *      |    10   |       2    |   32768   |    65536   |
 *      +---------+------------+-----------+------------+
 *
 * Calculations for other data rate are entirely based on these reference
 * tables. For normal operation, Latency 5 seems give the best, well
 * balanced performance for typical workload. Anything below 5 will
 * eat up CPU to keep up with increasing context switches because of
 * shorter buffer space and usually require the application to handle it
 * aggressively through possibly real time programming technique.
 *
 */

#define CHN_LATENCY_DATA_REF    192000 /* 48khz stereo 16bit ~ 48000 x 2 x 2 */

static int
chn_calclatency(int dir, int latency, int bps, u_int32_t datarate,
                                u_int32_t max, int *rblksz, int *rblkcnt)
{
        static int pblkcnts[CHN_LATENCY_PROFILE_MAX + 1][CHN_LATENCY_MAX + 1] = {
                {1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 1},
                {1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 1}
        };
        static int  pbufszs[CHN_LATENCY_PROFILE_MAX + 1][CHN_LATENCY_MAX + 1] = {
                {7, 9, 12, 13, 14, 15, 15, 15, 15, 15, 16},
                {11, 12, 13, 14, 15, 16, 16, 16, 16, 16, 17}
        };
        static int rblkcnts[CHN_LATENCY_PROFILE_MAX + 1][CHN_LATENCY_MAX + 1] = {
                {9, 8, 7, 6, 5, 5, 4, 3, 2, 1, 1},
                {9, 8, 7, 6, 5, 5, 4, 3, 2, 1, 1}
        };
        static int  rbufszs[CHN_LATENCY_PROFILE_MAX + 1][CHN_LATENCY_MAX + 1] = {
                {14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 16},
                {15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 17}
        };
        u_int32_t bufsz;
        int lprofile, blksz, blkcnt;

        if (latency < CHN_LATENCY_MIN || latency > CHN_LATENCY_MAX ||
            bps < 1 || datarate < 1 ||
            !(dir == PCMDIR_PLAY || dir == PCMDIR_REC)) {
                if (rblksz != NULL)
                        *rblksz = CHN_2NDBUFMAXSIZE >> 1;
                if (rblkcnt != NULL)
                        *rblkcnt = 2;
                printf("%s(): FAILED dir=%d latency=%d bps=%d "
                    "datarate=%u max=%u\n",
                    __func__, dir, latency, bps, datarate, max);
                return CHN_2NDBUFMAXSIZE;
        }

        lprofile = chn_latency_profile;

        if (dir == PCMDIR_PLAY) {
                blkcnt = pblkcnts[lprofile][latency];
                bufsz = pbufszs[lprofile][latency];
        } else {
                blkcnt = rblkcnts[lprofile][latency];
                bufsz = rbufszs[lprofile][latency];
        }

        bufsz = round_pow2(snd_xbytes(1 << bufsz, CHN_LATENCY_DATA_REF,
            datarate));
        if (bufsz > max)
                bufsz = max;
        blksz = round_blksz(bufsz >> blkcnt, bps);

        if (rblksz != NULL)
                *rblksz = blksz;
        if (rblkcnt != NULL)
                *rblkcnt = 1 << blkcnt;

        return blksz << blkcnt;
}

static int
chn_resizebuf(struct pcm_channel *c, int latency,
                                        int blkcnt, int blksz)
{
        struct snd_dbuf *b, *bs, *pb;
        int sblksz, sblkcnt, hblksz, hblkcnt, limit = 0, nsblksz, nsblkcnt;
        int ret;

        CHN_LOCKASSERT(c);

        if ((c->flags & (CHN_F_MMAP | CHN_F_TRIGGERED)) ||
            !(c->direction == PCMDIR_PLAY || c->direction == PCMDIR_REC))
                return EINVAL;

        if (latency == -1) {
                c->latency = -1;
                latency = chn_latency;
        } else if (latency == -2) {
                latency = c->latency;
                if (latency < CHN_LATENCY_MIN || latency > CHN_LATENCY_MAX)
                        latency = chn_latency;
        } else if (latency < CHN_LATENCY_MIN || latency > CHN_LATENCY_MAX)
                return EINVAL;
        else {
                c->latency = latency;
        }

        bs = c->bufsoft;
        b = c->bufhard;

        if (!(blksz == 0 || blkcnt == -1) &&
            (blksz < 16 || blksz < bs->align || blkcnt < 2 ||
            (blksz * blkcnt) > CHN_2NDBUFMAXSIZE))
                return EINVAL;

        chn_calclatency(c->direction, latency, bs->align,
            bs->align * bs->spd, CHN_2NDBUFMAXSIZE,
            &sblksz, &sblkcnt);

        if (blksz == 0 || blkcnt == -1) {
                if (blkcnt == -1)
                        c->flags &= ~CHN_F_HAS_SIZE;
                if (c->flags & CHN_F_HAS_SIZE) {
                        blksz = bs->blksz;
                        blkcnt = bs->blkcnt;
                }
        } else
                c->flags |= CHN_F_HAS_SIZE;

        if (c->flags & CHN_F_HAS_SIZE) {
                /*
                 * The application has requested their own blksz/blkcnt.
                 * Just obey with it, and let them toast alone. We can
                 * clamp it to the nearest latency profile, but that would
                 * defeat the purpose of having custom control. The least
                 * we can do is round it to the nearest ^2 and align it.
                 */
                sblksz = round_blksz(blksz, bs->align);
                sblkcnt = round_pow2(blkcnt);
        }

        if (c->parentchannel != NULL) {
                pb = c->parentchannel->bufsoft;
                CHN_UNLOCK(c);
                CHN_LOCK(c->parentchannel);
                chn_notify(c->parentchannel, CHN_N_BLOCKSIZE);
                CHN_UNLOCK(c->parentchannel);
                CHN_LOCK(c);
                if (c->direction == PCMDIR_PLAY) {
                        limit = (pb != NULL) ?
                            sndbuf_xbytes(pb->bufsize, pb, bs) : 0;
                } else {
                        limit = (pb != NULL) ?
                            sndbuf_xbytes(pb->blksz, pb, bs) * 2 : 0;
                }
        } else {
                hblkcnt = 2;
                if (c->flags & CHN_F_HAS_SIZE) {
                        hblksz = round_blksz(sndbuf_xbytes(sblksz, bs, b),
                            b->align);
                        hblkcnt = round_pow2(bs->blkcnt);
                } else
                        chn_calclatency(c->direction, latency,
                            b->align, b->align * b->spd,
                            CHN_2NDBUFMAXSIZE, &hblksz, &hblkcnt);

                if ((hblksz << 1) > b->maxsize)
                        hblksz = round_blksz(b->maxsize >> 1, b->align);

                while ((hblksz * hblkcnt) > b->maxsize) {
                        if (hblkcnt < 4)
                                hblksz >>= 1;
                        else
                                hblkcnt >>= 1;
                }

                hblksz -= hblksz % b->align;

                CHN_UNLOCK(c);
                if (chn_usefrags == 0 ||
                    CHANNEL_SETFRAGMENTS(c->methods, c->devinfo,
                    hblksz, hblkcnt) != 0)
                        b->blksz = CHANNEL_SETBLOCKSIZE(c->methods,
                            c->devinfo, hblksz);
                CHN_LOCK(c);

                if (!CHN_EMPTY(c, children)) {
                        nsblksz = round_blksz(
                            sndbuf_xbytes(b->blksz, b, bs), bs->align);
                        nsblkcnt = b->blkcnt;
                        if (c->direction == PCMDIR_PLAY) {
                                do {
                                        nsblkcnt--;
                                } while (nsblkcnt >= 2 &&
                                    nsblksz * nsblkcnt >= sblksz * sblkcnt);
                                nsblkcnt++;
                        }
                        sblksz = nsblksz;
                        sblkcnt = nsblkcnt;
                        limit = 0;
                } else
                        limit = sndbuf_xbytes(b->blksz, b, bs) * 2;
        }

        if (limit > CHN_2NDBUFMAXSIZE)
                limit = CHN_2NDBUFMAXSIZE;

        while ((sblksz * sblkcnt) < limit)
                sblkcnt <<= 1;

        while ((sblksz * sblkcnt) > CHN_2NDBUFMAXSIZE) {
                if (sblkcnt < 4)
                        sblksz >>= 1;
                else
                        sblkcnt >>= 1;
        }

        sblksz -= sblksz % bs->align;

        if (bs->blkcnt != sblkcnt || bs->blksz != sblksz ||
            bs->bufsize != (sblkcnt * sblksz)) {
                ret = sndbuf_remalloc(bs, sblkcnt, sblksz);
                if (ret != 0) {
                        device_printf(c->dev, "%s(): Failed: %d %d\n",
                            __func__, sblkcnt, sblksz);
                        return ret;
                }
        }

        /*
         * Interrupt timeout
         */
        c->timeout = ((u_int64_t)hz * bs->bufsize) /
            ((u_int64_t)bs->spd * bs->align);
        if (c->parentchannel != NULL)
                c->timeout = min(c->timeout, c->parentchannel->timeout);
        if (c->timeout < 1)
                c->timeout = 1;

        /*
         * OSSv4 docs: "By default OSS will set the low water level equal
         * to the fragment size which is optimal in most cases."
         */
        c->lw = bs->blksz;
        chn_resetbuf(c);

        if (snd_verbose > 3)
                device_printf(c->dev, "%s(): %s (%s) timeout=%u "
                    "b[%d/%d/%d] bs[%d/%d/%d] limit=%d\n",
                    __func__, CHN_DIRSTR(c),
                    (c->flags & CHN_F_VIRTUAL) ? "virtual" : "hardware",
                    c->timeout,
                    b->bufsize, b->blksz,
                    b->blkcnt,
                    bs->bufsize, bs->blksz,
                    bs->blkcnt, limit);

        return 0;
}

int
chn_setlatency(struct pcm_channel *c, int latency)
{
        CHN_LOCKASSERT(c);
        /* Destroy blksz/blkcnt, enforce latency profile. */
        return chn_resizebuf(c, latency, -1, 0);
}

int
chn_setblocksize(struct pcm_channel *c, int blkcnt, int blksz)
{
        CHN_LOCKASSERT(c);
        /* Destroy latency profile, enforce blksz/blkcnt */
        return chn_resizebuf(c, -1, blkcnt, blksz);
}

int
chn_setparam(struct pcm_channel *c, uint32_t format, uint32_t speed)
{
        struct pcmchan_caps *caps;
        uint32_t hwspeed, delta;
        int ret;

        CHN_LOCKASSERT(c);

        if (speed < 1 || format == 0 || CHN_STARTED(c))
                return (EINVAL);

        c->format = format;
        c->speed = speed;

        caps = chn_getcaps(c);

        hwspeed = speed;
        RANGE(hwspeed, caps->minspeed, caps->maxspeed);

        sndbuf_setspd(c->bufhard, CHANNEL_SETSPEED(c->methods, c->devinfo,
            hwspeed));
        hwspeed = c->bufhard->spd;

        delta = (hwspeed > speed) ? (hwspeed - speed) : (speed - hwspeed);

        if (delta <= feeder_rate_round)
                c->speed = hwspeed;

        ret = feeder_chain(c);

        if (ret == 0)
                ret = CHANNEL_SETFORMAT(c->methods, c->devinfo, c->bufhard->fmt);

        if (ret == 0)
                ret = chn_resizebuf(c, -2, 0, 0);

        return (ret);
}

int
chn_setspeed(struct pcm_channel *c, uint32_t speed)
{
        uint32_t oldformat, oldspeed;
        int ret;

        oldformat = c->format;
        oldspeed = c->speed;

        if (c->speed == speed)
                return (0);

        ret = chn_setparam(c, c->format, speed);
        if (ret != 0) {
                if (snd_verbose > 3)
                        device_printf(c->dev,
                            "%s(): Setting speed %d failed, "
                            "falling back to %d\n",
                            __func__, speed, oldspeed);
                chn_setparam(c, oldformat, oldspeed);
        }

        return (ret);
}

int
chn_setformat(struct pcm_channel *c, uint32_t format)
{
        uint32_t oldformat, oldspeed, x;
        int ret;

        /*
         * Detect unsupported formats. This checks if the format is supported
         * in the first place, and that no more than 1 format is specified at
         * the same time.
         */
        x = format & AFMT_CONVERTIBLE;
        if ((x & (x - 1)) != 0) {
                if (snd_verbose > 3) {
                        device_printf(c->dev, "%s(): Unsupported format: "
                            "0x%08x\n", __func__, format);
                }
                return (EINVAL);
        }

        /* XXX force stereo */
        if ((format & AFMT_PASSTHROUGH) && AFMT_CHANNEL(format) < 2) {
                format = SND_FORMAT(format, AFMT_PASSTHROUGH_CHANNEL,
                    AFMT_PASSTHROUGH_EXTCHANNEL);
        }

        oldformat = c->format;
        oldspeed = c->speed;

        if (c->format == format)
                return (0);

        ret = chn_setparam(c, format, c->speed);
        if (ret != 0) {
                if (snd_verbose > 3)
                        device_printf(c->dev,
                            "%s(): Format change 0x%08x failed, "
                            "falling back to 0x%08x\n",
                            __func__, format, oldformat);
                chn_setparam(c, oldformat, oldspeed);
        }

        return (ret);
}

void
chn_syncstate(struct pcm_channel *c)
{
        struct snddev_info *d;
        struct snd_mixer *m;

        d = (c != NULL) ? c->parentsnddev : NULL;
        m = (d != NULL && d->mixer_dev != NULL) ? d->mixer_dev->si_drv1 :
            NULL;

        if (d == NULL || m == NULL)
                return;

        CHN_LOCKASSERT(c);

        if (c->feederflags & (1 << FEEDER_VOLUME)) {
                uint32_t parent;
                int vol, pvol, left, right, center;

                if (c->direction == PCMDIR_PLAY &&
                    (d->flags & SD_F_SOFTPCMVOL)) {
                        /* CHN_UNLOCK(c); */
                        vol = mix_get(m, SOUND_MIXER_PCM);
                        parent = mix_getparent(m, SOUND_MIXER_PCM);
                        if (parent != SOUND_MIXER_NONE)
                                pvol = mix_get(m, parent);
                        else
                                pvol = 100 | (100 << 8);
                        /* CHN_LOCK(c); */
                } else {
                        vol = 100 | (100 << 8);
                        pvol = vol;
                }

                if (vol == -1) {
                        device_printf(c->dev,
                            "Soft PCM Volume: Failed to read pcm "
                            "default value\n");
                        vol = 100 | (100 << 8);
                }

                if (pvol == -1) {
                        device_printf(c->dev,
                            "Soft PCM Volume: Failed to read parent "
                            "default value\n");
                        pvol = 100 | (100 << 8);
                }

                left = ((vol & 0x7f) * (pvol & 0x7f)) / 100;
                right = (((vol >> 8) & 0x7f) * ((pvol >> 8) & 0x7f)) / 100;
                center = (left + right) >> 1;

                chn_setvolume_multi(c, SND_VOL_C_MASTER, left, right, center);
        }

        if (c->feederflags & (1 << FEEDER_EQ)) {
                struct pcm_feeder *f;
                int treble, bass, state;

                /* CHN_UNLOCK(c); */
                treble = mix_get(m, SOUND_MIXER_TREBLE);
                bass = mix_get(m, SOUND_MIXER_BASS);
                /* CHN_LOCK(c); */

                if (treble == -1)
                        treble = 50;
                else
                        treble = ((treble & 0x7f) +
                            ((treble >> 8) & 0x7f)) >> 1;

                if (bass == -1)
                        bass = 50;
                else
                        bass = ((bass & 0x7f) + ((bass >> 8) & 0x7f)) >> 1;

                f = feeder_find(c, FEEDER_EQ);
                if (f != NULL) {
                        if (FEEDER_SET(f, FEEDEQ_TREBLE, treble) != 0)
                                device_printf(c->dev,
                                    "EQ: Failed to set treble -- %d\n",
                                    treble);
                        if (FEEDER_SET(f, FEEDEQ_BASS, bass) != 0)
                                device_printf(c->dev,
                                    "EQ: Failed to set bass -- %d\n",
                                    bass);
                        if (FEEDER_SET(f, FEEDEQ_PREAMP, d->eqpreamp) != 0)
                                device_printf(c->dev,
                                    "EQ: Failed to set preamp -- %d\n",
                                    d->eqpreamp);
                        if (d->flags & SD_F_EQ_BYPASSED)
                                state = FEEDEQ_BYPASS;
                        else if (d->flags & SD_F_EQ_ENABLED)
                                state = FEEDEQ_ENABLE;
                        else
                                state = FEEDEQ_DISABLE;
                        if (FEEDER_SET(f, FEEDEQ_STATE, state) != 0)
                                device_printf(c->dev,
                                    "EQ: Failed to set state -- %d\n", state);
                }
        }
}

int
chn_trigger(struct pcm_channel *c, int go)
{
        struct snddev_info *d = c->parentsnddev;
        int ret;

        CHN_LOCKASSERT(c);
        if (!PCMTRIG_COMMON(go))
                return (CHANNEL_TRIGGER(c->methods, c->devinfo, go));

        if (go == c->trigger)
                return (0);

        if (snd_verbose > 3) {
                device_printf(c->dev, "%s() %s: calling go=0x%08x , "
                    "prev=0x%08x\n", __func__, c->name, go, c->trigger);
        }

        c->trigger = go;
        ret = CHANNEL_TRIGGER(c->methods, c->devinfo, go);
        if (ret != 0)
                return (ret);

        CHN_UNLOCK(c);
        PCM_LOCK(d);
        CHN_LOCK(c);

        /*
         * Do nothing if another thread set a different trigger while we had
         * dropped the mutex.
         */
        if (go != c->trigger) {
                PCM_UNLOCK(d);
                return (0);
        }

        /*
         * Use the SAFE variants to prevent inserting/removing an already
         * existing/missing element.
         */
        switch (go) {
        case PCMTRIG_START:
                CHN_INSERT_HEAD_SAFE(d, c, channels.pcm.busy);
                PCM_UNLOCK(d);
                chn_syncstate(c);
                break;
        case PCMTRIG_STOP:
        case PCMTRIG_ABORT:
                CHN_REMOVE(d, c, channels.pcm.busy);
                PCM_UNLOCK(d);
                break;
        default:
                PCM_UNLOCK(d);
                break;
        }

        return (0);
}

/**
 * @brief Queries sound driver for sample-aligned hardware buffer pointer index
 *
 * This function obtains the hardware pointer location, then aligns it to
 * the current bytes-per-sample value before returning.  (E.g., a channel
 * running in 16 bit stereo mode would require 4 bytes per sample, so a
 * hwptr value ranging from 32-35 would be returned as 32.)
 *
 * @param c     PCM channel context     
 * @returns     sample-aligned hardware buffer pointer index
 */
int
chn_getptr(struct pcm_channel *c)
{
        int hwptr;

        CHN_LOCKASSERT(c);
        hwptr = (CHN_STARTED(c)) ? CHANNEL_GETPTR(c->methods, c->devinfo) : 0;
        return (hwptr - (hwptr % c->bufhard->align));
}

struct pcmchan_caps *
chn_getcaps(struct pcm_channel *c)
{
        CHN_LOCKASSERT(c);
        return CHANNEL_GETCAPS(c->methods, c->devinfo);
}

u_int32_t
chn_getformats(struct pcm_channel *c)
{
        u_int32_t *fmtlist, fmts;
        int i;

        fmtlist = chn_getcaps(c)->fmtlist;
        fmts = 0;
        for (i = 0; fmtlist[i]; i++)
                fmts |= fmtlist[i];

        /* report software-supported formats */
        if (!CHN_BITPERFECT(c) && report_soft_formats)
                fmts |= AFMT_CONVERTIBLE;

        return (AFMT_ENCODING(fmts));
}

int
chn_notify(struct pcm_channel *c, u_int32_t flags)
{
        struct pcm_channel *ch;
        struct pcmchan_caps *caps;
        uint32_t bestformat, bestspeed, besthwformat, *vchanformat, *vchanrate;
        uint32_t vpflags;
        int dirty, err, run, nrun;

        CHN_LOCKASSERT(c);

        if (CHN_EMPTY(c, children))
                return (0);

        err = 0;

        /*
         * If the hwchan is running, we can't change its rate, format or
         * blocksize
         */
        run = CHN_STARTED(c);
        if (run)
                flags &= CHN_N_TRIGGER;

        if (flags & CHN_N_BLOCKSIZE) {
                /*
                 * Set to default latency profile
                 */
                chn_setlatency(c, chn_latency);
        }

        if (flags & CHN_N_TRIGGER) {
                if (!(c->flags & CHN_F_VCHAN_DYNAMIC)) {
                        nrun = !CHN_EMPTY(c, children.busy);
                        if (nrun && !run)
                                err = chn_start(c, 1);
                        if (!nrun && run)
                                chn_abort(c);

                        return (err);
                }

                if (c->direction == PCMDIR_PLAY) {
                        vchanformat = &c->parentsnddev->pvchanformat;
                        vchanrate = &c->parentsnddev->pvchanrate;
                } else {
                        vchanformat = &c->parentsnddev->rvchanformat;
                        vchanrate = &c->parentsnddev->rvchanrate;
                }

                if (!(c->flags & CHN_F_VCHAN_ADAPTIVE)) {
                        bestformat = *vchanformat;
                        bestspeed = *vchanrate;
                } else {
                        bestformat = 0;
                        bestspeed = 0;
                }

                besthwformat = 0;
                nrun = 0;
                caps = chn_getcaps(c);
                dirty = 0;
                vpflags = 0;

                CHN_FOREACH(ch, c, children.busy) {
                        nrun++;
                        CHN_LOCK(ch);
                        if ((ch->format & AFMT_PASSTHROUGH) &&
                            snd_fmtvalid(ch->format, caps->fmtlist)) {
                                bestformat = ch->format;
                                bestspeed = ch->speed;
                                CHN_UNLOCK(ch);
                                vpflags = CHN_F_PASSTHROUGH;
                                break;
                        }
                        if ((ch->flags & CHN_F_EXCLUSIVE) && vpflags == 0) {
                                if (c->flags & CHN_F_VCHAN_ADAPTIVE) {
                                        bestspeed = ch->speed;
                                        RANGE(bestspeed, caps->minspeed,
                                            caps->maxspeed);
                                        besthwformat = snd_fmtbest(ch->format,
                                            caps->fmtlist);
                                        if (besthwformat != 0)
                                                bestformat = besthwformat;
                                }
                                CHN_UNLOCK(ch);
                                vpflags = CHN_F_EXCLUSIVE;
                                continue;
                        }
                        if (!(c->flags & CHN_F_VCHAN_ADAPTIVE) ||
                            vpflags != 0) {
                                CHN_UNLOCK(ch);
                                continue;
                        }
                        if (ch->speed > bestspeed) {
                                bestspeed = ch->speed;
                                RANGE(bestspeed, caps->minspeed,
                                    caps->maxspeed);
                        }
                        besthwformat = snd_fmtbest(ch->format, caps->fmtlist);
                        if (!(besthwformat & AFMT_VCHAN)) {
                                CHN_UNLOCK(ch);
                                continue;
                        }
                        if (AFMT_CHANNEL(besthwformat) >
                            AFMT_CHANNEL(bestformat))
                                bestformat = besthwformat;
                        else if (AFMT_CHANNEL(besthwformat) ==
                            AFMT_CHANNEL(bestformat) &&
                            AFMT_BIT(besthwformat) > AFMT_BIT(bestformat))
                                bestformat = besthwformat;
                        CHN_UNLOCK(ch);
                }

                if (bestformat == 0)
                        bestformat = c->format;
                if (bestspeed == 0)
                        bestspeed = c->speed;

                if (bestformat != c->format || bestspeed != c->speed)
                        dirty = 1;

                c->flags &= ~(CHN_F_PASSTHROUGH | CHN_F_EXCLUSIVE);
                c->flags |= vpflags;

                if (nrun && !run) {
                        if (dirty) {
                                bestspeed = CHANNEL_SETSPEED(c->methods,
                                    c->devinfo, bestspeed);
                                err = chn_reset(c, bestformat, bestspeed);
                        }
                        if (err == 0) {
                                if (dirty) {
                                        CHN_FOREACH(ch, c, children.busy) {
                                                CHN_LOCK(ch);
                                                if (VCHAN_SYNC_REQUIRED(ch))
                                                        vchan_sync(ch);
                                                CHN_UNLOCK(ch);
                                        }
                                        c->flags |= CHN_F_DIRTY;
                                }
                                err = chn_start(c, 1);
                        }
                }

                if (nrun && run && dirty) {
                        chn_abort(c);
                        bestspeed = CHANNEL_SETSPEED(c->methods, c->devinfo,
                            bestspeed);
                        err = chn_reset(c, bestformat, bestspeed);
                        if (err == 0) {
                                CHN_FOREACH(ch, c, children.busy) {
                                        CHN_LOCK(ch);
                                        if (VCHAN_SYNC_REQUIRED(ch))
                                                vchan_sync(ch);
                                        CHN_UNLOCK(ch);
                                }
                                c->flags |= CHN_F_DIRTY;
                                err = chn_start(c, 1);
                        }
                }

                if (err == 0 && !(bestformat & AFMT_PASSTHROUGH) &&
                    (bestformat & AFMT_VCHAN)) {
                        *vchanformat = bestformat;
                        *vchanrate = bestspeed;
                }

                if (!nrun && run) {
                        c->flags &= ~(CHN_F_PASSTHROUGH | CHN_F_EXCLUSIVE);
                        bestformat = *vchanformat;
                        bestspeed = *vchanrate;
                        chn_abort(c);
                        if (c->format != bestformat || c->speed != bestspeed)
                                chn_reset(c, bestformat, bestspeed);
                }
        }

        return (err);
}

/**
 * @brief Fetch array of supported discrete sample rates
 *
 * Wrapper for CHANNEL_GETRATES.  Please see channel_if.m:getrates() for
 * detailed information.
 *
 * @note If the operation isn't supported, this function will just return 0
 *       (no rates in the array), and *rates will be set to NULL.  Callers
 *       should examine rates @b only if this function returns non-zero.
 *
 * @param c     pcm channel to examine
 * @param rates pointer to array of integers; rate table will be recorded here
 *
 * @return number of rates in the array pointed to be @c rates
 */
int
chn_getrates(struct pcm_channel *c, int **rates)
{
        KASSERT(rates != NULL, ("rates is null"));
        CHN_LOCKASSERT(c);
        return CHANNEL_GETRATES(c->methods, c->devinfo, rates);
}

/**
 * @brief Remove channel from a sync group, if there is one.
 *
 * This function is initially intended for the following conditions:
 *   - Starting a syncgroup (@c SNDCTL_DSP_SYNCSTART ioctl)
 *   - Closing a device.  (A channel can't be destroyed if it's still in use.)
 *
 * @note Before calling this function, the syncgroup list mutex must be
 * held.  (Consider pcm_channel::sm protected by the SG list mutex
 * whether @c c is locked or not.)
 *
 * @param c     channel device to be started or closed
 * @returns     If this channel was the only member of a group, the group ID
 *              is returned to the caller so that the caller can release it
 *              via free_unr() after giving up the syncgroup lock.  Else it
 *              returns 0.
 */
int
chn_syncdestroy(struct pcm_channel *c)
{
        struct pcmchan_syncmember *sm;
        struct pcmchan_syncgroup *sg;
        int sg_id;

        sg_id = 0;

        PCM_SG_LOCKASSERT(MA_OWNED);

        if (c->sm != NULL) {
                sm = c->sm;
                sg = sm->parent;
                c->sm = NULL;

                KASSERT(sg != NULL, ("syncmember has null parent"));

                SLIST_REMOVE(&sg->members, sm, pcmchan_syncmember, link);
                free(sm, M_DEVBUF);

                if (SLIST_EMPTY(&sg->members)) {
                        SLIST_REMOVE(&snd_pcm_syncgroups, sg, pcmchan_syncgroup, link);
                        sg_id = sg->id;
                        free(sg, M_DEVBUF);
                }
        }

        return sg_id;
}

#ifdef OSSV4_EXPERIMENT
int
chn_getpeaks(struct pcm_channel *c, int *lpeak, int *rpeak)
{
        CHN_LOCKASSERT(c);
        return CHANNEL_GETPEAKS(c->methods, c->devinfo, lpeak, rpeak);
}
#endif