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

/*
 * Copyright (c) 2014, Joyent, Inc. All rights reserved.
 */

#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/promif.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/cyclic.h>
#include <sys/termio.h>
#include <sys/intr.h>
#include <sys/ivintr.h>
#include <sys/note.h>
#include <sys/stat.h>
#include <sys/fcntl.h>
#include <sys/sysmacros.h>

#include <sys/ldc.h>
#include <sys/mdeg.h>
#include <sys/vcc_impl.h>

#define VCC_LDC_RETRIES         5
#define VCC_LDC_DELAY           1000 /* usec */

/*
 * Function prototypes.
 */

/* DDI entrypoints */
static int      vcc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
static int      vcc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
static int      vcc_open(dev_t *devp, int flag, int otyp, cred_t *cred);
static int      vcc_close(dev_t dev, int flag, int otyp, cred_t *cred);
static int      vcc_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
                        cred_t *credp, int *rvalp);
static int      vcc_read(dev_t dev, struct uio *uiop, cred_t *credp);
static int      vcc_write(dev_t dev, struct uio *uiop, cred_t *credp);
static int      vcc_chpoll(dev_t dev, short events, int anyyet,
                        short *reventsp, struct pollhead **phpp);
static int      vcc_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd,
                        void *arg, void **resultp);

/* callback functions */
static uint_t   vcc_ldc_cb(uint64_t event, caddr_t arg);
static int      vcc_mdeg_cb(void *cb_argp, mdeg_result_t *resp);

/* Internal functions */
static int      i_vcc_ldc_init(vcc_t *vccp, vcc_port_t *vport);
static int      i_vcc_add_port(vcc_t *vccp, char *group_name, uint64_t tcp_port,
                        uint_t portno, char *domain_name);
static int      i_vcc_config_port(vcc_t *vccp, uint_t portno, uint64_t ldc_id);
static int      i_vcc_reset_events(vcc_t *vccp);
static int      i_vcc_cons_tbl(vcc_t *vccp, uint_t num_ports,
                        caddr_t buf, int mode);
static int      i_vcc_del_cons_ok(vcc_t *vccp, caddr_t buf, int mode);
static int      i_vcc_close_port(vcc_port_t *vport);
static int      i_vcc_write_ldc(vcc_port_t *vport, vcc_msg_t *buf);
static int      i_vcc_read_ldc(vcc_port_t *vport, char *data_buf, size_t *sz);

static void *vcc_ssp;

static struct cb_ops vcc_cb_ops = {
        vcc_open,           /* open */
        vcc_close,          /* close */
        nodev,              /* strategy */
        nodev,              /* print */
        nodev,              /* dump */
        vcc_read,           /* read */
        vcc_write,          /* write */
        vcc_ioctl,          /* ioctl */
        nodev,              /* devmap */
        nodev,              /* mmap */
        ddi_segmap,         /* segmap */
        vcc_chpoll,         /* chpoll */
        ddi_prop_op,        /* prop_op */
        NULL,               /* stream */
        D_NEW | D_MP        /* flags */
};


static struct dev_ops vcc_ops = {
        DEVO_REV,               /* rev */
        0,                      /* ref count */
        vcc_getinfo,            /* getinfo */
        nulldev,                /* identify */
        nulldev,                /* probe */
        vcc_attach,             /* attach */
        vcc_detach,             /* detach */
        nodev,                  /* reset */
        &vcc_cb_ops,            /* cb_ops */
        (struct bus_ops *)NULL, /* bus_ops */
        NULL,                   /* power */
        ddi_quiesce_not_needed,         /* quiesce */
};

extern struct mod_ops mod_driverops;

#define     VCC_CHANNEL_ENDPOINT        "channel-endpoint"
#define     VCC_ID_PROP         "id"

/*
 * This is the string displayed by modinfo(8).
 */
static char vcc_ident[] = "sun4v Virtual Console Concentrator Driver";

static struct modldrv md = {
        &mod_driverops,         /* Type - it is a driver */
        vcc_ident,              /* Name of the module */
        &vcc_ops,               /* driver specfic opts */
};

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

/*
 * 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 vcc_port_prop_match[] = {
        { MDET_PROP_VAL,            "id"   },
        { MDET_LIST_END,            NULL    }
};

static mdeg_node_match_t vcc_port_match = {"virtual-device-port",
                                        vcc_port_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 'cfg-handle' value before being passed to the MDEG.
 */
static mdeg_prop_spec_t vcc_prop_template[] = {
        { MDET_PROP_STR,    "name",     "virtual-console-concentrator"  },
        { MDET_PROP_VAL,    "cfg-handle",       NULL    },
        { MDET_LIST_END,    NULL,               NULL    }
};

#define VCC_SET_MDEG_PROP_INST(specp, val) (specp)[1].ps_val = (val);


#ifdef DEBUG

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

int vccdbg = 0x8;

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

        va_start(ap, fmt);
        (void) vsprintf(buf, fmt, ap);
        va_end(ap);

        cmn_err(CE_CONT, "%s\n", buf);
}

#define D1              \
if (vccdbg & 0x01)      \
        vccdebug

#define D2              \
if (vccdbg & 0x02)      \
        vccdebug

#define DWARN           \
if (vccdbg & 0x04)      \
        vccdebug

#else

#define D1
#define D2
#define DWARN

#endif

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

        /* init the soft state structure */
        error = ddi_soft_state_init(&vcc_ssp, sizeof (vcc_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(&vcc_ssp);
        }

        return (error);
}

/* getinfo(9E) */
static int
vcc_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd,  void *arg, void **resultp)
{
        _NOTE(ARGUNUSED(dip))

        int     instance = VCCINST(getminor((dev_t)arg));
        vcc_t   *vccp = NULL;

        switch (cmd) {

        case DDI_INFO_DEVT2DEVINFO:
                if ((vccp = ddi_get_soft_state(vcc_ssp, instance)) == NULL) {
                        *resultp = NULL;
                        return (DDI_FAILURE);
                }
                *resultp = vccp->dip;
                return (DDI_SUCCESS);

        case DDI_INFO_DEVT2INSTANCE:
                *resultp = (void *)(uintptr_t)instance;
                return (DDI_SUCCESS);

        default:
                *resultp = NULL;
                return (DDI_FAILURE);
        }
}

/*
 * There are two cases that need special blocking. One of them is to block
 * a minor node without a port and another is to block application other
 * than vntsd.
 *
 * A minor node can exist in the file system without associated with a port
 * because when a port is deleted, ddi_remove_minor does not unlink it.
 * Clients might try to open a minor node even after the corresponding port
 * node has been removed.  To identify and block these calls,
 * we need to validate the association between a port and its minor node.
 *
 * An application other than vntsd can access a console port as long
 * as vntsd is not using the port. A port opened by an application other
 * than vntsd will be closed when vntsd wants to use the port.
 * However, other application could use same file descriptor
 * access vcc cb_ops. So we need to identify and block caller other
 * than vntsd, when vntsd is using the port.
 */
static int
i_vcc_can_use_port(vcc_minor_t *minorp, vcc_port_t *vport)
{
        if (vport->minorp != minorp) {
                /* port config changed */
                return (ENXIO);
        }

        if (vport->valid_pid == VCC_NO_PID_BLOCKING) {
                /* no blocking needed */
                return (0);
        }

        if (vport->valid_pid != ddi_get_pid()) {
                return (EIO);
        }

        return (0);
}


/* Syncronization between thread using cv_wait */
static int
i_vcc_wait_port_status(vcc_port_t *vport, kcondvar_t *cv, uint32_t status)
{

        int         rv;

        ASSERT(mutex_owned(&vport->lock));

        for (; ; ) {

                if ((vport->status & VCC_PORT_AVAIL) == 0) {
                        /* port has been deleted */
                        D1("i_vcc_wait_port_status: port%d deleted\n",
                            vport->number);
                        return (EIO);
                }

                if ((vport->status & VCC_PORT_OPEN) == 0) {
                        D1("i_vcc_wait_port_status: port%d is closed \n",
                            vport->number);
                        return (EIO);
                }

                if (vport->status & VCC_PORT_LDC_LINK_DOWN) {
                        return (EIO);
                }

                if ((vport->valid_pid != VCC_NO_PID_BLOCKING) &&
                    (vport->valid_pid != ddi_get_pid())) {
                        return (EIO);
                }

                if ((vport->status & status) == status) {
                        return (0);
                }

                if (!ddi_can_receive_sig()) {
                        return (EIO);
                }

                rv = cv_wait_sig(cv, &vport->lock);
                if (rv == 0) {
                        D1("i_vcc_wait_port_status: port%d get intr \n",
                            vport->number);
                        /* got signal */
                        return (EINTR);
                }
        }

}

