/*
 * 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.
 */


#include <sys/types.h>
#include <sys/file.h>
#include <sys/errno.h>
#include <sys/uio.h>
#include <sys/open.h>
#include <sys/cred.h>
#include <sys/kmem.h>
#include <sys/conf.h>
#include <sys/cmn_err.h>
#include <sys/ksynch.h>
#include <sys/modctl.h>
#include <sys/stat.h>                   /* needed for S_IFBLK and S_IFCHR */
#include <sys/debug.h>
#include <sys/sysmacros.h>
#include <sys/types.h>
#include <sys/cred.h>
#include <sys/promif.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/cyclic.h>
#include <sys/note.h>
#include <sys/mach_descrip.h>
#include <sys/mdeg.h>
#include <sys/ldc.h>
#include <sys/vldc_impl.h>

/*
 * Function prototypes.
 */

/* DDI entrypoints */
static int vldc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
static int vldc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
static int vldc_open(dev_t *devp, int flag, int otyp, cred_t *cred);
static int vldc_close(dev_t dev, int flag, int otyp, cred_t *cred);
static int vldc_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
    cred_t *credp, int *rvalp);
static int vldc_read(dev_t dev, struct uio *uiop, cred_t *credp);
static int vldc_write(dev_t dev, struct uio *uiop, cred_t *credp);
static int vldc_chpoll(dev_t dev, short events, int anyyet,
    short *reventsp, struct pollhead **phpp);

/* Internal functions */
static uint_t i_vldc_cb(uint64_t event, caddr_t arg);
static int i_vldc_mdeg_cb(void *cb_argp, mdeg_result_t *resp);
static int i_vldc_mdeg_register(vldc_t *vldcp);
static int i_vldc_mdeg_unregister(vldc_t *vldcp);
static int i_vldc_add_port(vldc_t *vldcp, md_t *mdp, mde_cookie_t node);
static int i_vldc_remove_port(vldc_t *vldcp, uint_t portno);
static int i_vldc_close_port(vldc_t *vldcp, uint_t portno);

/* soft state structure */
static void *vldc_ssp;

/*
 * Matching criteria passed to the MDEG to register interest
 * in changes to 'virtual-device-port' nodes identified by their
 * 'id' property.
 */
static md_prop_match_t vport_prop_match[] = {
        { MDET_PROP_VAL,    "id"   },
        { MDET_LIST_END,    NULL    }
};

static mdeg_node_match_t vport_match = { "virtual-device-port",
                                        vport_prop_match };

/*
 * Specification of an MD node passed to the MDEG to filter any
 * 'virtual-device-port' nodes that do not belong to the specified
 * node. This template is copied for each vldc instance and filled
 * in with the appropriate 'name' and 'cfg-handle' values before
 * being passed to the MDEG.
 */
static mdeg_prop_spec_t vldc_prop_template[] = {
        { MDET_PROP_STR,    "name",             NULL    },
        { MDET_PROP_VAL,    "cfg-handle",       NULL    },
        { MDET_LIST_END,    NULL,               NULL    }
};

#define VLDC_MDEG_PROP_NAME(specp)              ((specp)[0].ps_str)
#define VLDC_SET_MDEG_PROP_NAME(specp, name)    ((specp)[0].ps_str = (name))
#define VLDC_SET_MDEG_PROP_INST(specp, inst)    ((specp)[1].ps_val = (inst))


static struct cb_ops vldc_cb_ops = {
        vldc_open,      /* open */
        vldc_close,     /* close */
        nodev,          /* strategy */
        nodev,          /* print */
        nodev,          /* dump */
        vldc_read,      /* read */
        vldc_write,     /* write */
        vldc_ioctl,     /* ioctl */
        nodev,          /* devmap */
        nodev,          /* mmap */
        ddi_segmap,     /* segmap */
        vldc_chpoll,    /* chpoll */
        ddi_prop_op,    /* prop_op */
        NULL,           /* stream */
        D_NEW | D_MP    /* flag */
};

static struct dev_ops vldc_ops = {
        DEVO_REV,               /* rev */
        0,                      /* ref count */
        ddi_getinfo_1to1,       /* getinfo */
        nulldev,                /* identify */
        nulldev,                /* probe */
        vldc_attach,            /* attach */
        vldc_detach,            /* detach */
        nodev,                  /* reset */
        &vldc_cb_ops,           /* cb_ops */
        (struct bus_ops *)NULL, /* bus_ops */
        NULL,                   /* power */
        ddi_quiesce_not_needed,         /* quiesce */
};

extern struct mod_ops mod_driverops;

static struct modldrv md = {
        &mod_driverops,                         /* Type - it is a driver */
        "sun4v Virtual LDC Driver",             /* Name of the module */
        &vldc_ops,                              /* driver specific ops */
};

static struct modlinkage ml = {
        MODREV_1,
        &md,
        NULL
};

/* maximum MTU and cookie size tunables */
uint32_t vldc_max_mtu = VLDC_MAX_MTU;
uint64_t vldc_max_cookie = VLDC_MAX_COOKIE;

/*
 * when ldc_close() returns EAGAIN, it is retried with a wait
 * of 'vldc_close_delay' between each retry.
 */
static clock_t  vldc_close_delay = VLDC_CLOSE_DELAY;

#ifdef DEBUG

/*
 * Print debug messages
 *
 * set vldcdbg to 0x7 to enable all messages
 *
 * 0x4 - Warnings
 * 0x2 - All debug messages (most verbose)
 * 0x1 - Minimal debug messages
 */

int vldcdbg = 0x0;

static void
vldcdebug(const char *fmt, ...)
{
        char buf[512];
        va_list ap;

        va_start(ap, fmt);
        (void) vsnprintf(buf, sizeof (buf), fmt, ap);
        va_end(ap);

        cmn_err(CE_CONT, "?%s", buf);
}

#define D1      if (vldcdbg & 0x01) vldcdebug
#define D2      if (vldcdbg & 0x02) vldcdebug
#define DWARN   if (vldcdbg & 0x04) vldcdebug

#else /* not DEBUG */

#define D1      if (0) printf
#define D2      if (0) printf
#define DWARN   if (0) printf

#endif /* not DEBUG */


/* _init(9E): initialize the loadable module */
int
_init(void)
{
        int error;

        /* init the soft state structure */
        error = ddi_soft_state_init(&vldc_ssp, sizeof (vldc_t), 1);
        if (error != 0) {
                return (error);
        }

        /* Link the driver into the system */
        error = mod_install(&ml);

        return (error);
}

/* _info(9E): return information about the loadable module */
int
_info(struct modinfo *modinfop)
{
        /* Report status of the dynamically loadable driver module */
        return (mod_info(&ml, modinfop));
}

