/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

/* configuration routines */
static int      av1394_isoch_create_minor_node(av1394_inst_t *);
static void     av1394_isoch_remove_minor_node(av1394_inst_t *);
static void     av1394_isoch_cleanup(av1394_inst_t *, int);
av1394_isoch_seg_t *av1394_isoch_find_seg(av1394_inst_t *, offset_t, size_t);
static int      av1394_isoch_autorecv_init(av1394_inst_t *, av1394_ic_t **);
static int      av1394_isoch_autoxmit_init(av1394_inst_t *, av1394_ic_t **,
                struct uio *);

/* ioctls */
static int      av1394_ioctl_isoch_init(av1394_inst_t *, void *, int);
static av1394_ic_t *av1394_ioctl_isoch_handle2ic(av1394_inst_t *, void *);
static int      av1394_ioctl_isoch_fini(av1394_inst_t *, void *, int);
static int      av1394_ioctl_start(av1394_inst_t *, void *, int);
static int      av1394_ioctl_stop(av1394_inst_t *, void *, int);
static int      av1394_ioctl_recv(av1394_inst_t *, void *, int);
static int      av1394_ioctl_xmit(av1394_inst_t *, void *, int);

static uint_t av1394_isoch_softintr(caddr_t);

static struct devmap_callback_ctl av1394_isoch_devmap_ops = {
        DEVMAP_OPS_REV,         /* rev */
        NULL,                   /* map */
        NULL,                   /* access */
        NULL,                   /* dup */
        NULL,                   /* unmap */
};

/* tunables */
int av1394_rate_n_dv_ntsc = 246;
int av1394_rate_d_dv_ntsc = 3840;
int av1394_rate_n_dv_pal = 1;
int av1394_rate_d_dv_pal = 16;

int av1394_isoch_autorecv_nframes = 50;
int av1394_isoch_autorecv_framesz = 250;
int av1394_isoch_autoxmit_nframes = 50;
int av1394_isoch_autoxmit_framesz = 250;

int
av1394_isoch_attach(av1394_inst_t *avp)
{
        av1394_isoch_t  *ip = &avp->av_i;
        ddi_iblock_cookie_t ibc = avp->av_attachinfo.iblock_cookie;

        mutex_init(&ip->i_mutex, NULL, MUTEX_DRIVER, ibc);

        mutex_enter(&ip->i_mutex);
        if (av1394_isoch_create_minor_node(avp) != DDI_SUCCESS) {
                mutex_exit(&ip->i_mutex);
                av1394_isoch_cleanup(avp, 1);
                return (DDI_FAILURE);
        }

        if (ddi_add_softintr(avp->av_dip, DDI_SOFTINT_LOW, &ip->i_softintr_id,
            0, 0, av1394_isoch_softintr, (caddr_t)avp) != DDI_SUCCESS) {
                mutex_exit(&ip->i_mutex);
                av1394_isoch_cleanup(avp, 2);
                return (DDI_FAILURE);
        }

        if (av1394_cmp_init(avp) != DDI_SUCCESS) {
                mutex_exit(&ip->i_mutex);
                av1394_isoch_cleanup(avp, 3);
                return (DDI_FAILURE);
        }

        av1394_as_init(&ip->i_mmap_as);
        mutex_exit(&ip->i_mutex);

        return (DDI_SUCCESS);
}

void
av1394_isoch_detach(av1394_inst_t *avp)
{
        av1394_isoch_cleanup(avp, AV1394_CLEANUP_LEVEL_MAX);
}

int
av1394_isoch_cpr_suspend(av1394_inst_t *avp)
{
        av1394_isoch_t  *ip = &avp->av_i;
        av1394_ic_t     *icp;
        int             i;
        int             ret = DDI_SUCCESS;

        /*
         * suspend only if there are no active channels
         */
        mutex_enter(&ip->i_mutex);
        for (i = 0; (i < NELEM(ip->i_ic)) && (ret == DDI_SUCCESS); i++) {
                icp = ip->i_ic[i];
                if (icp) {
                        mutex_enter(&icp->ic_mutex);
                        if (icp->ic_state != AV1394_IC_IDLE) {
                                ret = DDI_FAILURE;
                        }
                        mutex_exit(&icp->ic_mutex);
                }
        }
        mutex_exit(&ip->i_mutex);

        return (ret);
}