/* Syncronization between threads, signal state change */
static void
i_vcc_set_port_status(vcc_port_t *vport, kcondvar_t *cv, uint32_t status)
{

        mutex_enter(&vport->lock);
        vport->status |= status;
        cv_broadcast(cv);
        mutex_exit(&vport->lock);
}

/* initialize a ldc channel */
static int
i_vcc_ldc_init(vcc_t *vccp, vcc_port_t *vport)
{
        ldc_attr_t      attr;
        int             rv = EIO;

        ASSERT(mutex_owned(&vport->lock));
        ASSERT(vport->ldc_id != VCC_INVALID_CHANNEL);

        /* initialize the channel */
        attr.devclass = LDC_DEV_SERIAL;
        attr.instance = ddi_get_instance(vccp->dip);
        attr.mtu = VCC_MTU_SZ;
        attr.mode = LDC_MODE_RAW;

        if ((rv = ldc_init(vport->ldc_id, &attr, &(vport->ldc_handle))) != 0) {
                cmn_err(CE_CONT, "i_vcc_ldc_init: port %d ldc channel %ld"
                    " failed ldc_init %d \n", vport->number, vport->ldc_id, rv);
                vport->ldc_id = VCC_INVALID_CHANNEL;
                return (rv);
        }

        /* register it */
        if ((rv = ldc_reg_callback(vport->ldc_handle, vcc_ldc_cb,
            (caddr_t)vport)) != 0) {
                cmn_err(CE_CONT, "i_vcc_ldc_init: port@%d ldc_register_cb"
                    "failed\n", vport->number);
                (void) ldc_fini(vport->ldc_handle);
                vport->ldc_id = VCC_INVALID_CHANNEL;
                return (rv);
        }

        /* open and bring channel up */
        if ((rv = ldc_open(vport->ldc_handle)) != 0) {
                cmn_err(CE_CONT, "i_vcc_ldc_init: port@%d inv channel 0x%lx\n",
                    vport->number, vport->ldc_id);
                (void) ldc_unreg_callback(vport->ldc_handle);
                (void) ldc_fini(vport->ldc_handle);
                vport->ldc_id = VCC_INVALID_CHANNEL;
                return (rv);
        }

        /* init the channel status */
        if ((rv = ldc_status(vport->ldc_handle, &vport->ldc_status)) != 0) {
                cmn_err(CE_CONT, "i_vcc_ldc_init: port@%d ldc_status failed\n",
                    vport->number);
                (void) ldc_close(vport->ldc_handle);
                (void) ldc_unreg_callback(vport->ldc_handle);
                (void) ldc_fini(vport->ldc_handle);
                vport->ldc_id = VCC_INVALID_CHANNEL;
                return (rv);
        }

        return (0);
}

/*  release a ldc channel */
static void
i_vcc_ldc_fini(vcc_port_t *vport)
{
        int             rv = EIO;
        vcc_msg_t       buf;
        size_t          sz;
        int             retry = 0;

        D1("i_vcc_ldc_fini: port@%lld, ldc_id%%llx\n", vport->number,
            vport->ldc_id);

        ASSERT(mutex_owned(&vport->lock));

        /* wait for write available */
        rv = i_vcc_wait_port_status(vport, &vport->write_cv,
            VCC_PORT_USE_WRITE_LDC);

        if (rv == 0) {
                vport->status &= ~VCC_PORT_USE_WRITE_LDC;

                /* send a HUP message */
                buf.type = LDC_CONSOLE_CTRL;
                buf.ctrl_msg = LDC_CONSOLE_HUP;
                buf.size = 0;

                /*
                 * ignore write error since we still want to clean up
                 * ldc channel.
                 */
                (void) i_vcc_write_ldc(vport, &buf);

                mutex_exit(&vport->lock);
                i_vcc_set_port_status(vport, &vport->write_cv,
                    VCC_PORT_USE_WRITE_LDC);
                mutex_enter(&vport->lock);
        }

        /* flush ldc channel */
        rv = i_vcc_wait_port_status(vport, &vport->read_cv,
            VCC_PORT_USE_READ_LDC);

        if (rv == 0) {
                vport->status &= ~VCC_PORT_USE_READ_LDC;
                do {
                        sz = sizeof (buf);
                        rv = i_vcc_read_ldc(vport, (char *)&buf, &sz);
                } while (rv == 0 && sz > 0);

                vport->status |= VCC_PORT_USE_READ_LDC;

        }

        /*
         * ignore read error since we still want to clean up
         * ldc channel.
         */

        (void) ldc_set_cb_mode(vport->ldc_handle, LDC_CB_DISABLE);

        /* close LDC channel - retry on EAGAIN */
        while ((rv = ldc_close(vport->ldc_handle)) == EAGAIN) {

                if (++retry > VCC_LDC_RETRIES) {
                        cmn_err(CE_CONT, "i_vcc_ldc_fini: cannot close channel"
                            " %ld\n", vport->ldc_id);
                        break;
                }

                drv_usecwait(VCC_LDC_DELAY);
        }

        if (rv == 0) {
                (void) ldc_unreg_callback(vport->ldc_handle);
                (void) ldc_fini(vport->ldc_handle);
        } else {
                /*
                 * Closing the LDC channel has failed. Ideally we should
                 * fail here but there is no Zeus level infrastructure
                 * to handle this. The MD has already been changed and
                 * we have to do the close. So we try to do as much
                 * clean up as we can.
                 */
                while (ldc_unreg_callback(vport->ldc_handle) == EAGAIN)
                        drv_usecwait(VCC_LDC_DELAY);
        }

}

/* read data from ldc channel */

static int
i_vcc_read_ldc(vcc_port_t *vport, char *data_buf, size_t *sz)
{

        int             rv;
        size_t          size;
        size_t          space_left = *sz;
        vcc_msg_t       buf;
        int             i;




        /* make sure holding read lock */
        ASSERT((vport->status & VCC_PORT_USE_READ_LDC) == 0);
        ASSERT(space_left >= VCC_MTU_SZ);

        *sz = 0;
        while (space_left >= VCC_MTU_SZ)  {
                size = sizeof (buf);

                rv = ldc_read(vport->ldc_handle, (caddr_t)&buf, &size);

                if (rv) {
                        return (rv);
                }


                /*
                 * FIXME: ldc_read should not reaturn 0 with
                 * either size == 0, buf.size == 0 or size < VCC_HDR_SZ
                 */
                if (size == 0) {
                        if (*sz > 0) {
                                return (0);
                        }
                        return (EAGAIN);
                }

                if (size < VCC_HDR_SZ) {
                        return (EIO);
                }

                /*
                 * only data is expected from console - otherwise
                 * return error
                 */
                if (buf.type != LDC_CONSOLE_DATA) {
                        return (EIO);
                }

                if (buf.size == 0) {
                        if (*sz > 0) {
                                return (0);
                        }
                        return (EAGAIN);
                }

                /* copy  data */
                for (i = 0; i < buf.size; i++, (*sz)++) {
                        data_buf[*sz] = buf.data[i];
                }

                space_left -= buf.size;
        }

        return (0);
}

/* callback from ldc */
static uint_t
vcc_ldc_cb(uint64_t event, caddr_t arg)
{

        vcc_port_t  *vport = (vcc_port_t *)arg;
        boolean_t   hasdata;

        /*
         * do not need to hold lock because if ldc calls back, the
         * ldc_handle must be valid.
         */
        D2("vcc_ldc_cb: callback invoked port=%d events=%llx\n",
            vport->number, event);

        /* check event from ldc */
        if (event & LDC_EVT_WRITE) {
                /* channel has space for write */

                i_vcc_set_port_status(vport, &vport->write_cv,
                    VCC_PORT_LDC_WRITE_READY);
                return (LDC_SUCCESS);
        }

        if (event & LDC_EVT_READ) {

                /* channel has data for read */
                (void) ldc_chkq(vport->ldc_handle, &hasdata);
                if (!hasdata) {
                        /* data already read */
                        return (LDC_SUCCESS);
                }

                i_vcc_set_port_status(vport, &vport->read_cv,
                    VCC_PORT_LDC_DATA_READY);
                return (LDC_SUCCESS);
        }

        if (event & LDC_EVT_DOWN) {
                /* channel is down */
                i_vcc_set_port_status(vport, &vport->write_cv,
                    VCC_PORT_LDC_LINK_DOWN);
                cv_broadcast(&vport->read_cv);

        }

        return (LDC_SUCCESS);

}


