/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright 2017 Joyent, Inc.
 */

/*
 * av1394 asynchronous module
 */
#include <sys/stat.h>
#include <sys/file.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/1394/targets/av1394/av1394_impl.h>

/* configuration routines */
static void     av1394_async_cleanup(av1394_inst_t *, int);
static int      av1394_async_create_minor_node(av1394_inst_t *);
static void     av1394_async_remove_minor_node(av1394_inst_t *);
static int      av1394_async_update_targetinfo(av1394_inst_t *);
static int      av1394_async_db2arq_type(int);
static void     av1394_async_putbq(av1394_queue_t *, mblk_t *);

static int      av1394_ioctl_arq_get_ibuf_size(av1394_inst_t *, void *, int);
static int      av1394_ioctl_arq_set_ibuf_size(av1394_inst_t *, void *, int);

/* tunables */
int av1394_ibuf_size_default = 64 * 1024;       /* default ibuf size */
int av1394_ibuf_size_max = 1024 * 1024;         /* max ibuf size */

/*
 *
 * --- configuration entry points
 *
 */
int
av1394_async_attach(av1394_inst_t *avp)
{
        av1394_async_t  *ap = &avp->av_a;
        ddi_iblock_cookie_t ibc = avp->av_attachinfo.iblock_cookie;

        mutex_init(&ap->a_mutex, NULL, MUTEX_DRIVER, ibc);
        av1394_initq(&ap->a_rq, ibc, av1394_ibuf_size_default);

        if (av1394_fcp_attach(avp) != DDI_SUCCESS) {
                av1394_async_cleanup(avp, 1);
                return (DDI_FAILURE);
        }

        if (av1394_cfgrom_init(avp) != DDI_SUCCESS) {
                av1394_async_cleanup(avp, 2);
                return (DDI_FAILURE);
        }

        if (av1394_async_create_minor_node(avp) != DDI_SUCCESS) {
                av1394_async_cleanup(avp, 3);
                return (DDI_FAILURE);
        }

        if (av1394_async_update_targetinfo(avp) != DDI_SUCCESS) {
                av1394_async_cleanup(avp, 4);
                return (DDI_FAILURE);
        }

        return (DDI_SUCCESS);
}

void
av1394_async_detach(av1394_inst_t *avp)
{
        av1394_async_cleanup(avp, AV1394_CLEANUP_LEVEL_MAX);
}

void
av1394_async_bus_reset(av1394_inst_t *avp)
{
        av1394_async_t  *ap = &avp->av_a;
        mblk_t          *bp;

        (void) av1394_async_update_targetinfo(avp);

        mutex_enter(&ap->a_mutex);
        if (ap->a_nopen > 0) {
                mutex_exit(&ap->a_mutex);
                return;
        }
        mutex_exit(&ap->a_mutex);

        /* queue up a bus reset message */
        if ((bp = allocb(1, BPRI_HI)) != NULL) {
                DB_TYPE(bp) = AV1394_M_BUS_RESET;
                av1394_async_putq_rq(avp, bp);
        }
}

int
av1394_async_cpr_resume(av1394_inst_t *avp)
{
        int     ret;

        ret = av1394_async_update_targetinfo(avp);

        return (ret);
}

void
av1394_async_reconnect(av1394_inst_t *avp)
{
        (void) av1394_async_update_targetinfo(avp);
}

int
av1394_async_open(av1394_inst_t *avp, int flag)
{
        av1394_async_t  *ap = &avp->av_a;

        mutex_enter(&ap->a_mutex);
        if (ap->a_nopen == 0) {
                ap->a_pollevents = 0;
        }
        ap->a_nopen++;
        ap->a_oflag = flag;
        mutex_exit(&ap->a_mutex);

        return (0);
}

/*ARGSUSED*/
int
av1394_async_close(av1394_inst_t *avp, int flag)
{
        av1394_async_t  *ap = &avp->av_a;

        av1394_cfgrom_close(avp);

        av1394_flushq(&ap->a_rq);

        mutex_enter(&ap->a_mutex);
        ap->a_nopen = 0;
        ap->a_pollevents = 0;
        mutex_exit(&ap->a_mutex);

        return (0);
}