/*ARGSUSED*/
int
av1394_isoch_close(av1394_inst_t *avp, int flag)
{
        int     ret;

        ret = av1394_ic_close(avp, flag);
        av1394_cmp_close(avp);

        return (ret);
}

int
av1394_isoch_read(av1394_inst_t *avp, struct uio *uiop)
{
        av1394_ic_t     *icp;
        int             ret;

        /* use broadcast channel */
        icp = avp->av_i.i_ic[63];
        if (icp == NULL) {
                if ((ret = av1394_isoch_autorecv_init(avp, &icp)) != 0) {
                        return (ret);
                }
        } else if (icp->ic_dir != AV1394_IR) {
                /* channel already used for xmit */
                return (EBUSY);
        }

        if ((ret = av1394_ir_start(icp)) == 0) {
                ret = av1394_ir_read(icp, uiop);
        }

        return (ret);
}

int
av1394_isoch_write(av1394_inst_t *avp, struct uio *uiop)
{
        av1394_ic_t     *icp;
        int             ret;

        /* use broadcast channel */
        icp = avp->av_i.i_ic[63];
        if (icp == NULL) {
                if ((ret = av1394_isoch_autoxmit_init(avp, &icp, uiop)) != 0) {
                        return (ret);
                }
        } else if (icp->ic_dir != AV1394_IT) {
                /* channel already used for recv */
                return (EBUSY);
        }

        ret = av1394_it_write(icp, uiop);

        return (ret);
}

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

        switch (cmd) {
        case IEC61883_ISOCH_INIT:
                ret = av1394_ioctl_isoch_init(avp, (void *)arg, mode);
                break;
        case IEC61883_ISOCH_FINI:
                ret = av1394_ioctl_isoch_fini(avp, (void *)arg, mode);
                break;
        case IEC61883_START:
                ret = av1394_ioctl_start(avp, (void *)arg, mode);
                break;
        case IEC61883_STOP:
                ret = av1394_ioctl_stop(avp, (void *)arg, mode);
                break;
        case IEC61883_RECV:
                ret = av1394_ioctl_recv(avp, (void *)arg, mode);
                break;
        case IEC61883_XMIT:
                ret = av1394_ioctl_xmit(avp, (void *)arg, mode);
                break;
        case IEC61883_PLUG_INIT:
                ret = av1394_ioctl_plug_init(avp, (void *)arg, mode);
                break;
        case IEC61883_PLUG_FINI:
                ret = av1394_ioctl_plug_fini(avp, (void *)arg, mode);
                break;
        case IEC61883_PLUG_REG_READ:
                ret = av1394_ioctl_plug_reg_read(avp, (void *)arg, mode);
                break;
        case IEC61883_PLUG_REG_CAS:
                ret = av1394_ioctl_plug_reg_cas(avp, (void *)arg, mode);
                break;
        }

        return (ret);
}

/*ARGSUSED*/
int
av1394_isoch_devmap(av1394_inst_t *avp, devmap_cookie_t dhp, offset_t off,
    size_t len, size_t *maplen, uint_t model)
{
        av1394_isoch_seg_t *isp;

        *maplen = 0;

        /* find segment */
        isp = av1394_isoch_find_seg(avp, off, ptob(btopr(len)));
        if (isp == NULL) {
                return (EINVAL);
        }

        /* map segment */
        if (devmap_umem_setup(dhp, avp->av_dip, &av1394_isoch_devmap_ops,
            isp->is_umem_cookie, 0, isp->is_umem_size, PROT_ALL, 0,
            &avp->av_attachinfo.acc_attr) != 0) {
                return (EINVAL);
        }
        *maplen = isp->is_umem_size;

        return (0);
}

/*
 *
 * --- configuration routines
 *
 * av1394_isoch_create_minor_node()
 *    Create isoch minor node
 */
static int
av1394_isoch_create_minor_node(av1394_inst_t *avp)
{
        int     ret;

        ret = ddi_create_minor_node(avp->av_dip, "isoch",
            S_IFCHR, AV1394_ISOCH_INST2MINOR(avp->av_instance),
            DDI_NT_AV_ISOCH, 0);
        return (ret);
}

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

/*
 * av1394_isoch_cleanup()
 *    Cleanup after attach
 */
