/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (C) 4Front Technologies 1996-2008.
 *
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/sysmacros.h>
#include <sys/stropts.h>
#include <sys/strsun.h>
#include <sys/list.h>
#include <sys/mkdev.h>
#include <sys/conf.h>
#include <sys/note.h>
#include <sys/atomic.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>

#include "audio_impl.h"

/*
 * Audio DDI glue implementation.
 */

/*
 * The audio module is itself a pseudo driver, as it contains the
 * logic to support un-associated nodes.  (Think generic /dev/mixer
 * and /dev/sndstat used by OSS.)
 */
static int
audio_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        audio_dev_t     *adev;

        /* pseudo devices don't need S/R support */
        if ((cmd != DDI_ATTACH) || (dip == NULL)) {
                return (DDI_FAILURE);
        }

        if (ddi_get_instance(dip) != 0) {
                return (DDI_FAILURE);
        }

        /* this can't fail */
        adev = audio_dev_alloc(dip, 0);
        adev->d_flags = DEV_SNDSTAT_CAP;
        audio_dev_set_description(adev, "Audio Common Code");
        audio_dev_set_version(adev, "pseudo");
        ddi_set_driver_private(dip, adev);

        /* look up our properties! */

        if (audio_dev_register(adev) != DDI_SUCCESS) {
                audio_dev_free(adev);
                return (DDI_FAILURE);
        }

        ddi_report_dev(dip);

        return (DDI_SUCCESS);
}

static int
audio_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        audio_dev_t     *adev;

        /* pseudo devices don't need S/R support */
        if (cmd != DDI_DETACH) {
                return (DDI_FAILURE);
        }

        if (dip == NULL) {
                return (DDI_FAILURE);
        }

        if ((adev = ddi_get_driver_private(dip)) == NULL) {
                return (DDI_FAILURE);
        }

        if (audio_dev_unregister(adev) != DDI_SUCCESS) {
                return (DDI_FAILURE);
        }

        audio_dev_free(adev);

        return (DDI_SUCCESS);
}

static int
audio_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resp)
{
        dip = NULL;

        if (getminor((dev_t)arg) & AUDIO_MN_CLONE_MASK) {
                audio_client_t *c;
                c = auclnt_hold_by_devt((dev_t)arg);
                if (c != NULL) {
                        dip = c->c_dev->d_dip;
                        auclnt_release(c);
                }
        } else {
                audio_dev_t     *adev;
                if ((adev = auimpl_dev_hold_by_devt((dev_t)arg)) != NULL) {
                        dip = adev->d_dip;
                        auimpl_dev_release(adev);
                }
        }

        if (dip == NULL) {
                return (DDI_FAILURE);
        }

        switch (cmd) {
        case DDI_INFO_DEVT2DEVINFO:
                *resp = dip;
                break;
        case DDI_INFO_DEVT2INSTANCE:
                *resp = (void *)(uintptr_t)ddi_get_instance(dip);
                break;
        default:
                *resp = NULL;
                return (DDI_FAILURE);
        }
        return (DDI_SUCCESS);
}

static int
audio_open(dev_t *devp, int oflag, int otyp, cred_t *credp)
{
        int                     rv;
        audio_client_t          *c;

        if (otyp == OTYP_BLK) {
                return (ENXIO);
        }

        if ((c = auimpl_client_create(*devp)) == NULL) {
                audio_dev_warn(NULL, "client create failed");
                return (ENXIO);
        }

        c->c_omode = oflag;
        c->c_pid = ddi_get_pid();
        c->c_cred = credp;

        /*
         * Call client/personality specific open handler.  Note that
         * we "insist" that there is an open.  The personality layer
         * will initialize/allocate any engines required.
         *
         * Hmm... do we need to pass in the cred?
         */
        if ((rv = c->c_open(c, oflag)) != 0) {
                audio_dev_warn(c->c_dev, "open failed (rv %d)", rv);
                auimpl_client_destroy(c);
                return (rv);
        }

        /* we do device cloning! */
        *devp = makedevice(c->c_major, c->c_minor);

        /* now we can receive upcalls */
        auimpl_client_activate(c);

        atomic_inc_uint(&c->c_dev->d_serial);

        return (0);
}