/* configure a vcc port with ldc channel */
static int
i_vcc_config_port(vcc_t *vccp, uint_t portno, uint64_t ldc_id)
{
        int             rv = EIO;
        vcc_port_t      *vport;

        if ((portno >= VCC_MAX_PORTS) || (portno == VCC_CONTROL_PORT)) {
                cmn_err(CE_CONT, "i_vcc_config_port: invalid port number %d\n",
                    portno);
                return (EINVAL);
        }

        vport = &(vccp->port[portno]);
        if ((vport->status & VCC_PORT_AVAIL) == 0) {
                cmn_err(CE_CONT, "i_vcc_config_port: port@%d does not exist\n",
                    portno);
                return (EINVAL);
        }


        if (vport->ldc_id != VCC_INVALID_CHANNEL) {
                cmn_err(CE_CONT, "i_vcc_config_port: port@%d channel already"
                    "configured\n", portno);
                return (EINVAL);
        }

        mutex_enter(&vport->lock);

        /* store the ldc ID */
        vport->ldc_id = ldc_id;
        /* check if someone has already opened this port */
        if (vport->status & VCC_PORT_OPEN) {

                if ((rv = i_vcc_ldc_init(vccp, vport)) != 0) {
                        mutex_exit(&vport->lock);
                        return (rv);
                }

                /* mark port as ready */
                vport->status |= VCC_PORT_LDC_CHANNEL_READY;
                cv_broadcast(&vport->read_cv);
                cv_broadcast(&vport->write_cv);
        }

        mutex_exit(&vport->lock);

        D1("i_vcc_config_port: port@%d ldc=%d, domain=%s",
            vport->number, vport->ldc_id, vport->minorp->domain_name);

        return (0);
}

/* add a vcc console port */
static int
i_vcc_add_port(vcc_t *vccp, char *group_name, uint64_t tcp_port,
    uint_t portno, char *domain_name)
{
        int             instance;
        int             rv = MDEG_FAILURE;
        minor_t         minor;
        vcc_port_t      *vport;
        uint_t          minor_idx;
        char            name[MAXPATHLEN];

        if ((portno >= VCC_MAX_PORTS) || (portno == VCC_CONTROL_PORT)) {
                DWARN("i_vcc_add_port: invalid port number %d\n", portno);
                return (MDEG_FAILURE);
        }

        vport = &(vccp->port[portno]);
        if (vport->status & VCC_PORT_AVAIL) {
                /* this port already exists */
                cmn_err(CE_CONT, "i_vcc_add_port: invalid port - port@%d "
                    "exists\n", portno);
                return (MDEG_FAILURE);
        }

        vport->number = portno;
        vport->ldc_id = VCC_INVALID_CHANNEL;

        if (domain_name == NULL) {
                cmn_err(CE_CONT, "i_vcc_add_port: invalid domain name\n");
                return (MDEG_FAILURE);
        }

        if (group_name == NULL) {
                cmn_err(CE_CONT, "i_vcc_add_port: invalid group name\n");
                return (MDEG_FAILURE);
        }

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

        if (minor_idx == vccp->minors_assigned) {
                /* end of lookup - assign new minor number */
                if (minor_idx == VCC_MAX_PORTS) {
                        cmn_err(CE_CONT, "i_vcc_add_port:"
                            "too many minornodes (%d)\n",
                            minor_idx);
                        return (MDEG_FAILURE);
                }

                (void) strlcpy(vccp->minor_tbl[minor_idx].domain_name,
                    domain_name, MAXPATHLEN);

                vccp->minors_assigned++;
        }

        vport->minorp = &vccp->minor_tbl[minor_idx];
        vccp->minor_tbl[minor_idx].portno = portno;

        (void) strlcpy(vport->group_name, group_name, MAXPATHLEN);

        vport->tcp_port = tcp_port;
        D1("i_vcc_add_port:@%d domain=%s, group=%s, tcp=%lld",
            vport->number, vport->minorp->domain_name,
            vport->group_name, vport->tcp_port);


        /*
         * Create a minor node. The minor number is
         * (instance << VCC_INST_SHIFT) | minor_idx
         */
        instance = ddi_get_instance(vccp->dip);

        minor = (instance << VCC_INST_SHIFT) | (minor_idx);

        (void) snprintf(name, MAXPATHLEN - 1, "%s%s", VCC_MINOR_NAME_PREFIX,
            domain_name);

        rv = ddi_create_minor_node(vccp->dip, name, S_IFCHR, minor,
            DDI_NT_SERIAL, 0);

        if (rv != DDI_SUCCESS) {
                vccp->minors_assigned--;
                return (MDEG_FAILURE);
        }

        mutex_enter(&vport->lock);
        vport->status = VCC_PORT_AVAIL | VCC_PORT_ADDED;
        mutex_exit(&vport->lock);


        return (MDEG_SUCCESS);
}

/* delete a port */
static int
i_vcc_delete_port(vcc_t *vccp, vcc_port_t *vport)
{

        char    name[MAXPATHLEN];
        int     rv;


        ASSERT(mutex_owned(&vport->lock));

        if ((vport->status & VCC_PORT_AVAIL) == 0) {
                D1("vcc_del_port port already deleted \n");
                return (0);
        }

        if (vport->status & VCC_PORT_OPEN) {
                /* do not block mdeg callback */
                vport->valid_pid = VCC_NO_PID_BLOCKING;
                rv = i_vcc_close_port(vport);
        }

        /* remove minor node */
        (void) snprintf(name, MAXPATHLEN-1, "%s%s", VCC_MINOR_NAME_PREFIX,
            vport->minorp->domain_name);

        ddi_remove_minor_node(vccp->dip, name);

        /* let read and write thread know */
        cv_broadcast(&vport->read_cv);
        cv_broadcast(&vport->write_cv);
        vport->status = 0;
        return (rv);


}

/* register callback to MDEG */
static int
i_vcc_mdeg_register(vcc_t *vccp, int instance)
{
        mdeg_prop_spec_t        *pspecp;
        mdeg_node_spec_t        *ispecp;
        mdeg_handle_t           mdeg_hdl;
        int                     sz;
        int                     rv;

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

        bcopy(vcc_prop_template, pspecp, sz);

        VCC_SET_MDEG_PROP_INST(pspecp, instance);

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

        /* perform the registration */
        rv = mdeg_register(ispecp, &vcc_port_match, vcc_mdeg_cb,
            vccp, &mdeg_hdl);

        if (rv != MDEG_SUCCESS) {
                cmn_err(CE_CONT, "i_vcc_mdeg_register:"
                    "mdeg_register failed (%d)\n", rv);
                kmem_free(ispecp, sizeof (mdeg_node_spec_t));
                kmem_free(pspecp, sz);
                return (DDI_FAILURE);
        }

        /* save off data that will be needed later */
        vccp->md_ispecp = (void *)ispecp;
        vccp->mdeg_hdl = mdeg_hdl;

        return (0);
}

/* destroy all mutex from port table */
static void
i_vcc_cleanup_port_table(vcc_t *vccp)
{
        int i;
        vcc_port_t *vport;

        for (i = 0; i < VCC_MAX_PORTS; i++) {
                vport = &(vccp->port[i]);
                mutex_destroy(&vport->lock);
                cv_destroy(&vport->read_cv);
                cv_destroy(&vport->write_cv);
        }
}

/*
 * attach(9E): attach a device to the system.
 * called once for each instance of the device on the system.
 */