/* _fini(9E): prepare the module for unloading. */
int
_fini(void)
{
        int error;

        /* Unlink the driver module from the system */
        if ((error = mod_remove(&ml)) == 0) {
                /*
                 * We have successfully "removed" the driver.
                 * destroy soft state
                 */
                ddi_soft_state_fini(&vldc_ssp);
        }

        return (error);
}

/* ldc callback */
static uint_t
i_vldc_cb(uint64_t event, caddr_t arg)
{
        int             rv;
        vldc_port_t     *vport = (vldc_port_t *)arg;
        ldc_status_t    old_status;
        short           pollevents = 0;

        ASSERT(vport != NULL);
        ASSERT(vport->minorp != NULL);

        D1("i_vldc_cb: vldc@%d:%d callback invoked, channel=0x%lx, "
            "event=0x%lx\n", vport->inst, vport->number, vport->ldc_id, event);

        /* ensure the port can't be destroyed while we are handling the cb */
        mutex_enter(&vport->minorp->lock);

        if (vport->status == VLDC_PORT_CLOSED) {
                return (LDC_SUCCESS);
        }

        old_status = vport->ldc_status;
        rv = ldc_status(vport->ldc_handle, &vport->ldc_status);
        if (rv != 0) {
                DWARN("i_vldc_cb: vldc@%d:%d could not get ldc status, "
                    "rv=%d\n", vport->inst, vport->number, rv);
                mutex_exit(&vport->minorp->lock);
                return (LDC_SUCCESS);
        }

        if (event & LDC_EVT_UP) {
                pollevents |= POLLOUT;
                vport->hanged_up = B_FALSE;

        } else if (event & LDC_EVT_RESET) {
                /*
                 * Mark the port in reset, if it is not CLOSED and
                 * the channel was previously in LDC_UP state. This
                 * implies that the port cannot be used until it has
                 * been closed and reopened.
                 */
                if (old_status == LDC_UP) {
                        vport->status = VLDC_PORT_RESET;
                        vport->hanged_up = B_TRUE;
                        pollevents = POLLHUP;
                } else {
                        rv = ldc_up(vport->ldc_handle);
                        if (rv) {
                                DWARN("i_vldc_cb: vldc@%d:%d cannot bring "
                                    "channel UP rv=%d\n", vport->inst,
                                    vport->number, rv);
                                mutex_exit(&vport->minorp->lock);
                                return (LDC_SUCCESS);
                        }
                        rv = ldc_status(vport->ldc_handle, &vport->ldc_status);
                        if (rv != 0) {
                                DWARN("i_vldc_cb: vldc@%d:%d could not get "
                                    "ldc status, rv=%d\n", vport->inst,
                                    vport->number, rv);
                                mutex_exit(&vport->minorp->lock);
                                return (LDC_SUCCESS);
                        }
                        if (vport->ldc_status == LDC_UP) {
                                pollevents |= POLLOUT;
                                vport->hanged_up = B_FALSE;
                        }
                }

        } else if (event & LDC_EVT_DOWN) {
                /*
                 * The other side went away - mark port in RESET state
                 */
                vport->status = VLDC_PORT_RESET;
                vport->hanged_up = B_TRUE;
                pollevents = POLLHUP;
        }

        if (event & LDC_EVT_READ)
                pollevents |= POLLIN;

        mutex_exit(&vport->minorp->lock);

        if (pollevents != 0) {
                D1("i_vldc_cb: port@%d pollwakeup=0x%x\n",
                    vport->number, pollevents);
                pollwakeup(&vport->poll, pollevents);
        }

        return (LDC_SUCCESS);
}

/* mdeg callback */
static int
i_vldc_mdeg_cb(void *cb_argp, mdeg_result_t *resp)
{
        vldc_t          *vldcp;
        int             idx;
        uint64_t        portno;
        int             rv;
        md_t            *mdp;
        mde_cookie_t    node;

        if (resp == NULL) {
                D1("i_vldc_mdeg_cb: no result returned\n");
                return (MDEG_FAILURE);
        }

        vldcp = (vldc_t *)cb_argp;

        mutex_enter(&vldcp->lock);
        if (vldcp->detaching == B_TRUE) {
                D1("i_vldc_mdeg_cb: detach in progress\n");
                mutex_exit(&vldcp->lock);
                return (MDEG_FAILURE);
        }

        D1("i_vldc_mdeg_cb: added=%d, removed=%d, matched=%d\n",
            resp->added.nelem, resp->removed.nelem, resp->match_prev.nelem);

        /* process added ports */
        for (idx = 0; idx < resp->added.nelem; idx++) {
                mdp = resp->added.mdp;
                node = resp->added.mdep[idx];

                D1("i_vldc_mdeg_cb: processing added node 0x%lx\n", node);

                /* attempt to add a port */
                if ((rv = i_vldc_add_port(vldcp, mdp, node)) != MDEG_SUCCESS) {
                        cmn_err(CE_NOTE, "?i_vldc_mdeg_cb: unable to add port, "
                            "err = %d", rv);
                }
        }

        /* process removed ports */
        for (idx = 0; idx < resp->removed.nelem; idx++) {
                mdp = resp->removed.mdp;
                node = resp->removed.mdep[idx];

                D1("i_vldc_mdeg_cb: processing removed node 0x%lx\n", node);

                /* read in the port's id property */
                if (md_get_prop_val(mdp, node, "id", &portno)) {
                        cmn_err(CE_NOTE, "?i_vldc_mdeg_cb: node 0x%lx of "
                            "removed list has no 'id' property", node);
                        continue;
                }

                /* attempt to remove a port */
                if ((rv = i_vldc_remove_port(vldcp, portno)) != 0) {
                        cmn_err(CE_NOTE, "?i_vldc_mdeg_cb: unable to remove "
                            "port %lu, err %d", portno, rv);
                }
        }

        /*
         * Currently no support for updating already active ports. So, ignore
         * the match_curr and match_prev arrays for now.
         */

        mutex_exit(&vldcp->lock);

        return (MDEG_SUCCESS);
}