static int
audio_stropen(queue_t *rq, dev_t *devp, int oflag, int sflag, cred_t *credp)
{
        int                     rv;
        audio_client_t          *c;

        if (sflag != 0) {
                /* no direct clone or module opens */
                return (ENXIO);
        }

        /*
         * Make sure its a STREAMS personality - only legacy Sun API uses
         * STREAMS.
         */
        switch (AUDIO_MN_TYPE_MASK & getminor(*devp)) {
        case AUDIO_MINOR_DEVAUDIO:
        case AUDIO_MINOR_DEVAUDIOCTL:
                break;
        default:
                return (ENOSTR);
        }

        if ((c = auimpl_client_create(*devp)) == NULL) {
                audio_dev_warn(NULL, "client create failed");
                return (ENXIO);
        }

        rq->q_ptr = WR(rq)->q_ptr = c;
        c->c_omode = oflag;
        c->c_pid = ddi_get_pid();
        c->c_cred = credp;
        c->c_rq = rq;
        c->c_wq = WR(rq);

        /*
         * Call client/personality specific open handler.  Note that
         * we "insist" that there is an open.  The personality layer
         * will initialize/allocate any engines required.
         *
         * Hmm... do we need to pass in the cred?
         */
        if ((rv = c->c_open(c, oflag)) != 0) {
                audio_dev_warn(c->c_dev, "open failed (rv %d)", rv);
                auimpl_client_destroy(c);
                return (rv);
        }

        /* we do device cloning! */
        *devp = makedevice(c->c_major, c->c_minor);

        qprocson(rq);

        /* now we can receive upcalls */
        auimpl_client_activate(c);

        atomic_inc_uint(&c->c_dev->d_serial);

        return (0);
}

static int
audio_strclose(queue_t *rq, int flag, cred_t *credp)
{
        audio_client_t  *c;
        audio_dev_t     *d;
        int             rv;

        _NOTE(ARGUNUSED(flag));
        _NOTE(ARGUNUSED(credp));

        if ((c = rq->q_ptr) == NULL) {
                return (ENXIO);
        }
        if (ddi_can_receive_sig() || (ddi_get_pid() == 0)) {
                rv = auclnt_drain(c);
        }

        /* make sure we won't get any upcalls */
        auimpl_client_deactivate(c);

        /*
         * Pick up any data sitting around in input buffers.  This
         * avoids leaving record data stuck in queues.
         */
        if (c->c_istream.s_engine != NULL)
                auimpl_input_callback(c->c_istream.s_engine);

        /* get a local hold on the device */
        d = c->c_dev;
        auimpl_dev_hold(c->c_dev);

        /* Turn off queue processing... */
        qprocsoff(rq);

        /* Call personality specific close handler */
        c->c_close(c);

        auimpl_client_destroy(c);

        /* notify peers that a change has occurred */
        atomic_inc_uint(&d->d_serial);

        /* now we can drop the release we had on the device */
        auimpl_dev_release(d);

        return (rv);
}

static int
audio_close(dev_t dev, int flag, int otyp, cred_t *credp)
{
        audio_client_t  *c;
        audio_dev_t     *d;

        _NOTE(ARGUNUSED(flag));
        _NOTE(ARGUNUSED(credp));
        _NOTE(ARGUNUSED(otyp));

        if ((c = auclnt_hold_by_devt(dev)) == NULL) {
                audio_dev_warn(NULL, "close on bogus devt %x,%x",
                    getmajor(dev), getminor(dev));
                return (ENXIO);
        }

        /* we don't want any upcalls anymore */
        auimpl_client_deactivate(c);

        /*
         * Pick up any data sitting around in input buffers.  This
         * avoids leaving record data stuck in queues.
         */
        if (c->c_istream.s_engine != NULL)
                auimpl_input_callback(c->c_istream.s_engine);

        /* get a local hold on the device */
        d = c->c_dev;
        auimpl_dev_hold(c->c_dev);

        /*
         * NB: This must be done before c->c_close, since it calls
         * auclnt_close which will block waiting for the refence count
         * to drop to zero.
         */
        auclnt_release(c);

        /* Call personality specific close handler */
        c->c_close(c);

        auimpl_client_destroy(c);

        /* notify peers that a change has occurred */
        atomic_inc_uint(&d->d_serial);

        /* now we can drop the release we had on the device */
        auimpl_dev_release(d);

        return (0);
}