static int
vcc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        int             i, instance, inst;
        int             rv = DDI_FAILURE;
        vcc_t           *vccp;
        minor_t         minor;
        vcc_port_t      *vport;

        switch (cmd) {

        case DDI_ATTACH:

                instance = ddi_get_instance(dip);
                if (ddi_soft_state_zalloc(vcc_ssp, instance) != DDI_SUCCESS)
                        return (DDI_FAILURE);

                vccp = ddi_get_soft_state(vcc_ssp, instance);
                if (vccp == NULL) {
                        ddi_soft_state_free(vccp, instance);
                        return (ENXIO);
                }

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

                /* initialize the mutex */
                mutex_init(&vccp->lock, NULL, MUTEX_DRIVER, NULL);

                mutex_enter(&vccp->lock);

                vccp->dip = dip;

                for (i = 0; i < VCC_MAX_PORTS; i++) {
                        vport = &(vccp->port[i]);
                        mutex_init(&vport->lock, NULL, MUTEX_DRIVER, NULL);
                        cv_init(&vport->read_cv, NULL, CV_DRIVER, NULL);
                        cv_init(&vport->write_cv, NULL, CV_DRIVER, NULL);
                        vport->valid_pid = VCC_NO_PID_BLOCKING;
                }

                vport = &vccp->port[VCC_CONTROL_PORT];
                mutex_enter(&vport->lock);

                vport->minorp = &vccp->minor_tbl[VCC_CONTROL_MINOR_IDX];
                vport->status |= VCC_PORT_AVAIL;

                /* create a minor node for vcc control */
                minor = (instance << VCC_INST_SHIFT) | VCC_CONTROL_MINOR_IDX;

                vccp->minor_tbl[VCC_CONTROL_PORT].portno =
                    VCC_CONTROL_MINOR_IDX;


                rv = ddi_create_minor_node(vccp->dip, "ctl", S_IFCHR, minor,
                    DDI_NT_SERIAL, 0);

                mutex_exit(&vport->lock);

                if (rv != DDI_SUCCESS) {
                        cmn_err(CE_CONT, "vcc_attach: error"
                            "creating control minor node\n");

                        i_vcc_cleanup_port_table(vccp);

                        mutex_exit(&vccp->lock);
                        /* clean up soft state */
                        ddi_soft_state_free(vccp, instance);

                        return (DDI_FAILURE);
                }

                /* get the instance number by reading 'reg' property */
                inst = ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
                    "reg", -1);
                if (inst == -1) {
                        cmn_err(CE_CONT, "vcc_attach: vcc%d has no "
                            "'reg' property\n",
                            ddi_get_instance(dip));

                        i_vcc_cleanup_port_table(vccp);

                        /* remove minor */
                        ddi_remove_minor_node(vccp->dip, NULL);

                        /* clean up soft state */
                        mutex_exit(&vccp->lock);
                        ddi_soft_state_free(vccp, instance);

                        return (DDI_FAILURE);
                }

                /*
                 * Mdeg might invoke callback in the same call sequence
                 * if there is a domain port at the time of registration.
                 * Since the callback also grabs vcc->lock mutex, to avoid
                 * mutex reentry error, release the lock before registration
                 */
                mutex_exit(&vccp->lock);

                /* register for notifications from Zeus */
                rv = i_vcc_mdeg_register(vccp, inst);
                if (rv != MDEG_SUCCESS) {
                        cmn_err(CE_CONT, "vcc_attach: error register to MD\n");

                        i_vcc_cleanup_port_table(vccp);

                        /* remove minor */
                        ddi_remove_minor_node(vccp->dip, NULL);

                        /* clean up soft state */
                        ddi_soft_state_free(vccp, 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
vcc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        int                 i, instance;
        vcc_t               *vccp;
        mdeg_node_spec_t    *ispecp;
        vcc_port_t          *vport;

        switch (cmd) {

        case DDI_DETACH:

                instance = ddi_get_instance(dip);
                vccp = ddi_get_soft_state(vcc_ssp, instance);
                if (vccp == NULL)
                        return (ENXIO);

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

                mutex_enter(&vccp->lock);

                /* unregister from MD event generator */

                ASSERT(vccp->mdeg_hdl);
                (void) mdeg_unregister(vccp->mdeg_hdl);

                ispecp = (mdeg_node_spec_t *)vccp->md_ispecp;
                ASSERT(ispecp);

                kmem_free(ispecp->specp, sizeof (vcc_prop_template));
                kmem_free(ispecp, sizeof (mdeg_node_spec_t));

                /* remove minor nodes */
                ddi_remove_minor_node(vccp->dip, NULL);
                mutex_exit(&vccp->lock);

                for (i = 0; i < VCC_MAX_PORTS; i++) {

                        vport = &vccp->port[i];
                        mutex_enter(&vport->lock);
                        if (i == VCC_CONTROL_PORT) {
                                if (vport->status & VCC_PORT_OPEN) {
                                        (void) i_vcc_close_port(vport);
                                }
                        }

                        if ((vccp->port[i].status & VCC_PORT_AVAIL) &&
                            (i != VCC_CONTROL_PORT)) {
                                D1("vcc_detach: removing port port@%d\n", i);
                                (void) i_vcc_delete_port(vccp, vport);
                        }
                        mutex_exit(&vport->lock);
                        cv_destroy(&vport->read_cv);
                        cv_destroy(&vport->write_cv);
                        mutex_destroy(&vport->lock);
                }



                /* destroy mutex and free the soft state */
                mutex_destroy(&vccp->lock);
                ddi_soft_state_free(vcc_ssp, instance);

                return (DDI_SUCCESS);

        case DDI_SUSPEND:

                return (DDI_SUCCESS);

        default:

                return (DDI_FAILURE);
        }
}

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

        int         instance;
        int         rv = EIO;
        minor_t     minor;
        uint_t      portno;
        vcc_t       *vccp;
        vcc_port_t  *vport;

        minor = getminor(*devp);
        instance = VCCINST(minor);

        vccp = ddi_get_soft_state(vcc_ssp, instance);
        if (vccp == NULL) {
                return (ENXIO);
        }

        portno = VCCPORT(vccp, minor);

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

        mutex_enter(&vport->lock);

        if ((vport->status & VCC_PORT_AVAIL) == 0) {
                /* port may be removed */
                mutex_exit(&vport->lock);
                return (ENXIO);
        }

        if (vport->status & VCC_PORT_OPEN) {
                /* only one open per port */
                cmn_err(CE_CONT, "vcc_open: virtual-console-concentrator@%d:%d "
                    "is already open\n", instance, portno);
                mutex_exit(&vport->lock);
                return (EAGAIN);
        }

        /* check minor no and pid */
        if ((rv = i_vcc_can_use_port(VCCMINORP(vccp, minor),
            vport)) != 0) {
                mutex_exit(&vport->lock);
                return (rv);
        }

        if (portno == VCC_CONTROL_PORT) {
                vport->status |= VCC_PORT_OPEN;
                mutex_exit(&vport->lock);
                return (0);
        }

        /*
         * the port may just be added by mdeg callback and may
         * not be configured yet.
         */
        if (vport->ldc_id == VCC_INVALID_CHANNEL) {
                mutex_exit(&vport->lock);
                return (ENXIO);
        }


        /* check if channel has been initialized */
        if ((vport->status & VCC_PORT_LDC_CHANNEL_READY) == 0) {
                rv = i_vcc_ldc_init(vccp, vport);
                if (rv) {
                        mutex_exit(&vport->lock);
                        return (EIO);
                }

                /* mark port as ready */
                vport->status |= VCC_PORT_LDC_CHANNEL_READY;
        }

        vport->status |= VCC_PORT_USE_READ_LDC | VCC_PORT_USE_WRITE_LDC|
            VCC_PORT_TERM_RD|VCC_PORT_TERM_WR|VCC_PORT_OPEN;

        if ((flag & O_NONBLOCK) || (flag & O_NDELAY)) {
                vport->status |= VCC_PORT_NONBLOCK;
        }

        mutex_exit(&vport->lock);

        return (0);
}