/* register callback to mdeg */
static int
i_vldc_mdeg_register(vldc_t *vldcp)
{
        mdeg_prop_spec_t *pspecp;
        mdeg_node_spec_t *inst_specp;
        mdeg_handle_t   mdeg_hdl;
        size_t          templatesz;
        int             inst;
        char            *name;
        size_t          namesz;
        char            *nameprop;
        int             rv;

        /* get the unique vldc instance assigned by the LDom manager */
        inst = ddi_prop_get_int(DDI_DEV_T_ANY, vldcp->dip,
            DDI_PROP_DONTPASS, "reg", -1);
        if (inst == -1) {
                cmn_err(CE_NOTE, "?vldc%d has no 'reg' property",
                    ddi_get_instance(vldcp->dip));
                return (DDI_FAILURE);
        }

        /* get the name of the vldc instance */
        rv = ddi_prop_lookup_string(DDI_DEV_T_ANY, vldcp->dip,
            DDI_PROP_DONTPASS, "name", &nameprop);
        if (rv != DDI_PROP_SUCCESS) {
                cmn_err(CE_NOTE, "?vldc%d has no 'name' property",
                    ddi_get_instance(vldcp->dip));
                return (DDI_FAILURE);
        }

        D1("i_vldc_mdeg_register: name=%s, instance=%d\n", nameprop, inst);

        /*
         * Allocate and initialize a per-instance copy
         * of the global property spec array that will
         * uniquely identify this vldc instance.
         */
        templatesz = sizeof (vldc_prop_template);
        pspecp = kmem_alloc(templatesz, KM_SLEEP);

        bcopy(vldc_prop_template, pspecp, templatesz);

        /* copy in the name property */
        namesz = strlen(nameprop) + 1;
        name = kmem_alloc(namesz, KM_SLEEP);

        bcopy(nameprop, name, namesz);
        VLDC_SET_MDEG_PROP_NAME(pspecp, name);
        ddi_prop_free(nameprop);

        /* copy in the instance property */
        VLDC_SET_MDEG_PROP_INST(pspecp, inst);

        /* initialize the complete prop spec structure */
        inst_specp = kmem_alloc(sizeof (mdeg_node_spec_t), KM_SLEEP);
        inst_specp->namep = "virtual-device";
        inst_specp->specp = pspecp;

        /* perform the registration */
        rv = mdeg_register(inst_specp, &vport_match, i_vldc_mdeg_cb,
            vldcp, &mdeg_hdl);

        if (rv != MDEG_SUCCESS) {
                cmn_err(CE_NOTE, "?i_vldc_mdeg_register: mdeg_register "
                    "failed, err = %d", rv);
                kmem_free(name, namesz);
                kmem_free(pspecp, templatesz);
                kmem_free(inst_specp, sizeof (mdeg_node_spec_t));
                return (DDI_FAILURE);
        }

        /* save off data that will be needed later */
        vldcp->inst_spec = inst_specp;
        vldcp->mdeg_hdl = mdeg_hdl;

        return (DDI_SUCCESS);
}

/* unregister callback from mdeg */
static int
i_vldc_mdeg_unregister(vldc_t *vldcp)
{
        char    *name;
        int     rv;

        D1("i_vldc_mdeg_unregister: hdl=0x%lx\n", vldcp->mdeg_hdl);

        rv = mdeg_unregister(vldcp->mdeg_hdl);
        if (rv != MDEG_SUCCESS) {
                return (rv);
        }

        /*
         * Clean up cached MDEG data
         */
        name = VLDC_MDEG_PROP_NAME(vldcp->inst_spec->specp);
        if (name != NULL) {
                kmem_free(name, strlen(name) + 1);
        }
        kmem_free(vldcp->inst_spec->specp, sizeof (vldc_prop_template));
        vldcp->inst_spec->specp = NULL;

        kmem_free(vldcp->inst_spec, sizeof (mdeg_node_spec_t));
        vldcp->inst_spec = NULL;

        return (MDEG_SUCCESS);
}

static int
i_vldc_get_port_channel(md_t *mdp, mde_cookie_t node, uint64_t *ldc_id)
{
        int num_nodes, nchan;
        size_t listsz;
        mde_cookie_t *listp;

        /*
         * Find the channel-endpoint node(s) (which should be under this
         * port node) which contain the channel id(s).
         */
        if ((num_nodes = md_node_count(mdp)) <= 0) {
                cmn_err(CE_NOTE, "?i_vldc_get_port_channel: invalid number of "
                    "channel-endpoint nodes found (%d)", num_nodes);
                return (-1);
        }

        /* allocate space for node list */
        listsz = num_nodes * sizeof (mde_cookie_t);
        listp = kmem_alloc(listsz, KM_SLEEP);

        nchan = md_scan_dag(mdp, node, md_find_name(mdp, "channel-endpoint"),
            md_find_name(mdp, "fwd"), listp);

        if (nchan <= 0) {
                cmn_err(CE_NOTE, "?i_vldc_get_port_channel: no channel-endpoint"
                    " nodes found");
                kmem_free(listp, listsz);
                return (-1);
        }

        D2("i_vldc_get_port_channel: %d channel-endpoint nodes found", nchan);

        /* use property from first node found */
        if (md_get_prop_val(mdp, listp[0], "id", ldc_id)) {
                cmn_err(CE_NOTE, "?i_vldc_get_port_channel: channel-endpoint "
                    "has no 'id' property");
                kmem_free(listp, listsz);
                return (-1);
        }

        kmem_free(listp, listsz);

        return (0);
}