int
av1394_async_read(av1394_inst_t *avp, struct uio *uiop)
{
        av1394_async_t  *ap = &avp->av_a;
        av1394_queue_t  *q = &ap->a_rq;
        iec61883_arq_t  arq;
        int             ret = 0;
        mblk_t          *mp;
        int             dbtype;
        int             len;

        /* copyout as much as we can */
        while ((uiop->uio_resid > 0) && (ret == 0)) {
                /*
                 * if data is available, copy it out. otherwise wait until
                 * data arrives, unless opened with non-blocking flag
                 */
                if ((mp = av1394_getq(q)) == NULL) {
                        if (ap->a_oflag & FNDELAY) {
                                return (EAGAIN);
                        }
                        if (av1394_qwait_sig(q) <= 0) {
                                ret = EINTR;
                        }
                        continue;
                }
                dbtype = AV1394_DBTYPE(mp);

                /* generate and copyout ARQ header, if not already */
                if (!AV1394_IS_NOHDR(mp)) {
                        /* headers cannot be partially read */
                        if (uiop->uio_resid < sizeof (arq)) {
                                av1394_async_putbq(q, mp);
                                ret = EINVAL;
                                break;
                        }

                        arq.arq_type = av1394_async_db2arq_type(dbtype);
                        arq.arq_len = MBLKL(mp);
                        arq.arq_data.octlet = 0;

                        /* copy ARQ-embedded data */
                        len = min(arq.arq_len, sizeof (arq.arq_data));
                        bcopy(mp->b_rptr, &arq.arq_data.buf[0], len);

                        /* copyout the ARQ */
                        ret = uiomove(&arq, sizeof (arq), UIO_READ, uiop);
                        if (ret != 0) {
                                av1394_async_putbq(q, mp);
                                break;
                        }
                        mp->b_rptr += len;
                        AV1394_MARK_NOHDR(mp);
                }

                /* any data left? */
                if (MBLKL(mp) == 0) {
                        freemsg(mp);
                        continue;
                }

                /* now we have some data and some user buffer space to fill */
                len = min(uiop->uio_resid, MBLKL(mp));
                if (len > 0) {
                        ret = uiomove(mp->b_rptr, len, UIO_READ, uiop);
                        if (ret != 0) {
                                av1394_async_putbq(q, mp);
                                break;
                        }
                        mp->b_rptr += len;
                }

                /* save the rest of the data for later */
                if (MBLKL(mp) > 0) {
                        av1394_async_putbq(q, mp);
                }
        }

        return (0);
}

int
av1394_async_write(av1394_inst_t *avp, struct uio *uiop)
{
        iec61883_arq_t  arq;
        int             ret;

        /* all data should arrive in ARQ format */
        while (uiop->uio_resid >= sizeof (arq)) {
                if ((ret = uiomove(&arq, sizeof (arq), UIO_WRITE, uiop)) != 0) {
                        break;
                }

                switch (arq.arq_type) {
                case IEC61883_ARQ_FCP_CMD:
                case IEC61883_ARQ_FCP_RESP:
                        ret = av1394_fcp_write(avp, &arq, uiop);
                        break;
                default:
                        ret = EINVAL;
                }
                if (ret != 0) {
                        break;
                }
        }

        return (ret);
}

/*ARGSUSED*/
int
av1394_async_ioctl(av1394_inst_t *avp, int cmd, intptr_t arg, int mode,
    int *rvalp)
{
        int     ret = EINVAL;

        switch (cmd) {
        case IEC61883_ARQ_GET_IBUF_SIZE:
                ret = av1394_ioctl_arq_get_ibuf_size(avp, (void *)arg, mode);
                break;
        case IEC61883_ARQ_SET_IBUF_SIZE:
                ret = av1394_ioctl_arq_set_ibuf_size(avp, (void *)arg, mode);
                break;
        case IEC61883_NODE_GET_BUS_NAME:
                ret = av1394_ioctl_node_get_bus_name(avp, (void *)arg, mode);
                break;
        case IEC61883_NODE_GET_UID:
                ret = av1394_ioctl_node_get_uid(avp, (void *)arg, mode);
                break;
        case IEC61883_NODE_GET_TEXT_LEAF:
                ret = av1394_ioctl_node_get_text_leaf(avp, (void *)arg, mode);
        }

        return (ret);
}

int
av1394_async_poll(av1394_inst_t *avp, short events, int anyyet, short *reventsp,
    struct pollhead **phpp)
{
        av1394_async_t  *ap = &avp->av_a;
        av1394_queue_t  *rq = &ap->a_rq;

        if (events & (POLLIN | POLLET)) {
                if ((events & POLLIN) && av1394_peekq(rq)) {
                        *reventsp |= POLLIN;
                }

                if ((!*reventsp && !anyyet) || (events & POLLET)) {
                        mutex_enter(&ap->a_mutex);
                        if (events & POLLIN) {
                                ap->a_pollevents |= POLLIN;
                        }
                        *phpp = &ap->a_pollhead;
                        mutex_exit(&ap->a_mutex);
                }
        }