/* close port */
static int
i_vcc_close_port(vcc_port_t *vport)
{

        if ((vport->status & VCC_PORT_OPEN) == 0) {
                return (0);
        }

        ASSERT(mutex_owned(&vport->lock));

        if (vport->status & VCC_PORT_LDC_CHANNEL_READY) {
                /* clean up ldc channel */
                i_vcc_ldc_fini(vport);
                vport->status &= ~VCC_PORT_LDC_CHANNEL_READY;
        }

        /* reset  rd/wr suspends  */
        vport->status |= VCC_PORT_TERM_RD | VCC_PORT_TERM_WR;
        vport->status &= ~VCC_PORT_NONBLOCK;
        vport->status &= ~VCC_PORT_OPEN;
        vport->valid_pid = VCC_NO_PID_BLOCKING;

        /* signal any blocked read and write thread */
        cv_broadcast(&vport->read_cv);
        cv_broadcast(&vport->write_cv);

        return (0);
}

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

        int         instance;
        minor_t     minor;
        int         rv = EIO;
        uint_t      portno;
        vcc_t       *vccp;
        vcc_port_t  *vport;

        minor = getminor(dev);

        instance = VCCINST(minor);
        vccp = ddi_get_soft_state(vcc_ssp, instance);
        if (vccp == NULL) {
                return (ENXIO);
        }

        portno = VCCPORT(vccp, minor);

        D1("vcc_close: closing virtual-console-concentrator@%d:%d\n",
            instance, portno);
        vport = &(vccp->port[portno]);


        /*
         * needs lock to provent i_vcc_delete_port, which is called by
         * the mdeg callback, from closing port.
         */
        mutex_enter(&vport->lock);

        if ((vport->status & VCC_PORT_OPEN) == 0) {
                mutex_exit(&vport->lock);
                return (0);
        }

        if (portno == VCC_CONTROL_PORT) {
                /*
                 * vntsd closes control port before it exits. There
                 * could be events still pending for vntsd.
                 */
                mutex_exit(&vport->lock);
                rv = i_vcc_reset_events(vccp);
                return (0);
        }


        /* check minor no and pid */
        if ((rv = i_vcc_can_use_port(VCCMINORP(vccp, minor),
            vport)) != 0) {
                mutex_exit(&vport->lock);
                return (rv);
        }

        rv = i_vcc_close_port(vport);
        mutex_exit(&vport->lock);

        return (rv);
}

/*
 * ioctl VCC_CONS_TBL - vntsd allocates buffer according to return of
 * VCC_NUM_PORTS. However, when vntsd requests for the console table, console
 * ports could be deleted or added. parameter num_ports is number of structures
 * that vntsd allocated for the table. If there are more ports than
 * num_ports, set up to wakeup vntsd to add ports.
 * If there less ports than num_ports, fill (-1) for cons_no to tell vntsd.
 */
static int
i_vcc_cons_tbl(vcc_t *vccp, uint_t num_ports, caddr_t buf, int mode)
{
        vcc_console_t   cons;
        int             i;
        vcc_port_t      *vport;
        boolean_t       notify_vntsd = B_FALSE;
        char pathname[MAXPATHLEN];


        (void) ddi_pathname(vccp->dip, pathname);
        for (i = 0; i < VCC_MAX_PORTS; i++) {

                vport = &vccp->port[i];

                if (i == VCC_CONTROL_PORT) {
                        continue;
                }

                if ((vport->status & VCC_PORT_AVAIL) == 0) {
                        continue;
                }

                /* a port exists before vntsd becomes online */
                mutex_enter(&vport->lock);

                if (num_ports == 0) {
                        /* more ports than vntsd's buffer can hold */
                        vport->status |= VCC_PORT_ADDED;
                        notify_vntsd = B_TRUE;
                        mutex_exit(&vport->lock);
                        continue;
                }

                bzero(&cons, sizeof (vcc_console_t));

                /* construct console buffer */
                cons.cons_no = vport->number;
                cons.tcp_port = vport->tcp_port;
                (void) memcpy(cons.domain_name,
                    vport->minorp->domain_name, MAXPATHLEN);

                (void) memcpy(cons.group_name, vport->group_name,
                    MAXPATHLEN);
                vport->status &= ~VCC_PORT_ADDED;
                mutex_exit(&vport->lock);

                (void) snprintf(cons.dev_name, MAXPATHLEN-1, "%s:%s%s",
                    pathname, VCC_MINOR_NAME_PREFIX, cons.domain_name);

                /* copy out data */
                if (ddi_copyout(&cons, (void *)buf,
                    sizeof (vcc_console_t), mode)) {
                        mutex_exit(&vport->lock);
                        return (EFAULT);
                }
                buf += sizeof (vcc_console_t);

                num_ports--;

        }

        if (num_ports == 0) {
                /* vntsd's buffer is full */

                if (notify_vntsd) {
                        /* more ports need to notify vntsd */
                        vport = &vccp->port[VCC_CONTROL_PORT];
                        mutex_enter(&vport->lock);
                        vport->pollevent |= VCC_POLL_ADD_PORT;
                        mutex_exit(&vport->lock);
                }

                return (0);
        }

        /* less ports than vntsd expected */
        bzero(&cons, sizeof (vcc_console_t));
        cons.cons_no = -1;

        while (num_ports > 0) {
                /* fill vntsd buffer with no console */
                if (ddi_copyout(&cons, (void *)buf,
                    sizeof (vcc_console_t), mode) != 0) {
                        mutex_exit(&vport->lock);
                        return (EFAULT);
                }
                D1("i_vcc_cons_tbl: a port is  deleted\n");
                buf += sizeof (vcc_console_t) +MAXPATHLEN;
                num_ports--;
        }

        return (0);
}


/* turn off event flag if there is no more change */
static void
i_vcc_turn_off_event(vcc_t *vccp, uint32_t port_status, uint32_t event)
{

        vcc_port_t *vport;
        int i;

        for (i = 0; i < VCC_MAX_PORTS; i++) {

                vport = &(vccp->port[i]);

                if ((vport->status & VCC_PORT_AVAIL) == 0) {
                        continue;
                }


                if (vport->status & port_status) {
                        /* more port changes status */
                        return;
                }

        }

        /* no more changed port  */
        vport = &vccp->port[VCC_CONTROL_PORT];

        /* turn off event */
        mutex_enter(&vport->lock);
        vport->pollevent &= ~event;
        mutex_exit(&vport->lock);
}

/* ioctl VCC_CONS_INFO */
static int
i_vcc_cons_info(vcc_t *vccp, caddr_t buf, int mode)
{
        vcc_console_t   cons;
        uint_t          portno;
        vcc_port_t      *vport;
        char pathname[MAXPATHLEN];

        /* read in portno */
        if (ddi_copyin((void*)buf, &portno, sizeof (uint_t), mode)) {
                return (EFAULT);
        }

        D1("i_vcc_cons_info@%d:\n", portno);

        if ((portno >= VCC_MAX_PORTS) || (portno == VCC_CONTROL_PORT)) {
                return (EINVAL);
        }

        vport = &vccp->port[portno];

        if ((vport->status & VCC_PORT_AVAIL) == 0) {
                return (EINVAL);
        }

        mutex_enter(&vport->lock);
        vport->status &= ~VCC_PORT_ADDED;

        /* construct configruation data  */
        bzero(&cons, sizeof (vcc_console_t));

        cons.cons_no = vport->number;
        cons.tcp_port = vport->tcp_port;

        (void) memcpy(cons.domain_name, vport->minorp->domain_name, MAXPATHLEN);

        (void) memcpy(cons.group_name, vport->group_name, MAXPATHLEN);

        mutex_exit(&vport->lock);

        (void) ddi_pathname(vccp->dip, pathname),

            /* copy device name */
            (void) snprintf(cons.dev_name, MAXPATHLEN-1, "%s:%s%s",
            pathname, VCC_MINOR_NAME_PREFIX, cons.domain_name);
        /* copy data */
        if (ddi_copyout(&cons, (void *)buf,
            sizeof (vcc_console_t), mode) != 0) {
                mutex_exit(&vport->lock);
                return (EFAULT);
        }

        D1("i_vcc_cons_info@%d:domain:%s serv:%s tcp@%lld %s\n",
            cons.cons_no, cons.domain_name,
            cons.group_name, cons.tcp_port, cons.dev_name);

        i_vcc_turn_off_event(vccp, VCC_PORT_ADDED, VCC_POLL_ADD_PORT);

        return (0);
}


/* response to vntsd inquiry ioctl call */
static int
i_vcc_inquiry(vcc_t *vccp, caddr_t buf, int mode)
{
        vcc_port_t      *vport;
        uint_t          i;
        vcc_response_t  msg;

        vport = &(vccp->port[VCC_CONTROL_PORT]);

        if ((vport->pollevent & VCC_POLL_ADD_PORT) == 0) {
                return (EINVAL);
        }

        /* an added port */

        D1("i_vcc_inquiry\n");

        for (i = 0; i < VCC_MAX_PORTS; i++) {
                if ((vccp->port[i].status & VCC_PORT_AVAIL) == 0) {
                        continue;
                }

                if (vccp->port[i].status & VCC_PORT_ADDED) {
                        /* port added */
                        msg.reason = VCC_CONS_ADDED;
                        msg.cons_no = i;

                        if (ddi_copyout((void *)&msg, (void *)buf,
                            sizeof (msg), mode) == -1) {
                                cmn_err(CE_CONT, "i_vcc_find_changed_port:"
                                    "ddi_copyout"
                                    " failed\n");
                                return (EFAULT);
                        }
                        return (0);
                }
        }

        /* the added port was deleted before vntsd wakes up */
        msg.reason = VCC_CONS_MISS_ADDED;

        if (ddi_copyout((void *)&msg, (void *)buf,
            sizeof (msg), mode) == -1) {
                cmn_err(CE_CONT, "i_vcc_find_changed_port: ddi_copyout"
                    " failed\n");
                return (EFAULT);
        }

        return (0);
}