/* add a vldc port */
static int
i_vldc_add_port(vldc_t *vldcp, md_t *mdp, mde_cookie_t node)
{
        vldc_port_t     *vport;
        char            *sname;
        uint64_t        portno;
        int             vldc_inst;
        minor_t         minor;
        int             minor_idx;
        boolean_t       new_minor;
        int             rv;

        ASSERT(MUTEX_HELD(&vldcp->lock));

        /* read in the port's id property */
        if (md_get_prop_val(mdp, node, "id", &portno)) {
                cmn_err(CE_NOTE, "?i_vldc_add_port: node 0x%lx of added "
                    "list has no 'id' property", node);
                return (MDEG_FAILURE);
        }

        if (portno >= VLDC_MAX_PORTS) {
                cmn_err(CE_NOTE, "?i_vldc_add_port: found port number (%lu) "
                    "larger than maximum supported number of ports", portno);
                return (MDEG_FAILURE);
        }

        vport = &(vldcp->port[portno]);

        if (vport->minorp != NULL) {
                cmn_err(CE_NOTE, "?i_vldc_add_port: trying to add a port (%lu)"
                    " which is already bound", portno);
                return (MDEG_FAILURE);
        }

        vport->number = portno;

        /* get all channels for this device (currently only one) */
        if (i_vldc_get_port_channel(mdp, node, &vport->ldc_id) == -1) {
                return (MDEG_FAILURE);
        }

        /* set the default MTU */
        vport->mtu = VLDC_DEFAULT_MTU;

        /* get the service being exported by this port */
        if (md_get_prop_str(mdp, node, "vldc-svc-name", &sname)) {
                cmn_err(CE_NOTE, "?i_vldc_add_port: vdevice has no "
                    "'vldc-svc-name' property");
                return (MDEG_FAILURE);
        }

        /* minor number look up */
        for (minor_idx = 0; minor_idx < vldcp->minors_assigned;
            minor_idx++) {
                if (strcmp(vldcp->minor_tbl[minor_idx].sname, sname) == 0) {
                        /* found previously assigned minor number */
                        break;
                }
        }

        new_minor = B_FALSE;
        if (minor_idx == vldcp->minors_assigned) {
                /* end of lookup - assign new minor number */
                if (vldcp->minors_assigned == VLDC_MAX_MINORS) {
                        cmn_err(CE_NOTE, "?i_vldc_add_port: too many minor "
                            "nodes (%d)", minor_idx);
                        return (MDEG_FAILURE);
                }

                (void) strlcpy(vldcp->minor_tbl[minor_idx].sname,
                    sname, MAXPATHLEN);

                vldcp->minors_assigned++;
                new_minor = B_TRUE;
        }

        if (vldcp->minor_tbl[minor_idx].portno != VLDC_INVALID_PORTNO) {
                cmn_err(CE_NOTE, "?i_vldc_add_port: trying to add a port (%lu)"
                    " which has a minor number in use by port (%u)",
                    portno, vldcp->minor_tbl[minor_idx].portno);
                return (MDEG_FAILURE);
        }

        vldc_inst = ddi_get_instance(vldcp->dip);

        vport->inst = vldc_inst;
        vport->minorp = &vldcp->minor_tbl[minor_idx];
        vldcp->minor_tbl[minor_idx].portno = portno;
        vldcp->minor_tbl[minor_idx].in_use = 0;

        D1("i_vldc_add_port: vldc@%d:%d  mtu=%d, ldc=%ld, service=%s\n",
            vport->inst, vport->number, vport->mtu, vport->ldc_id, sname);

        /*
         * Create a minor node. The minor number is
         * (vldc_inst << VLDC_INST_SHIFT) | minor_idx
         */
        minor = (vldc_inst << VLDC_INST_SHIFT) | (minor_idx);

        rv = ddi_create_minor_node(vldcp->dip, sname, S_IFCHR,
            minor, DDI_NT_SERIAL, 0);

        if (rv != DDI_SUCCESS) {
                cmn_err(CE_NOTE, "?i_vldc_add_port: failed to create minor"
                    "node (%u), err = %d", minor, rv);
                vldcp->minor_tbl[minor_idx].portno = VLDC_INVALID_PORTNO;
                if (new_minor) {
                        vldcp->minors_assigned--;
                }
                return (MDEG_FAILURE);
        }

        /*
         * The port is now bound to a minor node and is initially in the
         * closed state.
         */
        vport->status = VLDC_PORT_CLOSED;

        D1("i_vldc_add_port: port %lu initialized\n", portno);

        return (MDEG_SUCCESS);
}

/* remove a vldc port */
static int
i_vldc_remove_port(vldc_t *vldcp, uint_t portno)
{
        vldc_port_t *vport;
        vldc_minor_t *vminor;

        ASSERT(vldcp != NULL);
        ASSERT(MUTEX_HELD(&vldcp->lock));

        vport = &(vldcp->port[portno]);
        vminor = vport->minorp;
        if (vminor == NULL) {
                cmn_err(CE_NOTE, "?i_vldc_remove_port: trying to remove a "
                    "port (%u) which is not bound", portno);
                return (MDEG_FAILURE);
        }

        /*
         * Make sure that all new attempts to open or use the minor node
         * associated with the port will fail.
         */
        mutex_enter(&vminor->lock);
        vminor->portno = VLDC_INVALID_PORTNO;
        mutex_exit(&vminor->lock);

        /* send hangup to anyone polling */
        pollwakeup(&vport->poll, POLLHUP);

        /* Now wait for all current users of the minor node to finish. */
        mutex_enter(&vminor->lock);
        while (vminor->in_use > 0) {
                cv_wait(&vminor->cv, &vminor->lock);
        }

        if (vport->status != VLDC_PORT_CLOSED) {
                /* close the port before it is torn down */
                (void) i_vldc_close_port(vldcp, portno);
        }

        /* remove minor node */
        ddi_remove_minor_node(vldcp->dip, vport->minorp->sname);
        vport->minorp = NULL;

        mutex_exit(&vminor->lock);

        D1("i_vldc_remove_port: removed vldc port %u\n", portno);

        return (MDEG_SUCCESS);
}

/*
 * Close and destroy the ldc channel associated with the port 'vport'
 *
 * NOTE It may not be possible close and destroy the channel if resources
 *      are still in use so the fucntion may exit before all the teardown
 *      operations are completed and would have to be called again by the
 *      vldc framework.
 *
 *      This function needs to be able to handle the case where it is called
 *      more than once and has to pick up from where it left off.
 */
static int
i_vldc_ldc_close(vldc_port_t *vport)
{
        int err = 0;

        ASSERT(MUTEX_HELD(&vport->minorp->lock));

        /*
         * If ldc_close() succeeded or if the channel was already closed[*]
         * (possibly by a previously unsuccessful call to this function)
         * we keep going and try to teardown the rest of the LDC state,
         * otherwise we bail out.
         *
         * [*] indicated by ldc_close() returning a value of EFAULT
         */
        err = ldc_close(vport->ldc_handle);
        if ((err != 0) && (err != EFAULT))
                return (err);

        err = ldc_unreg_callback(vport->ldc_handle);
        if (err != 0)
                return (err);

        err = ldc_fini(vport->ldc_handle);
        if (err != 0)
                return (err);

        vport->status = VLDC_PORT_OPEN;

        return (0);
}

/* close a vldc port */
static int
i_vldc_close_port(vldc_t *vldcp, uint_t portno)
{
        vldc_port_t     *vport;
        vldc_minor_t    *vminor;
        int             rv = DDI_SUCCESS;

        vport = &(vldcp->port[portno]);

        ASSERT(MUTEX_HELD(&vport->minorp->lock));

        D1("i_vldc_close_port: vldc@%d:%d: closing port\n",
            vport->inst, vport->minorp->portno);

        vminor = vport->minorp;

        switch (vport->status) {
        case VLDC_PORT_CLOSED:
                /* nothing to do */
                DWARN("i_vldc_close_port: port %d in an unexpected "
                    "state (%d)\n", portno, vport->status);
                return (DDI_SUCCESS);

        case VLDC_PORT_READY:
        case VLDC_PORT_RESET:
                do {
                        rv = i_vldc_ldc_close(vport);
                        if (rv != EAGAIN)
                                break;

                        /*
                         * EAGAIN indicates that ldc_close() failed because
                         * ldc callback thread is active for the channel.
                         * cv_timedwait() is used to release vminor->lock and
                         * allow ldc callback thread to complete.
                         * after waking up, check if the port has been closed
                         * by another thread in the meantime.
                         */
                        (void) cv_reltimedwait(&vminor->cv, &vminor->lock,
                            drv_usectohz(vldc_close_delay), TR_CLOCK_TICK);
                        rv = 0;
                } while (vport->status != VLDC_PORT_CLOSED);

                if ((rv != 0) || (vport->status == VLDC_PORT_CLOSED))
                        return (rv);

                break;

        case VLDC_PORT_OPEN:
                break;

        default:
                DWARN("i_vldc_close_port: port %d in an unexpected "
                    "state (%d)\n", portno, vport->status);
                ASSERT(0);      /* fail quickly to help diagnosis */
                return (EINVAL);
        }

        ASSERT(vport->status == VLDC_PORT_OPEN);

        /* free memory */
        kmem_free(vport->send_buf, vport->mtu);
        kmem_free(vport->recv_buf, vport->mtu);

        if (strcmp(vminor->sname, VLDC_HVCTL_SVCNAME) == 0)
                kmem_free(vport->cookie_buf, vldc_max_cookie);

        vport->status = VLDC_PORT_CLOSED;

        return (rv);
}