        return (0);
}


/*
 * put a message on the read queue, take care of polling
 */
void
av1394_async_putq_rq(av1394_inst_t *avp, mblk_t *mp)
{
        av1394_async_t  *ap = &avp->av_a;

        if (!av1394_putq(&ap->a_rq, mp)) {
                freemsg(mp);
        } else {
                mutex_enter(&ap->a_mutex);
                if (ap->a_pollevents & POLLIN) {
                        ap->a_pollevents &= ~POLLIN;
                        mutex_exit(&ap->a_mutex);
                        pollwakeup(&ap->a_pollhead, POLLIN);
                } else {
                        mutex_exit(&ap->a_mutex);
                }
        }
}

/*
 *
 * --- configuration routines
 *
 * av1394_async_cleanup()
 *    Cleanup after attach
 */
static void
av1394_async_cleanup(av1394_inst_t *avp, int level)
{
        av1394_async_t  *ap = &avp->av_a;

        ASSERT((level > 0) && (level <= AV1394_CLEANUP_LEVEL_MAX));

        switch (level) {
        default:
                av1394_async_remove_minor_node(avp);
                /* FALLTHRU */
        case 3:
                av1394_cfgrom_fini(avp);
                /* FALLTHRU */
        case 2:
                av1394_fcp_detach(avp);
                /* FALLTHRU */
        case 1:
                av1394_destroyq(&ap->a_rq);
                mutex_destroy(&ap->a_mutex);
        }
}

/*
 * av1394_async_create_minor_node()
 *    Create async minor node
 */
static int
av1394_async_create_minor_node(av1394_inst_t *avp)
{
        int     ret;

        ret = ddi_create_minor_node(avp->av_dip, "async",
            S_IFCHR, AV1394_ASYNC_INST2MINOR(avp->av_instance),
            DDI_NT_AV_ASYNC, 0);
        return (ret);
}

/*
 * av1394_async_remove_minor_node()
 *    Remove async minor node
 */
static void
av1394_async_remove_minor_node(av1394_inst_t *avp)
{
        ddi_remove_minor_node(avp->av_dip, "async");
}

/*
 * av1394_async_update_targetinfo()
 *    Retrieve target info and bus generation
 */
static int
av1394_async_update_targetinfo(av1394_inst_t *avp)
{
        av1394_async_t  *ap = &avp->av_a;
        uint_t          bg;
        int             ret;

        mutex_enter(&avp->av_mutex);
        bg = avp->av_attachinfo.localinfo.bus_generation;
        mutex_exit(&avp->av_mutex);

        mutex_enter(&ap->a_mutex);
        ret = t1394_get_targetinfo(avp->av_t1394_hdl, bg, 0, &ap->a_targetinfo);
        ap->a_bus_generation = bg;
        mutex_exit(&ap->a_mutex);

        return (ret);
}

static int
av1394_async_db2arq_type(int dbtype)
{
        int     arq_type;

        switch (dbtype) {
        case AV1394_M_FCP_RESP:
                arq_type = IEC61883_ARQ_FCP_RESP;
                break;
        case AV1394_M_FCP_CMD:
                arq_type = IEC61883_ARQ_FCP_CMD;
                break;
        case AV1394_M_BUS_RESET:
                arq_type = IEC61883_ARQ_BUS_RESET;
                break;
        default:
                ASSERT(0);      /* cannot happen */
        }
        return (arq_type);
}

static void
av1394_async_putbq(av1394_queue_t *q, mblk_t *mp)
{
        if (!av1394_putbq(q, mp)) {
                freemsg(mp);
        }
}

/*ARGSUSED*/
static int
av1394_ioctl_arq_get_ibuf_size(av1394_inst_t *avp, void *arg, int mode)
{
        av1394_async_t  *ap = &avp->av_a;
        int             sz;
        int             ret = 0;

        sz = av1394_getmaxq(&ap->a_rq);

        if (ddi_copyout(&sz, arg, sizeof (sz), mode) != 0) {
                ret = EFAULT;
        }

        return (ret);
}

/*ARGSUSED*/
static int
av1394_ioctl_arq_set_ibuf_size(av1394_inst_t *avp, void *arg, int mode)
{
        av1394_async_t  *ap = &avp->av_a;
        int             sz;
        int             ret = 0;

        sz = (int)(intptr_t)arg;

        if ((sz < 0) || (sz > av1394_ibuf_size_max)) {
                ret = EINVAL;
        } else {
                av1394_setmaxq(&ap->a_rq, sz);
        }

        return (ret);
}