/* clean up events after vntsd exits */
static int
i_vcc_reset_events(vcc_t *vccp)
{
        uint_t      i;
        vcc_port_t  *vport;

        for (i = 0; i < VCC_MAX_PORTS; i++) {
                vport = &(vccp->port[i]);

                if ((vport->status & VCC_PORT_AVAIL) == 0) {
                        continue;
                }

                ASSERT(!mutex_owned(&vport->lock));

                if (i == VCC_CONTROL_PORT) {
                        /* close control port */
                        mutex_enter(&vport->lock);
                        vport->status &= ~VCC_PORT_OPEN;

                        /* clean up poll events */
                        vport->pollevent = 0;
                        vport->pollflag = 0;
                        mutex_exit(&vport->lock);
                        continue;
                }
                if (vport->status & VCC_PORT_ADDED) {
                        /* pending added port event to vntsd */
                        mutex_enter(&vport->lock);
                        vport->status &= ~VCC_PORT_ADDED;
                        mutex_exit(&vport->lock);
                }

        }

        vport = &vccp->port[VCC_CONTROL_PORT];

        return (0);
}

/* ioctl VCC_FORCE_CLOSE */
static int
i_vcc_force_close(vcc_t *vccp, caddr_t buf, int mode)
{
        uint_t          portno;
        vcc_port_t      *vport;
        int             rv;

        /* read in portno */
        if (ddi_copyin((void*)buf, &portno, sizeof (uint_t), mode)) {
                return (EFAULT);
        }

        D1("i_vcc_force_close@%d:\n", portno);

        if ((portno >= VCC_MAX_PORTS) || (portno == VCC_CONTROL_PORT)) {
                return (EINVAL);
        }

        vport = &vccp->port[portno];

        if ((vport->status & VCC_PORT_AVAIL) == 0) {
                return (EINVAL);
        }

        mutex_enter(&vport->lock);

        rv = i_vcc_close_port(vport);

        /* block callers other than vntsd */
        vport->valid_pid = ddi_get_pid();

        mutex_exit(&vport->lock);
        return (rv);

}

/* ioctl VCC_CONS_STATUS */
static int
i_vcc_cons_status(vcc_t *vccp, caddr_t buf, int mode)
{
        vcc_console_t   console;
        vcc_port_t      *vport;

        /* read in portno */
        if (ddi_copyin((void*)buf, &console, sizeof (console), mode)) {
                return (EFAULT);
        }

        D1("i_vcc_cons_status@%d:\n", console.cons_no);

        if ((console.cons_no >= VCC_MAX_PORTS) ||
            (console.cons_no == VCC_CONTROL_PORT)) {
                return (EINVAL);
        }


        vport = &vccp->port[console.cons_no];
        if ((vport->status & VCC_PORT_AVAIL) == 0) {
                console.cons_no = -1;
        } else  if (strncmp(console.domain_name, vport->minorp->domain_name,
            MAXPATHLEN)) {
                console.cons_no = -1;
        } else if (strncmp(console.group_name, vport->group_name,
            MAXPATHLEN)) {
                console.cons_no = -1;
        } else if (console.tcp_port != vport->tcp_port) {
                console.cons_no = -1;
        } else if (vport->ldc_id == VCC_INVALID_CHANNEL) {
                console.cons_no = -1;
        }

        D1("i_vcc_cons_status@%d: %s %s %llx\n", console.cons_no,
            console.group_name, console.domain_name, console.tcp_port);
        if (ddi_copyout(&console, (void *)buf, sizeof (console), mode) == -1) {
                cmn_err(CE_CONT, "i_vcc_cons_status ddi_copyout failed\n");
                return (EFAULT);
        }

        return (0);
}

/* cb_ioctl handler for vcc control port */
static int
i_vcc_ctrl_ioctl(vcc_t *vccp, int cmd, void* arg, int mode)
{

        static uint_t   num_ports;


        switch (cmd) {

        case VCC_NUM_CONSOLE:

                mutex_enter(&vccp->lock);
                num_ports = vccp->num_ports;
                mutex_exit(&vccp->lock);
                /* number of consoles */

                return (ddi_copyout((void *)&num_ports, arg,
                    sizeof (int), mode));
        case VCC_CONS_TBL:

                /* console config table */
                return (i_vcc_cons_tbl(vccp, num_ports, (caddr_t)arg, mode));

        case VCC_INQUIRY:

                /* reason for wakeup */
                return (i_vcc_inquiry(vccp, (caddr_t)arg, mode));

        case VCC_CONS_INFO:
                /* a console config */
                return (i_vcc_cons_info(vccp, (caddr_t)arg, mode));

        case VCC_FORCE_CLOSE:
                /* force to close a console */
                return (i_vcc_force_close(vccp, (caddr_t)arg, mode));

        case VCC_CONS_STATUS:
                /* console status */
                return (i_vcc_cons_status(vccp, (caddr_t)arg, mode));

        default:

                /* unknown command */
                return (ENODEV);
        }


}

/* write data to ldc. may block if channel has no space for write */
static int
i_vcc_write_ldc(vcc_port_t *vport, vcc_msg_t *buf)
{
        int     rv = EIO;
        size_t  size;

        ASSERT(mutex_owned(&vport->lock));
        ASSERT((vport->status & VCC_PORT_USE_WRITE_LDC) == 0);

        for (; ; ) {

                size = VCC_HDR_SZ + buf->size;
                rv = ldc_write(vport->ldc_handle, (caddr_t)buf, &size);

                D1("i_vcc_write_ldc: port@%d: err=%d %d bytes\n",
                    vport->number, rv, size);

                if (rv == 0) {
                        return (rv);
                }

                if (rv != EWOULDBLOCK) {
                        return (EIO);
                }

                if (vport->status & VCC_PORT_NONBLOCK) {
                        return (EAGAIN);
                }

                /*  block util ldc has more space */

                rv = i_vcc_wait_port_status(vport, &vport->write_cv,
                    VCC_PORT_LDC_WRITE_READY);

                if (rv) {
                        return (rv);
                }

                vport->status &= ~VCC_PORT_LDC_WRITE_READY;

        }

}