/*
 * attach(9E): attach a device to the system.
 * called once for each instance of the device on the system.
 */
static int
vldc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        int     i, instance;
        vldc_t  *vldcp;

        switch (cmd) {

        case DDI_ATTACH:

                instance = ddi_get_instance(dip);

                if (ddi_soft_state_zalloc(vldc_ssp, instance) != DDI_SUCCESS) {
                        return (DDI_FAILURE);
                }

                vldcp = ddi_get_soft_state(vldc_ssp, instance);
                if (vldcp == NULL) {
                        ddi_soft_state_free(vldc_ssp, instance);
                        return (ENXIO);
                }

                D1("vldc_attach: DDI_ATTACH instance=%d\n", instance);

                mutex_init(&vldcp->lock, NULL, MUTEX_DRIVER, NULL);
                vldcp->dip = dip;
                vldcp->detaching = B_FALSE;

                for (i = 0; i < VLDC_MAX_PORTS; i++) {
                        /* No minor node association to start with */
                        vldcp->port[i].minorp = NULL;
                }

                for (i = 0; i < VLDC_MAX_MINORS; i++) {
                        mutex_init(&(vldcp->minor_tbl[i].lock), NULL,
                            MUTEX_DRIVER, NULL);
                        cv_init(&(vldcp->minor_tbl[i].cv), NULL,
                            CV_DRIVER, NULL);
                        /* No port association to start with */
                        vldcp->minor_tbl[i].portno = VLDC_INVALID_PORTNO;
                }

                /* Register for MD update notification */
                if (i_vldc_mdeg_register(vldcp) != DDI_SUCCESS) {
                        ddi_soft_state_free(vldc_ssp, instance);
                        return (DDI_FAILURE);
                }

                return (DDI_SUCCESS);

        case DDI_RESUME:

                return (DDI_SUCCESS);

        default:

                return (DDI_FAILURE);
        }
}

/*
 * detach(9E): detach a device from the system.
 */
static int
vldc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        int             i, instance;
        vldc_t          *vldcp;

        switch (cmd) {

        case DDI_DETACH:

                instance = ddi_get_instance(dip);

                vldcp = ddi_get_soft_state(vldc_ssp, instance);
                if (vldcp == NULL) {
                        return (DDI_FAILURE);
                }

                D1("vldc_detach: DDI_DETACH instance=%d\n", instance);

                mutex_enter(&vldcp->lock);

                /* Fail the detach if all ports have not been removed. */
                for (i = 0; i < VLDC_MAX_MINORS; i++) {
                        if (vldcp->minor_tbl[i].portno != VLDC_INVALID_PORTNO) {
                                D1("vldc_detach: vldc@%d:%d is bound, "
                                    "detach failed\n",
                                    instance, vldcp->minor_tbl[i].portno);
                                mutex_exit(&vldcp->lock);
                                return (DDI_FAILURE);
                        }
                }

                /*
                 * Prevent MDEG from adding new ports before the callback can
                 * be unregistered. The lock can't be held accross the
                 * unregistration call because a callback may be in progress
                 * and blocked on the lock.
                 */
                vldcp->detaching = B_TRUE;

                mutex_exit(&vldcp->lock);

                if (i_vldc_mdeg_unregister(vldcp) != MDEG_SUCCESS) {
                        vldcp->detaching = B_FALSE;
                        return (DDI_FAILURE);
                }

                /* Tear down all bound ports and free resources. */
                for (i = 0; i < VLDC_MAX_MINORS; i++) {
                        if (vldcp->minor_tbl[i].portno != VLDC_INVALID_PORTNO) {
                                (void) i_vldc_remove_port(vldcp, i);
                        }
                        mutex_destroy(&(vldcp->minor_tbl[i].lock));
                        cv_destroy(&(vldcp->minor_tbl[i].cv));
                }

                mutex_destroy(&vldcp->lock);
                ddi_soft_state_free(vldc_ssp, instance);

                return (DDI_SUCCESS);

        case DDI_SUSPEND:

                return (DDI_SUCCESS);

        default:

                return (DDI_FAILURE);
        }
}

/* cb_open */
static int
vldc_open(dev_t *devp, int flag, int otyp, cred_t *cred)
{
        _NOTE(ARGUNUSED(flag, otyp, cred))

        int instance;
        minor_t minor;
        uint64_t portno;
        vldc_t *vldcp;
        vldc_port_t *vport;
        vldc_minor_t *vminor;

        minor = getminor(*devp);
        instance = VLDCINST(minor);
        vldcp = ddi_get_soft_state(vldc_ssp, instance);
        if (vldcp == NULL)
                return (ENXIO);

        vminor = VLDCMINOR(vldcp, minor);
        mutex_enter(&vminor->lock);
        portno = vminor->portno;
        if (portno == VLDC_INVALID_PORTNO) {
                mutex_exit(&vminor->lock);
                return (ENXIO);
        }

        vport = &(vldcp->port[portno]);

        D1("vldc_open: opening vldc@%d:%lu\n", instance, portno);

        if (vport->status != VLDC_PORT_CLOSED) {
                mutex_exit(&vminor->lock);
                return (EBUSY);
        }

        vport->recv_buf = kmem_alloc(vport->mtu, KM_SLEEP);
        vport->send_buf = kmem_alloc(vport->mtu, KM_SLEEP);

        if (strcmp(vport->minorp->sname, VLDC_HVCTL_SVCNAME) == 0)
                vport->cookie_buf = kmem_alloc(vldc_max_cookie, KM_SLEEP);

        vport->is_stream = B_FALSE;     /* assume not a stream */
        vport->hanged_up = B_FALSE;

        vport->status = VLDC_PORT_OPEN;

        mutex_exit(&vminor->lock);

        return (DDI_SUCCESS);
}