static void
av1394_isoch_cleanup(av1394_inst_t *avp, int level)
{
        av1394_isoch_t  *ip = &avp->av_i;

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

        switch (level) {
        default:
                mutex_enter(&ip->i_mutex);
                av1394_as_fini(&ip->i_mmap_as);
                av1394_cmp_fini(avp);
                mutex_exit(&ip->i_mutex);
                /* FALLTHRU */
        case 3:
                ddi_remove_softintr(ip->i_softintr_id);
                /* FALLTHRU */
        case 2:
                av1394_isoch_remove_minor_node(avp);
                /* FALLTHRU */
        case 1:
                mutex_destroy(&ip->i_mutex);
        }
}

/*
 * av1394_isoch_find_seg()
 *    Given an offset and size, find a matching av1394_isoch_seg_t structure.
 */
av1394_isoch_seg_t *
av1394_isoch_find_seg(av1394_inst_t *avp, offset_t off, size_t len)
{
        av1394_isoch_t  *ip = &avp->av_i;
        av1394_ic_t     *icp;
        av1394_isoch_pool_t *pool;
        av1394_isoch_seg_t *isp;
        offset_t        segoff;
        int             i;

        /* find channel from within this range */
        for (i = 0; i < NELEM(ip->i_ic); i++) {
                icp = ip->i_ic[i];
                if (icp == NULL) {
                        continue;
                }
                if ((off >= icp->ic_mmap_off) &&
                    (off + len <= icp->ic_mmap_off + icp->ic_mmap_sz)) {
                        off -= icp->ic_mmap_off;        /* convert to base */
                        break;
                }
                icp = NULL;
        }
        if (icp == NULL) {
                return (NULL);
        }

        /* find a segment */
        pool = (icp->ic_dir == AV1394_IR) ?
            &icp->ic_ir.ir_data_pool : &icp->ic_it.it_data_pool;
        for (segoff = 0, i = 0; i < pool->ip_nsegs; i++) {
                isp = &pool->ip_seg[i];
                if (off == segoff) {
                        break;
                }
                segoff += isp->is_umem_size;
                isp = NULL;
        }
        if (isp == NULL) {
                return (NULL);
        }

        /* only whole segments can be mapped */
        if (len != isp->is_umem_size) {
                return (NULL);
        }
        return (isp);
}

/*
 * initialize default channel for data receipt
 */
static int
av1394_isoch_autorecv_init(av1394_inst_t *avp, av1394_ic_t **icpp)
{
        iec61883_isoch_init_t ii;
        int             ret = 0;

        bzero(&ii, sizeof (ii));
        ii.ii_version = IEC61883_V1_0;
        ii.ii_pkt_size = 512;
        ii.ii_frame_size = av1394_isoch_autorecv_framesz;
        ii.ii_frame_cnt = av1394_isoch_autorecv_nframes;
        ii.ii_direction = IEC61883_DIR_RECV;
        ii.ii_bus_speed = IEC61883_S100;
        ii.ii_channel = (1ULL << 63);

        ret = av1394_ic_init(avp, &ii, icpp);

        return (ret);
}

/*
 * initialize default channel for data xmit
 */
static int
av1394_isoch_autoxmit_init(av1394_inst_t *avp, av1394_ic_t **icpp,
    struct uio *uiop)
{
        av1394_isoch_autoxmit_t *axp = &avp->av_i.i_autoxmit;
        iec61883_isoch_init_t ii;
        uint_t          fmt, dbs, fn, f5060, stype;     /* CIP fields */
        int             ret = 0;

        /* copyin the first CIP header */
        axp->ax_copy_ciph = B_FALSE;
        if (uiop->uio_resid < AV1394_CIPSZ) {
                return (EINVAL);
        }
        ret = uiomove(axp->ax_ciph, AV1394_CIPSZ, UIO_WRITE, uiop);
        if (ret != 0) {
                return (ret);
        }
        axp->ax_copy_ciph = B_TRUE;

        /* parse CIP header */
        dbs = axp->ax_ciph[1];
        fn = (axp->ax_ciph[2] >> 6) & 0x3;
        fmt = axp->ax_ciph[4] & 0x3F;
        stype = (axp->ax_ciph[5] >> 2) & 0x1F;