static int
audio_write(dev_t dev, struct uio *uio, cred_t *credp)
{
        audio_client_t *c;
        int rv;

        if ((c = auclnt_hold_by_devt(dev)) == NULL) {
                return (ENXIO);
        }
        if ((rv = auclnt_serialize(c)) == 0) {
                rv = (c->c_write == NULL) ? ENXIO : c->c_write(c, uio, credp);
                auclnt_unserialize(c);
        }
        auclnt_release(c);

        return (rv);
}

static int
audio_read(dev_t dev, struct uio *uio, cred_t *credp)
{
        audio_client_t *c;
        int rv;

        if ((c = auclnt_hold_by_devt(dev)) == NULL) {
                return (ENXIO);
        }
        if ((rv = auclnt_serialize(c)) == 0) {
                rv = (c->c_read == NULL) ? ENXIO : c->c_read(c, uio, credp);
                auclnt_unserialize(c);
        }
        auclnt_release(c);

        return (rv);
}

static int
audio_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
    int *rvalp)
{
        audio_client_t *c;
        int rv;

        if ((c = auclnt_hold_by_devt(dev)) == NULL) {
                return (ENXIO);
        }
        rv = (c->c_ioctl == NULL) ? ENXIO : c->c_ioctl(c, cmd, arg, mode,
            credp, rvalp);
        auclnt_release(c);

        return (rv);
}

static int
audio_chpoll(dev_t dev, short events, int anyyet, short *reventsp,
    struct pollhead **phpp)
{
        audio_client_t *c;
        int rv;

        if ((c = auclnt_hold_by_devt(dev)) == NULL) {
                return (ENXIO);
        }
        rv = (c->c_chpoll == NULL) ?
            ENXIO :
            c->c_chpoll(c, events, anyyet, reventsp, phpp);
        auclnt_release(c);

        return (rv);
}

static int
audio_wput(queue_t *wq, mblk_t *mp)
{
        audio_client_t  *c;

        c = wq->q_ptr;
        if (c->c_wput) {
                c->c_wput(c, mp);
        } else {
                freemsg(mp);
        }
        return (0);
}

static int
audio_wsrv(queue_t *wq)
{
        audio_client_t  *c;

        c = wq->q_ptr;
        if (c->c_wsrv) {
                c->c_wsrv(c);
        } else {
                flushq(wq, FLUSHALL);
        }
        return (0);
}

static int
audio_rsrv(queue_t *rq)
{
        audio_client_t  *c;

        c = rq->q_ptr;
        if (c->c_rsrv) {
                c->c_rsrv(c);
        } else {
                flushq(rq, FLUSHALL);
        }
        return (0);
}


static struct dev_ops audio_dev_ops = {
        DEVO_REV,               /* rev */
        0,                      /* refcnt */
        NULL,                   /* getinfo */
        nulldev,                /* identify */
        nulldev,                /* probe */
        audio_attach,           /* attach */
        audio_detach,           /* detach */
        nodev,                  /* reset */
        NULL,                   /* cb_ops */
        NULL,                   /* bus_ops */
        NULL,                   /* power */
};

static struct modldrv modldrv = {
        &mod_driverops,
        "Audio Framework",
        &audio_dev_ops,
};

static struct modlinkage modlinkage = {
        MODREV_1,                       /* MODREV_1 indicated by manual */
        &modldrv,
        NULL
};

struct audio_ops_helper {
        struct cb_ops           cbops;  /* NB: must be first */
        struct streamtab        strtab;
        struct qinit            rqinit;
        struct qinit            wqinit;
        struct module_info      minfo;
        char                    name[MODMAXNAMELEN];
};