/* cb_close */
static int
vldc_close(dev_t dev, int flag, int otyp, cred_t *cred)
{
        _NOTE(ARGUNUSED(flag, otyp, cred))

        int instance;
        minor_t minor;
        uint64_t portno;
        vldc_t *vldcp;
        vldc_minor_t *vminor;
        int rv;

        minor = getminor(dev);
        instance = VLDCINST(minor);
        vldcp = ddi_get_soft_state(vldc_ssp, instance);
        if (vldcp == NULL) {
                return (ENXIO);
        }

        vminor = VLDCMINOR(vldcp, minor);
        mutex_enter(&vminor->lock);
        portno = vminor->portno;
        if (portno == VLDC_INVALID_PORTNO) {
                mutex_exit(&vminor->lock);
                return (ENOLINK);
        }

        D1("vldc_close: closing vldc@%d:%lu\n", instance, portno);

        rv = i_vldc_close_port(vldcp, portno);

        mutex_exit(&vminor->lock);

        return (rv);
}

static int
vldc_set_ldc_mode(vldc_port_t *vport, vldc_t *vldcp, int channel_mode)
{
        ldc_attr_t attr;
        int rv;

        ASSERT(MUTEX_HELD(&vport->minorp->lock));

        /* validate mode */
        switch (channel_mode) {
        case LDC_MODE_RELIABLE:
                vport->is_stream = B_TRUE;
                break;
        case LDC_MODE_RAW:
        case LDC_MODE_UNRELIABLE:
                vport->is_stream = B_FALSE;
                break;
        default:
                return (EINVAL);
        }

        if (vport->status == VLDC_PORT_READY) {
                rv = i_vldc_ldc_close(vport);
                if (rv != 0) {
                        DWARN("vldc_set_ldc_mode: i_vldc_ldc_close "
                            "failed, rv=%d\n", rv);
                        return (rv);
                }
        }

        D1("vldc_set_ldc_mode: vport status %d, mode %d\n",
            vport->status, channel_mode);

        vport->ldc_mode = channel_mode;

        /* initialize the channel */
        attr.devclass = LDC_DEV_SERIAL;
        attr.instance = ddi_get_instance(vldcp->dip);
        attr.mtu = vport->mtu;
        attr.mode = vport->ldc_mode;

        if ((rv = ldc_init(vport->ldc_id, &attr,
            &vport->ldc_handle)) != 0) {
                DWARN("vldc_ioctl_opt_op: ldc_init failed, rv=%d\n", rv);
                goto error_init;
        }

        /* register it */
        if ((rv = ldc_reg_callback(vport->ldc_handle,
            i_vldc_cb, (caddr_t)vport)) != 0) {
                DWARN("vldc_ioctl_opt_op: ldc_reg_callback failed, rv=%d\n",
                    rv);
                goto error_reg;
        }

        /* open the channel */
        if ((rv = ldc_open(vport->ldc_handle)) != 0) {
                DWARN("vldc_ioctl_opt_op: ldc_open failed, rv=%d\n", rv);
                goto error_open;
        }

        vport->status = VLDC_PORT_READY;

        /*
         * Attempt to bring the channel up, but do not
         * fail if the other end is not up yet.
         */
        rv = ldc_up(vport->ldc_handle);
        if (rv == ECONNREFUSED) {
                D1("vldc_ioctl_opt_op: remote endpoint not up yet\n");
        } else if (rv != 0) {
                DWARN("vldc_ioctl_opt_op: ldc_up failed, rv=%d\n", rv);
                goto error_up;
        }

        rv = ldc_status(vport->ldc_handle, &vport->ldc_status);
        if (rv != 0) {
                DWARN("vldc_ioctl_opt_op: vldc@%d:%d could not get ldc "
                    "status, rv=%d\n", vport->inst, vport->number, rv);
                goto error_up;
        }

        D1("vldc_ioctl_opt_op: ldc %ld initialized successfully\n",
            vport->ldc_id);

        return (0);

error_up:
        vport->status = VLDC_PORT_OPEN;
        (void) ldc_close(vport->ldc_handle);
error_open:
        (void) ldc_unreg_callback(vport->ldc_handle);
error_reg:
        (void) ldc_fini(vport->ldc_handle);
error_init:
        return (rv);
}

/* ioctl to read cookie */
static int
i_vldc_ioctl_read_cookie(vldc_port_t *vport, int vldc_instance, void *arg,
    int mode)
{
        vldc_data_t copy_info;
        uint64_t len, balance, copy_size;
        caddr_t src_addr, dst_addr;
        int rv;

        if (ddi_copyin(arg, &copy_info, sizeof (copy_info), mode) == -1) {
                return (EFAULT);
        }

        len = balance = copy_info.length;
        src_addr = (caddr_t)copy_info.src_addr;
        dst_addr = (caddr_t)copy_info.dst_addr;
        while (balance > 0) {

                /* get the max amount to the copied */
                copy_size = MIN(balance, vldc_max_cookie);

                mutex_enter(&vport->minorp->lock);

                D2("i_vldc_ioctl_read_cookie: vldc@%d:%d reading from 0x%p "
                    "size 0x%lx to 0x%p\n", vldc_instance, vport->number,
                    dst_addr, copy_size, src_addr);

                /* read from the HV into the temporary buffer */
                rv = ldc_mem_rdwr_cookie(vport->ldc_handle, vport->cookie_buf,
                    &copy_size, dst_addr, LDC_COPY_IN);
                if (rv != 0) {
                        DWARN("i_vldc_ioctl_read_cookie: vldc@%d:%d cannot "
                            "read address 0x%p, rv=%d\n",
                            vldc_instance, vport->number, dst_addr, rv);
                        mutex_exit(&vport->minorp->lock);
                        return (EFAULT);
                }

                D2("i_vldc_ioctl_read_cookie: vldc@%d:%d read succeeded\n",
                    vldc_instance, vport->number);

                mutex_exit(&vport->minorp->lock);

                /*
                 * copy data from temporary buffer out to the
                 * caller and free buffer
                 */
                rv = ddi_copyout(vport->cookie_buf, src_addr, copy_size, mode);
                if (rv != 0) {
                        return (EFAULT);
                }

                /* adjust len, source and dest */
                balance -= copy_size;
                src_addr += copy_size;
                dst_addr += copy_size;
        }

        /* set the structure to reflect outcome */
        copy_info.length = len;
        if (ddi_copyout(&copy_info, arg, sizeof (copy_info), mode) != 0) {
                return (EFAULT);
        }

        return (0);
}