        /* fill out the init structure */
        bzero(&ii, sizeof (ii));
        ii.ii_version = IEC61883_V1_0;
        ii.ii_frame_cnt = av1394_isoch_autoxmit_nframes;
        ii.ii_direction = IEC61883_DIR_XMIT;
        ii.ii_bus_speed = IEC61883_S100;
        ii.ii_channel = (1ULL << 63);
        ii.ii_dbs = dbs;
        ii.ii_fn = fn;

        if ((fmt == 0) && (dbs == 0x78) && (fn == 0) && (stype == 0)) {
                /* either DV-NTSC or DV-PAL */
                ii.ii_pkt_size = 488;
                ii.ii_ts_mode = IEC61883_TS_SYT;
                f5060 = axp->ax_ciph[5] & 0x80;
                if (f5060 == 0) {
                        axp->ax_fmt = AV1394_ISOCH_AUTOXMIT_DV_NTSC;
                        ii.ii_frame_size = AV1394_DV_NTSC_FRAMESZ;
                        ii.ii_rate_n = av1394_rate_n_dv_ntsc;
                        ii.ii_rate_d = av1394_rate_d_dv_ntsc;
                } else {
                        axp->ax_fmt = AV1394_ISOCH_AUTOXMIT_DV_PAL;
                        ii.ii_frame_size = AV1394_DV_PAL_FRAMESZ;
                        ii.ii_rate_n = av1394_rate_n_dv_pal;
                        ii.ii_rate_d = av1394_rate_d_dv_pal;
                }
        } else {
                /* raw stream */
                axp->ax_fmt = AV1394_ISOCH_AUTOXMIT_UNKNOWN;
                ii.ii_pkt_size = 512;
                ii.ii_frame_size = av1394_isoch_autoxmit_framesz;
                ii.ii_ts_mode = IEC61883_TS_NONE;
        }

        ret = av1394_ic_init(avp, &ii, icpp);

        return (ret);
}


/*
 *
 * --- ioctls
 *      these routines are generally responsible for copyin/out of arguments
 *      and passing control to the actual implementation.
 *
 */
static int
av1394_ioctl_isoch_init(av1394_inst_t *avp, void *arg, int mode)
{
        iec61883_isoch_init_t   ii;
#ifdef _MULTI_DATAMODEL
        iec61883_isoch_init32_t ii32;
#endif
        av1394_ic_t             *icp;
        int                     ret;

        if (ddi_copyin(arg, &ii, sizeof (ii), mode) != 0) {
                return (EFAULT);
        }

        ret = av1394_ic_init(avp, &ii, &icp);

        if (ret != 0) {
#ifdef _MULTI_DATAMODEL
                if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
                        bcopy(&ii, &ii32, sizeof (ii32));
                        ii32.ii_error = ii.ii_error;
                        (void) ddi_copyout(&ii32, arg, sizeof (ii32), mode);
                } else
#endif
                (void) ddi_copyout(&ii, arg, sizeof (ii), mode);
                return (ret);
        }

#ifdef _MULTI_DATAMODEL
        /* fixup 32-bit deviations */
        if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
                bcopy(&ii, &ii32, sizeof (ii32));
                ii32.ii_mmap_off = ii.ii_mmap_off;
                ii32.ii_rchannel = ii.ii_rchannel;
                ii32.ii_error = ii.ii_error;
                ret = ddi_copyout(&ii32, arg, sizeof (ii32), mode);
        } else
#endif
        ret = ddi_copyout(&ii, arg, sizeof (ii), mode);
        if (ret != 0) {
                return (ENOMEM);
        }

        return (ret);
}

static av1394_ic_t *
av1394_ioctl_isoch_handle2ic(av1394_inst_t *avp, void *arg)
{
        int             num = (int)(intptr_t)arg;
        av1394_isoch_t  *ip = &avp->av_i;

        if (num >= NELEM(ip->i_ic)) {
                return (NULL);
        }
        return (ip->i_ic[num]);
}

/*ARGSUSED*/
static int
av1394_ioctl_isoch_fini(av1394_inst_t *avp, void *arg, int mode)
{
        av1394_ic_t     *icp;

        if ((icp = av1394_ioctl_isoch_handle2ic(avp, arg)) != NULL) {
                av1394_ic_fini(icp);
        }

        return (0);
}