/* cb_ioctl handler for port ioctl */
static int
i_vcc_port_ioctl(vcc_t *vccp, minor_t minor, int portno, int cmd, void *arg,
    int mode)
{

        vcc_port_t      *vport;
        struct termios  term;
        vcc_msg_t       buf;
        int             rv;

        D1("i_vcc_port_ioctl@%d cmd %d\n", portno, cmd);

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

        if ((vport->status & VCC_PORT_AVAIL) == 0) {
                return (EIO);
        }


        switch (cmd) {

        /* terminal support */
        case TCGETA:
        case TCGETS:

                mutex_enter(&vport->lock);

                /* check minor no and pid */
                if ((rv = i_vcc_can_use_port(VCCMINORP(vccp, minor),
                    vport)) != 0) {
                        mutex_exit(&vport->lock);
                        return (rv);
                }

                (void) memcpy(&term, &vport->term, sizeof (term));
                mutex_exit(&vport->lock);

                return (ddi_copyout(&term, arg, sizeof (term), mode));

        case TCSETS:
        case TCSETA:
        case TCSETAW:
        case TCSETAF:

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

                mutex_enter(&vport->lock);

                /* check minor no and pid */
                if ((rv = i_vcc_can_use_port(VCCMINORP(vccp, minor),
                    vport)) != 0) {
                        mutex_exit(&vport->lock);
                        return (rv);
                }

                (void) memcpy(&vport->term, &term, sizeof (term));
                mutex_exit(&vport->lock);
                return (0);


        case TCSBRK:

                /* send break to console */
                mutex_enter(&vport->lock);

                /* check minor no and pid */
                if ((rv = i_vcc_can_use_port(VCCMINORP(vccp, minor),
                    vport)) != 0) {
                        mutex_exit(&vport->lock);
                        return (rv);
                }

                /* wait for write available */
                rv = i_vcc_wait_port_status(vport, &vport->write_cv,
                    VCC_PORT_LDC_CHANNEL_READY| VCC_PORT_USE_WRITE_LDC);
                if (rv) {
                        mutex_exit(&vport->lock);
                        return (rv);
                }

                vport->status &= ~VCC_PORT_USE_WRITE_LDC;

                buf.type = LDC_CONSOLE_CTRL;
                buf.ctrl_msg = LDC_CONSOLE_BREAK;
                buf.size = 0;

                rv = i_vcc_write_ldc(vport, &buf);

                mutex_exit(&vport->lock);

                i_vcc_set_port_status(vport, &vport->write_cv,
                    VCC_PORT_USE_WRITE_LDC);
                return (0);

        case TCXONC:
                /* suspend read or write */
                if (ddi_copyin(arg, &cmd, sizeof (int), mode) != 0) {
                        return (EFAULT);
                }

                mutex_enter(&vport->lock);

                /* check minor no and pid */
                if ((rv = i_vcc_can_use_port(VCCMINORP(vccp, minor),
                    vport)) != 0) {
                        mutex_exit(&vport->lock);
                        return (rv);
                }


                switch (cmd) {

                case 0:
                        /* suspend read */
                        vport->status &= ~VCC_PORT_TERM_RD;
                        break;

                case 1:
                        /* resume read */
                        vport->status |= VCC_PORT_TERM_RD;
                        cv_broadcast(&vport->read_cv);
                        break;

                case 2:
                        /* suspend write */
                        vport->status &= ~VCC_PORT_TERM_WR;
                        break;

                case 3:
                        /* resume write */
                        vport->status |= VCC_PORT_TERM_WR;
                        cv_broadcast(&vport->write_cv);
                        break;

                default:
                        mutex_exit(&vport->lock);
                        return (EINVAL);
                }

                mutex_exit(&vport->lock);
                return (0);

        case TCFLSH:
                return (0);

        default:
                return (EINVAL);
        }

}

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

        int instance;
        minor_t minor;
        int portno;
        vcc_t *vccp;

        minor = getminor(dev);

        instance = VCCINST(minor);

        vccp = ddi_get_soft_state(vcc_ssp, instance);
        if (vccp == NULL) {
                return (ENXIO);
        }

        portno = VCCPORT(vccp, minor);

        D1("vcc_ioctl: virtual-console-concentrator@%d:%d\n", instance, portno);

        if (portno >= VCC_MAX_PORTS) {
                cmn_err(CE_CONT, "vcc_ioctl:virtual-console-concentrator@%d"
                    " invalid portno\n", portno);
                return (EINVAL);
        }

        D1("vcc_ioctl: virtual-console-concentrator@%d:%d ioctl cmd=%d\n",
            instance, portno, cmd);

        if (portno == VCC_CONTROL_PORT) {
                /* control ioctl */
                return (i_vcc_ctrl_ioctl(vccp, cmd, (void *)arg, mode));
        }

        /* data port ioctl */
        return (i_vcc_port_ioctl(vccp, minor, portno, cmd, (void *)arg, mode));
}

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

        int         instance;
        minor_t     minor;
        uint_t      portno;
        vcc_t       *vccp;
        vcc_port_t  *vport;
        int         rv = EIO;   /* by default fail ! */
        char            *buf;
        size_t          uio_size;
        size_t          size;

        minor = getminor(dev);

        instance = VCCINST(minor);

        vccp = ddi_get_soft_state(vcc_ssp, instance);
        if (vccp == NULL) {
                return (ENXIO);
        }

        portno = VCCPORT(vccp, minor);

        /* no read for control port */
        if (portno == VCC_CONTROL_PORT) {
                return (EIO);
        }

        /* temp buf to hold ldc data */
        uio_size = uiop->uio_resid;

        if (uio_size < VCC_MTU_SZ) {
                return (EINVAL);
        }

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

        mutex_enter(&vport->lock);

        /* check minor no and pid */
        if ((rv = i_vcc_can_use_port(VCCMINORP(vccp, minor),
            vport)) != 0) {
                mutex_exit(&vport->lock);
                return (rv);
        }

        rv = i_vcc_wait_port_status(vport, &vport->read_cv,
            VCC_PORT_TERM_RD|VCC_PORT_LDC_CHANNEL_READY|
            VCC_PORT_USE_READ_LDC);
        if (rv) {
                mutex_exit(&vport->lock);
                return (rv);
        }

        buf = kmem_alloc(uio_size, KM_SLEEP);

        vport->status &= ~VCC_PORT_USE_READ_LDC;

        for (; ; ) {

                size = uio_size;
                rv = i_vcc_read_ldc(vport, buf, &size);


                if (rv == EAGAIN) {
                        /* should block? */
                        if (vport->status & VCC_PORT_NONBLOCK) {
                                break;
                        }

                } else if (rv) {
                        /* error */
                        break;
                }

                if (size > 0) {
                        /* got data */
                        break;
                }

                /* wait for data from ldc */
                vport->status &= ~VCC_PORT_LDC_DATA_READY;

                mutex_exit(&vport->lock);
                i_vcc_set_port_status(vport, &vport->read_cv,
                    VCC_PORT_USE_READ_LDC);
                mutex_enter(&vport->lock);

                rv = i_vcc_wait_port_status(vport, &vport->read_cv,
                    VCC_PORT_TERM_RD|VCC_PORT_LDC_CHANNEL_READY|
                    VCC_PORT_USE_READ_LDC| VCC_PORT_LDC_DATA_READY);
                if (rv) {
                        break;
                }

                vport->status &= ~VCC_PORT_USE_READ_LDC;
        }

        mutex_exit(&vport->lock);

        if ((rv == 0) && (size > 0)) {
                /* data is in buf */
                rv = uiomove(buf, size, UIO_READ, uiop);
        }

        kmem_free(buf, uio_size);
        i_vcc_set_port_status(vport, &vport->read_cv, VCC_PORT_USE_READ_LDC);

        return (rv);
}


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

        int         instance;
        minor_t     minor;
        size_t      size;
        size_t      bytes;
        uint_t      portno;
        vcc_t       *vccp;

        vcc_port_t  *vport;
        int         rv = EIO;

        vcc_msg_t       buf;

        minor = getminor(dev);

        instance = VCCINST(minor);

        vccp = ddi_get_soft_state(vcc_ssp, instance);
        if (vccp == NULL) {
                return (ENXIO);
        }

        portno = VCCPORT(vccp, minor);

        /* no write for control port */
        if (portno == VCC_CONTROL_PORT) {
                return (EIO);
        }
        vport = &(vccp->port[portno]);

        /*
         * check if the channel has been configured,
         * if write has been suspend and grab write lock.
         */
        mutex_enter(&vport->lock);

        /* check minor no and pid */
        if ((rv = i_vcc_can_use_port(VCCMINORP(vccp, minor),
            vport)) != 0) {
                mutex_exit(&vport->lock);
                return (rv);
        }

        rv = i_vcc_wait_port_status(vport, &vport->write_cv,
            VCC_PORT_TERM_WR|VCC_PORT_LDC_CHANNEL_READY|
            VCC_PORT_USE_WRITE_LDC);
        if (rv) {
                mutex_exit(&vport->lock);
                return (rv);
        }

        vport->status &= ~VCC_PORT_USE_WRITE_LDC;
        mutex_exit(&vport->lock);
        size = uiop->uio_resid;

        D2("vcc_write: virtual-console-concentrator@%d:%d writing %d bytes\n",
            instance, portno, size);



        buf.type = LDC_CONSOLE_DATA;

        while (size) {

                bytes = MIN(size, VCC_MTU_SZ);
                /* move data */
                rv = uiomove(&(buf.data), bytes, UIO_WRITE, uiop);

                if (rv) {
                        break;
                }

                /* write to ldc */
                buf.size = bytes;

                mutex_enter(&vport->lock);

                /* check minor no and pid */
                if ((rv = i_vcc_can_use_port(VCCMINORP(vccp, minor),
                    vport)) != 0) {
                        mutex_exit(&vport->lock);
                        return (rv);
                }

                rv = i_vcc_write_ldc(vport, &buf);

                mutex_exit(&vport->lock);

                if (rv) {
                        break;
                }

                size -= bytes;

        }

        i_vcc_set_port_status(vport, &vport->write_cv, VCC_PORT_USE_WRITE_LDC);
        return (rv);
}