/* ioctl to write cookie */
static int
i_vldc_ioctl_write_cookie(vldc_port_t *vport, int vldc_instance, void *arg,
    int mode)
{
        vldc_data_t copy_info;
        uint64_t len, balance, copy_size;
        caddr_t src_addr, dst_addr;
        int rv;

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

        D2("i_vldc_ioctl_write_cookie: vldc@%d:%d writing 0x%lx size 0x%lx "
            "to 0x%lx\n", vldc_instance, vport->number, copy_info.src_addr,
            copy_info.length, copy_info.dst_addr);

        len = balance = copy_info.length;
        src_addr = (caddr_t)copy_info.src_addr;
        dst_addr = (caddr_t)copy_info.dst_addr;
        while (balance > 0) {

                /* get the max amount to the copied */
                copy_size = MIN(balance, vldc_max_cookie);

                /*
                 * copy into the temporary buffer the data
                 * to be written to the HV
                 */
                if (ddi_copyin((caddr_t)src_addr, vport->cookie_buf,
                    copy_size, mode) != 0) {
                        return (EFAULT);
                }

                mutex_enter(&vport->minorp->lock);

                /* write the data from the temporary buffer to the HV */
                rv = ldc_mem_rdwr_cookie(vport->ldc_handle, vport->cookie_buf,
                    &copy_size, dst_addr, LDC_COPY_OUT);
                if (rv != 0) {
                        DWARN("i_vldc_ioctl_write_cookie: vldc@%d:%d "
                            "failed to write at address 0x%p\n, rv=%d",
                            vldc_instance, vport->number, dst_addr, rv);
                        mutex_exit(&vport->minorp->lock);
                        return (EFAULT);
                }

                D2("i_vldc_ioctl_write_cookie: vldc@%d:%d write succeeded\n",
                    vldc_instance, vport->number);

                mutex_exit(&vport->minorp->lock);

                /* adjust len, source and dest */
                balance -= copy_size;
                src_addr += copy_size;
                dst_addr += copy_size;
        }

        /* set the structure to reflect outcome */
        copy_info.length = len;
        if (ddi_copyout(&copy_info, (caddr_t)arg,
            sizeof (copy_info), mode) != 0) {
                return (EFAULT);
        }

        return (0);
}

/* vldc specific ioctl option commands */
static int
i_vldc_ioctl_opt_op(vldc_port_t *vport, vldc_t *vldcp, void *arg, int mode)
{
        vldc_opt_op_t   vldc_cmd;
        uint32_t        new_mtu;
        int             rv = 0;

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

        D1("vldc_ioctl_opt_op: op %d\n", vldc_cmd.opt_sel);

        switch (vldc_cmd.opt_sel) {

        case VLDC_OPT_MTU_SZ:

                if (vldc_cmd.op_sel == VLDC_OP_GET) {
                        vldc_cmd.opt_val = vport->mtu;
                        if (ddi_copyout(&vldc_cmd, arg,
                            sizeof (vldc_cmd), mode) == -1) {
                                return (EFAULT);
                        }
                } else {
                        new_mtu = vldc_cmd.opt_val;

                        if ((new_mtu < LDC_PACKET_SIZE) ||
                            (new_mtu > vldc_max_mtu)) {
                                return (EINVAL);
                        }

                        mutex_enter(&vport->minorp->lock);

                        if ((vport->status != VLDC_PORT_CLOSED) &&
                            (new_mtu != vport->mtu)) {
                                /*
                                 * The port has buffers allocated since it is
                                 * not closed plus the MTU size has changed.
                                 * Reallocate the buffers to the new MTU size.
                                 */
                                kmem_free(vport->recv_buf, vport->mtu);
                                vport->recv_buf = kmem_alloc(new_mtu, KM_SLEEP);

                                kmem_free(vport->send_buf, vport->mtu);
                                vport->send_buf = kmem_alloc(new_mtu, KM_SLEEP);

                                vport->mtu = new_mtu;
                        }

                        mutex_exit(&vport->minorp->lock);
                }

                break;

        case VLDC_OPT_STATUS:

                if (vldc_cmd.op_sel == VLDC_OP_GET) {
                        vldc_cmd.opt_val = vport->status;
                        if (ddi_copyout(&vldc_cmd, arg,
                            sizeof (vldc_cmd), mode) == -1) {
                                return (EFAULT);
                        }
                } else {
                        return (ENOTSUP);
                }

                break;

        case VLDC_OPT_MODE:

                if (vldc_cmd.op_sel == VLDC_OP_GET) {
                        vldc_cmd.opt_val = vport->ldc_mode;
                        if (ddi_copyout(&vldc_cmd, arg,
                            sizeof (vldc_cmd), mode) == -1) {
                                return (EFAULT);
                        }
                } else {
                        mutex_enter(&vport->minorp->lock);
                        rv = vldc_set_ldc_mode(vport, vldcp, vldc_cmd.opt_val);
                        mutex_exit(&vport->minorp->lock);
                }

                break;

        default:

                D1("vldc_ioctl_opt_op: unsupported op %d\n", vldc_cmd.opt_sel);
                return (ENOTSUP);
        }

        return (rv);
}

/* cb_ioctl */
static int
vldc_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
    int *rvalp)
{
        _NOTE(ARGUNUSED(credp, rvalp))

        int rv = EINVAL;
        int instance;
        minor_t minor;
        uint64_t portno;
        vldc_t *vldcp;
        vldc_port_t *vport;
        vldc_minor_t *vminor;

        minor = getminor(dev);
        instance = VLDCINST(minor);
        vldcp = ddi_get_soft_state(vldc_ssp, instance);
        if (vldcp == NULL) {
                return (ENXIO);
        }

        vminor = VLDCMINOR(vldcp, minor);
        mutex_enter(&vminor->lock);
        portno = vminor->portno;
        if (portno == VLDC_INVALID_PORTNO) {
                mutex_exit(&vminor->lock);
                return (ENOLINK);
        }
        vminor->in_use += 1;
        mutex_exit(&vminor->lock);

        vport = &(vldcp->port[portno]);

        D1("vldc_ioctl: vldc@%d:%lu cmd=0x%x\n", instance, portno, cmd);

        switch (cmd) {

        case VLDC_IOCTL_OPT_OP:
                rv = i_vldc_ioctl_opt_op(vport, vldcp, (void *)arg,  mode);
                break;

        case VLDC_IOCTL_READ_COOKIE:
                if (strcmp(vport->minorp->sname, VLDC_HVCTL_SVCNAME)) {
                        rv = EINVAL;
                        break;
                }
                rv = i_vldc_ioctl_read_cookie(vport, instance,
                    (void *)arg, mode);
                break;

        case VLDC_IOCTL_WRITE_COOKIE:
                if (strcmp(vport->minorp->sname, VLDC_HVCTL_SVCNAME)) {
                        rv = EINVAL;
                        break;
                }
                rv = i_vldc_ioctl_write_cookie(vport, instance,
                    (void *)arg, mode);
                break;

        default:
                DWARN("vldc_ioctl: vldc@%d:%lu unknown cmd=0x%x\n",
                    instance, portno, cmd);
                rv = EINVAL;
                break;
        }

        mutex_enter(&vminor->lock);
        vminor->in_use -= 1;
        if (vminor->in_use == 0) {
                cv_signal(&vminor->cv);
        }
        mutex_exit(&vminor->lock);

        D1("vldc_ioctl: rv=%d\n", rv);

        return (rv);
}