/*ARGSUSED*/
static int
av1394_ioctl_start(av1394_inst_t *avp, void *arg, int mode)
{
        av1394_ic_t     *icp;
        int             ret = EINVAL;

        if ((icp = av1394_ioctl_isoch_handle2ic(avp, arg)) != NULL) {
                ret = av1394_ic_start(icp);
        }

        return (ret);
}

/*ARGSUSED*/
static int
av1394_ioctl_stop(av1394_inst_t *avp, void *arg, int mode)
{
        av1394_ic_t     *icp;
        int             ret = EINVAL;

        if ((icp = av1394_ioctl_isoch_handle2ic(avp, arg)) != NULL) {
                ret = av1394_ic_stop(icp);
        }

        return (ret);
}

static int
av1394_ioctl_recv(av1394_inst_t *avp, void *arg, int mode)
{
        av1394_isoch_t  *ip = &avp->av_i;
        av1394_ic_t     *icp;
        iec61883_recv_t recv;
        int             num;
        int             ret = EINVAL;

        /* copyin the structure and get channel pointer */
        if (ddi_copyin(arg, &recv, sizeof (recv), mode) != 0) {
                return (EFAULT);
        }
        num = recv.rx_handle;
        if (num >= NELEM(ip->i_ic)) {
                return (EINVAL);
        }
        icp = ip->i_ic[num];

        /* now call the actual handler */
        if (icp->ic_dir != AV1394_IR) {
                ret = EINVAL;
        } else {
                ret = av1394_ir_recv(icp, &recv);
        }

        /* copyout the result */
        if (ret == 0) {
                if (ddi_copyout(&recv, arg, sizeof (recv), mode) != 0) {
                        return (EFAULT);
                }
        }

        return (ret);
}

static int
av1394_ioctl_xmit(av1394_inst_t *avp, void *arg, int mode)
{
        av1394_isoch_t  *ip = &avp->av_i;
        av1394_ic_t     *icp;
        iec61883_xmit_t xmit;
        int             num;
        int             ret = EINVAL;

        /* copyin the structure and get channel pointer */
        if (ddi_copyin(arg, &xmit, sizeof (xmit), mode) != 0) {
                return (EFAULT);
        }
        num = xmit.tx_handle;
        if (num >= NELEM(ip->i_ic)) {
                return (EINVAL);
        }
        icp = ip->i_ic[num];

        /* now call the actual handler */
        if (icp->ic_dir != AV1394_IT) {
                ret = EINVAL;
        } else {
                ret = av1394_it_xmit(icp, &xmit);
        }

        /* copyout the result */
        if (ret == 0) {
                if (ddi_copyout(&xmit, arg, sizeof (xmit), mode) != 0) {
                        return (EFAULT);
                }
        }

        return (ret);
}

static uint_t
av1394_isoch_softintr(caddr_t arg)
{
        av1394_inst_t   *avp = (av1394_inst_t *)arg;
        av1394_isoch_t  *ip = &avp->av_i;
        int             i;
        uint64_t        ch;
        av1394_ic_t     *icp;

        mutex_enter(&ip->i_mutex);
        do {
                for (i = 63, ch = (1ULL << 63);
                    (i > 0) && (ip->i_softintr_ch != 0);
                    i--, ch >>= 1) {
                        if ((ip->i_softintr_ch & ch) == 0) {
                                continue;
                        }
                        ip->i_softintr_ch &= ~ch;
                        icp = ip->i_ic[i];
                        if (icp == NULL) {
                                continue;
                        }

                        mutex_exit(&ip->i_mutex);
                        mutex_enter(&icp->ic_mutex);
                        if (icp->ic_preq & AV1394_PREQ_IR_OVERFLOW) {
                                icp->ic_preq &= ~AV1394_PREQ_IR_OVERFLOW;
                                av1394_ir_overflow(icp);
                        }
                        if (icp->ic_preq & AV1394_PREQ_IT_UNDERRUN) {
                                icp->ic_preq &= ~AV1394_PREQ_IT_UNDERRUN;
                                av1394_it_underrun(icp);
                        }
                        mutex_exit(&icp->ic_mutex);
                        mutex_enter(&ip->i_mutex);
                }
        } while (ip->i_softintr_ch != 0);
        mutex_exit(&ip->i_mutex);

        return (DDI_INTR_CLAIMED);
}