/* mdeg callback for a removed port */
static int
i_vcc_md_remove_port(md_t *mdp, mde_cookie_t mdep, vcc_t *vccp)
{
        uint64_t  portno;       /* md requires 64bit for port number */
        int rv = MDEG_FAILURE;
        vcc_port_t *vport;

        if (md_get_prop_val(mdp, mdep, "id", &portno)) {
                cmn_err(CE_CONT, "vcc_mdeg_cb: port has no 'id' property\n");
                return (MDEG_FAILURE);
        }

        if ((portno >= VCC_MAX_PORTS) || (portno < 0)) {
                cmn_err(CE_CONT, "i_vcc_md_remove_port@%ld invalid port no\n",
                    portno);
                return (MDEG_FAILURE);
        }

        if (portno == VCC_CONTROL_PORT) {
                cmn_err(CE_CONT, "i_vcc_md_remove_port@%ld can not remove"
                    "control port\n",
                    portno);
                return (MDEG_FAILURE);
        }

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

        /* delete the port */
        mutex_enter(&vport->lock);
        rv = i_vcc_delete_port(vccp, vport);
        mutex_exit(&vport->lock);

        mutex_enter(&vccp->lock);
        vccp->num_ports--;
        mutex_exit(&vccp->lock);

        return (rv ? MDEG_FAILURE : MDEG_SUCCESS);
}

static int
i_vcc_get_ldc_id(md_t *md, mde_cookie_t mdep, uint64_t *ldc_id)
{
        int             num_nodes;
        size_t          size;
        mde_cookie_t    *channel;
        int             num_channels;


        if ((num_nodes = md_node_count(md)) <= 0) {
                cmn_err(CE_CONT, "i_vcc_get_ldc_channel_id:"
                    "  Invalid node count in Machine Description subtree");
                return (-1);
        }
        size = num_nodes*(sizeof (*channel));
        channel = kmem_zalloc(size, KM_SLEEP);
        ASSERT(channel != NULL);        /* because KM_SLEEP */


        /* Look for channel endpoint child(ren) of the vdisk MD node */
        if ((num_channels = md_scan_dag(md, mdep,
            md_find_name(md, "channel-endpoint"),
            md_find_name(md, "fwd"), channel)) <= 0) {
                cmn_err(CE_CONT, "i_vcc_get_ldc_id:  No 'channel-endpoint'"
                    " found for vcc");
                kmem_free(channel, size);
                return (-1);
        }

        /* Get the "id" value for the first channel endpoint node */
        if (md_get_prop_val(md, channel[0], "id", ldc_id) != 0) {
                cmn_err(CE_CONT, "i_vcc_get_ldc:  No id property found "
                    "for channel-endpoint of vcc");
                kmem_free(channel, size);
                return (-1);
        }

        if (num_channels > 1) {
                cmn_err(CE_CONT, "i_vcc_get_ldc:  Warning:  Using ID of first"
                    " of multiple channels for this vcc");
        }

        kmem_free(channel, size);
        return (0);
}
/* mdeg callback for an added port  */
static int
i_vcc_md_add_port(md_t *mdp, mde_cookie_t mdep, vcc_t *vccp)
{
        uint64_t        portno;         /* md requires 64 bit */
        char            *domain_name;
        char            *group_name;
        uint64_t        ldc_id;
        uint64_t        tcp_port;
        vcc_port_t      *vport;

        /* read in the port's reg property */
        if (md_get_prop_val(mdp, mdep, "id", &portno)) {
                cmn_err(CE_CONT, "i_vcc_md_add_port_: port has no 'id' "
                    "property\n");
                return (MDEG_FAILURE);
        }

        /* read in the port's "vcc-doman-name" property */
        if (md_get_prop_str(mdp, mdep, "vcc-domain-name", &domain_name)) {
                cmn_err(CE_CONT, "i_vcc_md_add_port: port%ld has "
                    "no 'vcc-domain-name' property\n", portno);
                return (MDEG_FAILURE);
        }


        /* read in the port's "vcc-group-name" property */
        if (md_get_prop_str(mdp, mdep, "vcc-group-name", &group_name)) {
                cmn_err(CE_CONT, "i_vcc_md_add_port: port%ld has no "
                    "'vcc-group-name'property\n", portno);
                return (MDEG_FAILURE);
        }


        /* read in the port's "vcc-tcp-port" property */
        if (md_get_prop_val(mdp, mdep, "vcc-tcp-port", &tcp_port)) {
                cmn_err(CE_CONT, "i_vcc_md_add_port: port%ld has no"
                    "'vcc-tcp-port' property\n", portno);
                return (MDEG_FAILURE);
        }

        D1("i_vcc_md_add_port: port@%d domain-name=%s group-name=%s"
            " tcp-port=%lld\n", portno, domain_name, group_name, tcp_port);

        /* add the port */
        if (i_vcc_add_port(vccp, group_name, tcp_port, portno, domain_name)) {
                return (MDEG_FAILURE);
        }

        vport = &vccp->port[portno];
        if (i_vcc_get_ldc_id(mdp, mdep, &ldc_id)) {
                mutex_enter(&vport->lock);
                (void) i_vcc_delete_port(vccp, vport);
                mutex_exit(&vport->lock);
                return (MDEG_FAILURE);
        }

        /* configure the port */
        if (i_vcc_config_port(vccp, portno, ldc_id)) {
                mutex_enter(&vport->lock);
                (void) i_vcc_delete_port(vccp, vport);
                mutex_exit(&vport->lock);
                return (MDEG_FAILURE);
        }

        mutex_enter(&vccp->lock);
        vccp->num_ports++;
        mutex_exit(&vccp->lock);

        vport = &vccp->port[VCC_CONTROL_PORT];

        if (vport->pollflag & VCC_POLL_CONFIG) {
                /* wakeup vntsd */
                mutex_enter(&vport->lock);
                vport->pollevent |= VCC_POLL_ADD_PORT;
                mutex_exit(&vport->lock);
                pollwakeup(&vport->poll, POLLIN);
        }

        return (MDEG_SUCCESS);
}

/* mdeg callback */
static int
vcc_mdeg_cb(void *cb_argp, mdeg_result_t *resp)
{
        int     idx;
        vcc_t   *vccp;
        int     rv;

        vccp = (vcc_t *)cb_argp;
        ASSERT(vccp);

        if (resp == NULL) {
                return (MDEG_FAILURE);
        }

        /* added port */
        D1("vcc_mdeg_cb: added %d port(s)\n", resp->added.nelem);

        for (idx = 0; idx < resp->added.nelem; idx++) {
                rv = i_vcc_md_add_port(resp->added.mdp,
                    resp->added.mdep[idx], vccp);

                if (rv !=  MDEG_SUCCESS) {
                        return (rv);
                }
        }

        /* removed port */
        D1("vcc_mdeg_cb: removed %d port(s)\n", resp->removed.nelem);

        for (idx = 0; idx < resp->removed.nelem; idx++) {
                rv = i_vcc_md_remove_port(resp->removed.mdp,
                    resp->removed.mdep[idx], vccp);

                if (rv !=  MDEG_SUCCESS) {
                        return (rv);
                }

        }

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

        return (MDEG_SUCCESS);
}


/* cb_chpoll */
static int
vcc_chpoll(dev_t dev, short events, int anyyet,  short *reventsp,
    struct pollhead **phpp)
{
        int         instance;
        minor_t     minor;
        uint_t      portno;
        vcc_t       *vccp;
        vcc_port_t  *vport;

        minor = getminor(dev);

        instance = VCCINST(minor);

        vccp = ddi_get_soft_state(vcc_ssp, instance);
        if (vccp == NULL) {
                return (ENXIO);
        }

        portno = VCCPORT(vccp, minor);

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

        D1("vcc_chpoll: virtual-console-concentrator@%d events 0x%x\n",
            portno, events);

        *reventsp = 0;

        if (portno != VCC_CONTROL_PORT) {
                return (ENXIO);
        }

        /* poll for config change */
        if (vport->pollevent) {
                *reventsp |= (events & POLLIN);
        }

        if ((((*reventsp) == 0) && (!anyyet)) || (events & POLLET)) {
                *phpp = &vport->poll;
                if (events & POLLIN) {
                        mutex_enter(&vport->lock);
                        vport->pollflag |= VCC_POLL_CONFIG;
                        mutex_exit(&vport->lock);
                } else {
                        return (ENXIO);
                }
        }

        D1("vcc_chpoll: virtual-console-concentrator@%d:%d ev=0x%x, "
            "rev=0x%x pev=0x%x, flag=0x%x\n",
            instance, portno, events, (*reventsp),
            vport->pollevent, vport->pollflag);


        return (0);
}