void
audio_init_ops(struct dev_ops *devops, const char *name)
{
        struct audio_ops_helper *helper;

        helper = kmem_zalloc(sizeof (*helper), KM_SLEEP);

        (void) strlcpy(helper->name, name, sizeof (helper->name));

        helper->minfo.mi_idnum = 0;     /* only for strlog(8) */
        helper->minfo.mi_idname = helper->name;
        helper->minfo.mi_minpsz = 0;
        helper->minfo.mi_maxpsz = 8192;
        helper->minfo.mi_hiwat = 65536;
        helper->minfo.mi_lowat = 32768;

        helper->wqinit.qi_putp = audio_wput;
        helper->wqinit.qi_srvp = audio_wsrv;
        helper->wqinit.qi_qopen = NULL;
        helper->wqinit.qi_qclose = NULL;
        helper->wqinit.qi_qadmin = NULL;
        helper->wqinit.qi_minfo = &helper->minfo;
        helper->wqinit.qi_mstat = NULL;

        helper->rqinit.qi_putp = putq;
        helper->rqinit.qi_srvp = audio_rsrv;
        helper->rqinit.qi_qopen = audio_stropen;
        helper->rqinit.qi_qclose = audio_strclose;
        helper->rqinit.qi_qadmin = NULL;
        helper->rqinit.qi_minfo = &helper->minfo;
        helper->rqinit.qi_mstat = NULL;

        helper->strtab.st_rdinit = &helper->rqinit;
        helper->strtab.st_wrinit = &helper->wqinit;
        helper->strtab.st_muxrinit = NULL;
        helper->strtab.st_muxwinit = NULL;

        helper->cbops.cb_open = audio_open;
        helper->cbops.cb_close = audio_close;
        helper->cbops.cb_strategy = nodev;
        helper->cbops.cb_print = nodev;
        helper->cbops.cb_dump = nodev;
        helper->cbops.cb_read = audio_read;
        helper->cbops.cb_write = audio_write;
        helper->cbops.cb_ioctl = audio_ioctl;
        helper->cbops.cb_devmap = nodev;
        helper->cbops.cb_mmap = nodev;
        helper->cbops.cb_segmap = nodev;
        helper->cbops.cb_chpoll = audio_chpoll;
        helper->cbops.cb_prop_op = ddi_prop_op;
        helper->cbops.cb_str = &helper->strtab;
        helper->cbops.cb_flag = D_MP | D_64BIT;
        helper->cbops.cb_rev = CB_REV;
        helper->cbops.cb_aread = nodev;
        helper->cbops.cb_awrite = nodev;

        devops->devo_cb_ops = &helper->cbops;
        devops->devo_getinfo = audio_getinfo;
}

void
audio_fini_ops(struct dev_ops *devops)
{
        kmem_free(devops->devo_cb_ops, sizeof (struct audio_ops_helper));
        devops->devo_cb_ops = NULL;
        devops->devo_getinfo = NULL;
}

void
auimpl_dev_vwarn(audio_dev_t *dev, const char *fmt, va_list va)
{
        char    buf[256];

        if (dev != NULL) {
                (void) snprintf(buf, sizeof (buf), "%s#%d: %s",
                    ddi_driver_name(dev->d_dip), ddi_get_instance(dev->d_dip),
                    fmt);
        } else {
                (void) snprintf(buf, sizeof (buf), "audio: %s", fmt);
        }

        vcmn_err(CE_WARN, buf, va);
}


void
audio_dev_warn(audio_dev_t *dev, const char *fmt, ...)
{
        va_list va;

        va_start(va, fmt);
        auimpl_dev_vwarn(dev, fmt, va);
        va_end(va);
}

/*
 * _init, _info, and _fini DDI glue.
 */
int
_init(void)
{
        int     rv;

        auimpl_client_init();
        auimpl_dev_init();
        auimpl_sun_init();
        auimpl_oss_init();

        audio_init_ops(&audio_dev_ops, "audio");

        if ((rv = mod_install(&modlinkage)) != 0) {
                audio_fini_ops(&audio_dev_ops);
                auimpl_dev_fini();
                auimpl_client_fini();
        }
        return (rv);
}

int
_info(struct modinfo *modinfop)
{
        return (mod_info(&modlinkage, modinfop));
}

int
_fini(void)
{
        int rv;

        if ((rv = mod_remove(&modlinkage)) != 0)
                return (rv);

        auimpl_dev_fini();
        auimpl_client_fini();

        return (rv);
}