/* cb_read */
static int
vldc_read(dev_t dev, struct uio *uiop, cred_t *credp)
{
        _NOTE(ARGUNUSED(credp))

        int instance;
        minor_t minor;
        size_t size = 0;
        uint64_t portno;
        vldc_t *vldcp;
        vldc_port_t *vport;
        vldc_minor_t *vminor;
        int rv = 0;

        minor = getminor(dev);
        instance = VLDCINST(minor);
        vldcp = ddi_get_soft_state(vldc_ssp, instance);
        if (vldcp == NULL) {
                return (ENXIO);
        }

        vminor = VLDCMINOR(vldcp, minor);
        mutex_enter(&vminor->lock);
        portno = vminor->portno;
        if (portno == VLDC_INVALID_PORTNO) {
                mutex_exit(&vminor->lock);
                return (ENOLINK);
        }

        D2("vldc_read: vldc@%d:%lu reading data\n", instance, portno);

        vport = &(vldcp->port[portno]);

        /* check the port status */
        if (vport->status != VLDC_PORT_READY) {
                DWARN("vldc_read: vldc@%d:%lu not in the ready state\n",
                    instance, portno);
                mutex_exit(&vminor->lock);
                return (ENOTACTIVE);
        }

        /* read data */
        size = MIN(vport->mtu, uiop->uio_resid);
        rv = ldc_read(vport->ldc_handle, vport->recv_buf, &size);

        D2("vldc_read: vldc@%d:%lu ldc_read size=%ld, rv=%d\n",
            instance, portno, size, rv);

        if (rv == 0) {
                if (size != 0) {
                        rv = uiomove(vport->recv_buf, size, UIO_READ, uiop);
                } else {
                        rv = EWOULDBLOCK;
                }
        } else {
                switch (rv) {
                case ENOBUFS:
                        break;
                case ETIMEDOUT:
                case EWOULDBLOCK:
                        rv = EWOULDBLOCK;
                        break;
                default:
                        rv = ECONNRESET;
                        break;
                }
        }

        mutex_exit(&vminor->lock);

        return (rv);
}

/* cb_write */
static int
vldc_write(dev_t dev, struct uio *uiop, cred_t *credp)
{
        _NOTE(ARGUNUSED(credp))

        int instance;
        minor_t minor;
        size_t size;
        size_t orig_size;
        uint64_t portno;
        vldc_t *vldcp;
        vldc_port_t *vport;
        vldc_minor_t *vminor;
        int rv = EINVAL;

        minor = getminor(dev);
        instance = VLDCINST(minor);
        vldcp = ddi_get_soft_state(vldc_ssp, instance);
        if (vldcp == NULL) {
                return (ENXIO);
        }

        vminor = VLDCMINOR(vldcp, minor);
        mutex_enter(&vminor->lock);
        portno = vminor->portno;
        if (portno == VLDC_INVALID_PORTNO) {
                mutex_exit(&vminor->lock);
                return (ENOLINK);
        }

        vport = &(vldcp->port[portno]);

        /* check the port status */
        if (vport->status != VLDC_PORT_READY) {
                DWARN("vldc_write: vldc@%d:%lu not in the ready state\n",
                    instance, portno);
                mutex_exit(&vminor->lock);
                return (ENOTACTIVE);
        }

        orig_size = uiop->uio_resid;
        size = orig_size;

        if (size > vport->mtu) {
                if (vport->is_stream) {
                        /* can only send MTU size at a time */
                        size = vport->mtu;
                } else {
                        mutex_exit(&vminor->lock);
                        return (EMSGSIZE);
                }
        }

        D2("vldc_write: vldc@%d:%lu writing %lu bytes\n", instance, portno,
            size);

        rv = uiomove(vport->send_buf, size, UIO_WRITE, uiop);
        if (rv == 0) {
                rv = ldc_write(vport->ldc_handle, (caddr_t)vport->send_buf,
                    &size);
                if (rv != 0) {
                        DWARN("vldc_write: vldc@%d:%lu failed writing %lu "
                            "bytes rv=%d\n", instance, portno, size, rv);
                }
        } else {
                size = 0;
        }

        mutex_exit(&vminor->lock);

        /* resid is total number of bytes *not* sent */
        uiop->uio_resid = orig_size - size;

        return (rv);
}

/* cb_chpoll */
static int
vldc_chpoll(dev_t dev, short events, int anyyet,  short *reventsp,
    struct pollhead **phpp)
{
        int instance;
        minor_t minor;
        uint64_t portno;
        vldc_t *vldcp;
        vldc_port_t *vport;
        vldc_minor_t *vminor;
        boolean_t haspkts;

        minor = getminor(dev);
        instance = VLDCINST(minor);
        vldcp = ddi_get_soft_state(vldc_ssp, instance);
        if (vldcp == NULL) {
                return (ENXIO);
        }

        vminor = VLDCMINOR(vldcp, minor);
        mutex_enter(&vminor->lock);
        portno = vminor->portno;
        if (portno == VLDC_INVALID_PORTNO) {
                mutex_exit(&vminor->lock);
                return (ENOLINK);
        }

        vport = &(vldcp->port[portno]);

        /* check the port status */
        if (vport->status != VLDC_PORT_READY) {
                mutex_exit(&vminor->lock);
                return (ENOTACTIVE);
        }

        D2("vldc_chpoll: vldc@%d:%lu polling events 0x%x\n",
            instance, portno, events);

        *reventsp = 0;

        if (vport->ldc_status == LDC_UP) {
                /*
                 * Check if the receive queue is empty and if not, signal that
                 * there is data ready to read.
                 */
                if (events & POLLIN) {
                        if ((ldc_chkq(vport->ldc_handle, &haspkts) == 0) &&
                            haspkts) {
                                *reventsp |= POLLIN;
                        }
                }

                if (events & POLLOUT)
                        *reventsp |= POLLOUT;

        } else if (vport->hanged_up) {
                *reventsp |= POLLHUP;
                vport->hanged_up = B_FALSE;
        }

        mutex_exit(&vminor->lock);

        if (((*reventsp) == 0) && (!anyyet)) {
                *phpp = &vport->poll;
        }

        D2("vldc_chpoll: vldc@%d:%lu ev=0x%x, rev=0x%x\n",
            instance, portno, events, *reventsp);

        return (0);
}