/*
 * Exported interface to unregister a LDC endpoint with
 * the channel nexus
 */
static int
cnex_unreg_chan(dev_info_t *dip, uint64_t id)
{
	cnex_ldc_t	*cldcp, *prev_cldcp;
	cnex_soft_state_t *cnex_ssp;
	int		instance;

	/* Get device instance and structure */
	instance = ddi_get_instance(dip);
	cnex_ssp = ddi_get_soft_state(cnex_state, instance);

	/* find and remove channel from list */
	mutex_enter(&cnex_ssp->clist_lock);
	prev_cldcp = NULL;
	cldcp = cnex_ssp->clist;
	while (cldcp) {
		if (cldcp->id == id)
			break;
		prev_cldcp = cldcp;
		cldcp = cldcp->next;
	}

	if (cldcp == 0) {
		DWARN("cnex_unreg_chan: invalid channel %d\n", id);
		mutex_exit(&cnex_ssp->clist_lock);
		return (EINVAL);
	}

	if (cldcp->tx.hdlr || cldcp->rx.hdlr) {
		DWARN("cnex_unreg_chan: handlers still exist: chan %lx\n", id);
		mutex_exit(&cnex_ssp->clist_lock);
		return (ENXIO);
	}

	if (prev_cldcp)
		prev_cldcp->next = cldcp->next;
	else
		cnex_ssp->clist = cldcp->next;

	mutex_exit(&cnex_ssp->clist_lock);

	/* destroy mutex */
	mutex_destroy(&cldcp->lock);

	/* free channel */
	kmem_free(cldcp, sizeof (*cldcp));

	return (0);
}

/*
 * for client leaf drivers to register their desire for rmc_comm
 * to stay attached
 */
int
rmc_comm_register()
{
	struct rmc_comm_state *rcs;

	mutex_enter(&rmc_comm_attach_lock);
	rcs = ddi_get_soft_state(rmc_comm_statep, 0);
	if ((rcs == NULL) || (!rcs->is_attached)) {
		mutex_exit(&rmc_comm_attach_lock);
		return (DDI_FAILURE);
	}
	rcs->n_registrations++;
	mutex_exit(&rmc_comm_attach_lock);
	return (DDI_SUCCESS);
}

/* ARGSUSED */
static int
tvhci_close(dev_t dev, int flag, int otype, cred_t *credp)
{
	struct tvhci_state *vhci;
	if (otype != OTYP_CHR) {
		return (EINVAL);
	}

	vhci = ddi_get_soft_state(tvhci_state, getminor(dev));
	if (vhci == NULL) {
		return (ENXIO);
	}

	return (0);
}

int
pcieb_plat_peekpoke(dev_info_t *dip, dev_info_t *rdip, ddi_ctl_enum_t ctlop,
    void *arg, void *result)
{
	pcieb_devstate_t *pcieb = ddi_get_soft_state(pcieb_state,
	    ddi_get_instance(dip));

	if (!PCIE_IS_RP(PCIE_DIP2BUS(dip)))
		return (ddi_ctlops(dip, rdip, ctlop, arg, result));

	return (pci_peekpoke_check(dip, rdip, ctlop, arg, result,
	    ddi_ctlops, &pcieb->pcieb_err_mutex,
	    &pcieb->pcieb_peek_poke_mutex,
	    pcieb_peekpoke_cb));
}

static void
ds1287_log_message(void)
{
	struct ds1287 *softsp;

	if ((softsp = ddi_get_soft_state(ds1287_state, instance)) == NULL) {
		cmn_err(CE_WARN, "ds1287: Failed to get internal state!");
		return;
	}

	mutex_enter(&softsp->ds1287_mutex);
	softsp->shutdown_pending = 0;
	cmn_err(CE_WARN, "ds1287: Failed to shut down the system!");
	mutex_exit(&softsp->ds1287_mutex);
}

/*ARGSUSED*/
static int
tcli_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
    int *rvalp)
{
	struct dstate *dstatep;
	int instance;

	instance = MINOR_TO_INST(getminor(dev));
	dstatep = ddi_get_soft_state(dstates, instance);

	if (dstatep == NULL)
		return (ENXIO);

	return (0);
}

/*
 * xpvtap_chpoll()
 */
static int
xpvtap_chpoll(dev_t dev, short events, int anyyet, short *reventsp,
    struct pollhead **phpp)
{
	xpvtap_user_ring_t *usring;
	xpvtap_state_t *state;
	int instance;


	instance = getminor(dev);
	if (instance == -1) {
		return (EBADF);
	}
	state = ddi_get_soft_state(xpvtap_statep, instance);
	if (state == NULL) {
		return (EBADF);
	}

	if (((events & (POLLIN | POLLRDNORM)) == 0) && !anyyet) {
		return (EINVAL);
	}

	/*
	 * if we pushed requests on the user ring since the last poll, wakeup
	 * the user app
	 */
	*reventsp = 0;
	usring = &state->bt_user_ring;
	if (usring->ur_prod_polled != usring->ur_ring.req_prod_pvt) {

		/*
		 * XXX - is this faster here or xpvtap_user_request_push??
		 * prelim data says here.  Because less membars or because
		 * user thread will spin in poll requests before getting to
		 * responses?
		 */
		RING_PUSH_REQUESTS(&usring->ur_ring);

		usring->ur_prod_polled = usring->ur_ring.sring->req_prod;
		*reventsp =  POLLIN | POLLRDNORM;
	}

	if ((*reventsp == 0 && !anyyet) || (events & POLLET)) {
		*phpp = &state->bt_pollhead;
	}

	return (0);
}

/*
 * heci_attach - Driver Attach Routine
 */
static int
heci_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	int instance, status;
	struct iamt_heci_device *device;

	switch (cmd) {
	case DDI_ATTACH:
		break;
	case DDI_RESUME:
		heci_resume(dip);
		return (DDI_SUCCESS);
	default:
		return (DDI_FAILURE);
	}

	DBG("%s - version %s\n", heci_driver_string, heci_driver_version);
	DBG("%s\n", heci_copyright);

	instance = ddi_get_instance(dip);	/* find out which unit */
	status = ddi_soft_state_zalloc(heci_soft_state_p, instance);
	if (status != DDI_SUCCESS)
		return (DDI_FAILURE);
	device = ddi_get_soft_state(heci_soft_state_p, instance);
	ASSERT(device != NULL);	/* can't fail - we only just allocated it */

	device->dip = dip;

	status = heci_initialize(dip, device);
	if (status != DDI_SUCCESS) {
		ddi_soft_state_free(heci_soft_state_p, instance);
		return (DDI_FAILURE);
	}

	status = ddi_create_minor_node(dip, "AMT", S_IFCHR,
	    MAKE_MINOR_NUM(HECI_MINOR_NUMBER, instance),
	    DDI_PSEUDO, 0);

	if (status != DDI_SUCCESS) {

		ddi_remove_minor_node(dip, NULL);
		ddi_soft_state_free(heci_soft_state_p, instance);
		return (DDI_FAILURE);
	}


	return (status);
}

static int
agp_target_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	agp_target_softstate_t *softstate;
	int instance;
	int status;

	if (cmd != DDI_ATTACH)
		return (DDI_FAILURE);

	instance = ddi_get_instance(dip);

	if (ddi_soft_state_zalloc(agptarget_glob_soft_handle, instance) !=
	    DDI_SUCCESS)
		return (DDI_FAILURE);

	softstate = ddi_get_soft_state(agptarget_glob_soft_handle, instance);
	mutex_init(&softstate->tsoft_lock, NULL, MUTEX_DRIVER, NULL);
	softstate->tsoft_dip = dip;
	status = pci_config_setup(dip, &softstate->tsoft_pcihdl);
	if (status != DDI_SUCCESS) {
		ddi_soft_state_free(agptarget_glob_soft_handle, instance);
		return (DDI_FAILURE);
	}

	softstate->tsoft_devid = pci_config_get32(softstate->tsoft_pcihdl,
	    PCI_CONF_VENID);
	softstate->tsoft_acaptr = agp_target_cap_find(softstate->tsoft_pcihdl);
	if (softstate->tsoft_acaptr == 0) {
		/* Make a correction for some Intel chipsets */
		if ((softstate->tsoft_devid & VENDOR_ID_MASK) ==
		    INTEL_VENDOR_ID)
			softstate->tsoft_acaptr = AGP_CAP_OFF_DEF;
		else
			return (DDI_FAILURE);
	}

	status = ddi_create_minor_node(dip, AGPTARGET_NAME, S_IFCHR,
	    INST2NODENUM(instance), DDI_NT_AGP_TARGET, 0);

	if (status != DDI_SUCCESS) {
		pci_config_teardown(&softstate->tsoft_pcihdl);
		ddi_soft_state_free(agptarget_glob_soft_handle, instance);
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

/* ARGSUSED */
static int
tphci_open(dev_t *devp, int flag, int otype, cred_t *credp)
{
	struct tphci_state *phci;

	if (otype != OTYP_CHR) {
		return (EINVAL);
	}

	phci = ddi_get_soft_state(tphci_state, getminor(*devp));
	if (phci == NULL) {
		return (ENXIO);
	}

	return (0);
}

/*
 * Report an address to per-address report
 *
 * damapp:	address map handle
 * address:	address in ascii string representation
 * addridp:	address ID
 * nvl:		optional nvlist of configuration-private data
 * addr_priv:	optional provider-private (passed to activate/deactivate cb)
 *
 * Returns:	DAM_SUCCESS
 *		DAM_EINVAL	Invalid argument(s)
 *		DAM_MAPFULL	address map exhausted
 */
int
damap_addr_add(damap_t *damapp, char *address, damap_id_t *addridp,
    nvlist_t *nvl, void *addr_priv)
{
	dam_t *mapp = (dam_t *)damapp;
	id_t addrid;
	dam_da_t *passp;

	if (!mapp || !address || (mapp->dam_rptmode != DAMAP_REPORT_PERADDR))
		return (DAM_EINVAL);

	DTRACE_PROBE3(damap__addr__add,
	    char *, mapp->dam_name, dam_t *, mapp,
	    char *, address);

	mutex_enter(&mapp->dam_lock);
	if ((dam_map_alloc(mapp) != DAM_SUCCESS) ||
	    ((addrid = dam_get_addrid(mapp, address)) == 0)) {
		mutex_exit(&mapp->dam_lock);
		return (DAM_MAPFULL);
	}

	passp = ddi_get_soft_state(mapp->dam_da, addrid);
	ASSERT(passp != NULL);

	/*
	 * If re-reporting the same address (add or remove) clear
	 * the existing report
	 */
	if (DAM_IN_REPORT(mapp, addrid)) {
		DTRACE_PROBE3(damap__addr__add__jitter,
		    char *, mapp->dam_name, dam_t *, mapp,
		    char *, address);
		DAM_INCR_STAT(mapp, dam_jitter);
		dam_addr_report_release(mapp, addrid);
		passp->da_jitter++;
	}
	passp->da_ppriv_rpt = addr_priv;
	if (nvl)
		(void) nvlist_dup(nvl, &passp->da_nvl_rpt, KM_SLEEP);

	dam_addr_report(mapp, passp, addrid, RPT_ADDR_ADD);
	if (addridp != NULL)
		*addridp = (damap_id_t)addrid;
	mutex_exit(&mapp->dam_lock);
	return (DAM_SUCCESS);
}

static int
ppb_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int flags,
    char *name, caddr_t valuep, int *lengthp)
{
	int		instance = PCI_MINOR_NUM_TO_INSTANCE(getminor(dev));
	ppb_devstate_t	*ppb_p = ddi_get_soft_state(ppb_state, instance);

	if (ppb_p == NULL)
		return (ENXIO);

	if (ppb_p->parent_bus == PCIE_PCIECAP_DEV_TYPE_PCIE_DEV)
		return (pcie_prop_op(dev, dip, prop_op, flags, name,
		    valuep, lengthp));

	return ((pcihp_get_cb_ops())->cb_prop_op(dev, dip, prop_op, flags,
	    name, valuep, lengthp));
}

static int VBoxUSBMonSolarisClose(dev_t Dev, int fFlag, int fType, cred_t *pCred)
{
    vboxusbmon_state_t *pState = NULL;

    LogFunc((DEVICE_NAME ":VBoxUSBMonSolarisClose\n"));

    pState = ddi_get_soft_state(g_pVBoxUSBMonSolarisState, getminor(Dev));
    if (!pState)
    {
        LogRel((DEVICE_NAME ":VBoxUSBMonSolarisClose: failed to get pState.\n"));
        return EFAULT;
    }

    mutex_enter(&g_VBoxUSBMonSolarisMtx);
    g_cVBoxUSBMonSolarisClient--;
    if (!g_cVBoxUSBMonSolarisClient)
    {
        if (RT_LIKELY(g_pDip))
        {
            mutex_exit(&g_VBoxUSBMonSolarisMtx);
            usb_unregister_dev_driver(g_pDip);
            Log((DEVICE_NAME ":Successfully deregistered driver election callback\n"));
        }
        else
        {
            mutex_exit(&g_VBoxUSBMonSolarisMtx);
            LogRel((DEVICE_NAME ":Extreme error! Missing device info during close.\n"));
        }
    }
    else
        mutex_exit(&g_VBoxUSBMonSolarisMtx);

    /*
     * Remove all filters for this client process.
     */
    VBoxUSBFilterRemoveOwner(pState->Process);

    ddi_soft_state_free(g_pVBoxUSBMonSolarisState, getminor(Dev));
    pState = NULL;

    NOREF(fFlag);
    NOREF(fType);
    NOREF(pCred);

    return 0;
}

/*
 * Helper used by smbfs_mount
 */
int
smb_dev2share(int fd, struct smb_share **sspp)
{
	file_t *fp = NULL;
	vnode_t *vp;
	smb_dev_t *sdp;
	smb_share_t *ssp;
	dev_t dev;
	int err;

	if ((fp = getf(fd)) == NULL)
		return (EBADF);
	/* rele fp below */

	vp = fp->f_vnode;
	dev = vp->v_rdev;
	if (dev == 0 || dev == NODEV ||
	    getmajor(dev) != nsmb_major) {
		err = EINVAL;
		goto out;
	}

	sdp = ddi_get_soft_state(statep, getminor(dev));
	if (sdp == NULL) {
		err = EINVAL;
		goto out;
	}

	ssp = sdp->sd_share;
	if (ssp == NULL) {
		err = ENOTCONN;
		goto out;
	}

	/*
	 * Our caller gains a ref. to this share.
	 */
	*sspp = ssp;
	smb_share_hold(ssp);
	err = 0;

out:
	if (fp)
		releasef(fd);
	return (err);
}

/*ARGSUSED*/
static int
xpvtap_close(dev_t devp, int flag, int otyp, cred_t *cred)
{
	xpvtap_state_t *state;
	int instance;


	instance = getminor(devp);
	state = ddi_get_soft_state(xpvtap_statep, instance);
	if (state == NULL) {
		return (ENXIO);
	}

	/*
	 * wake thread so it can cleanup and wait for it to exit so we can
	 * be sure it's not in the middle of processing a request/response.
	 */
	mutex_enter(&state->bt_thread.ut_mutex);
	state->bt_thread.ut_wake = B_TRUE;
	state->bt_thread.ut_exit = B_TRUE;
	cv_signal(&state->bt_thread.ut_wake_cv);
	if (!state->bt_thread.ut_exit_done) {
		cv_wait(&state->bt_thread.ut_exit_done_cv,
		    &state->bt_thread.ut_mutex);
	}
	ASSERT(state->bt_thread.ut_exit_done);
	mutex_exit(&state->bt_thread.ut_mutex);

	state->bt_map.um_as = NULL;
	state->bt_map.um_guest_pages = NULL;

	/*
	 * when the ring is brought down, a userland hotplug script is run
	 * which tries to bring the userland app down. We'll wait for a bit
	 * for the user app to exit. Notify the thread waiting that the app
	 * has closed the driver.
	 */
	mutex_enter(&state->bt_open.bo_mutex);
	ASSERT(state->bt_open.bo_opened);
	state->bt_open.bo_opened = B_FALSE;
	cv_signal(&state->bt_open.bo_exit_cv);
	mutex_exit(&state->bt_open.bo_mutex);

	return (0);
}

static int
ics951601_open(dev_t *devp, int flags, int otyp, cred_t *credp)
{
	int			instance;
	ics951601_unit_t	*icsp;
	int			err = EBUSY;

	/*
	 * Make sure the open is for the right file type
	 */
	if (otyp != OTYP_CHR) {
		return (EINVAL);
	}

	instance = getminor(*devp);
	if (instance < 0) {
		return (ENXIO);
	}
	icsp = (ics951601_unit_t *)ddi_get_soft_state(ics951601_soft_statep,
	    instance);
	if (icsp == NULL) {
		return (ENXIO);
	}

	/* must be privileged to access this device */
	if (drv_priv(credp) != 0) {
		return (EPERM);
	}

	/*
	 * Enforce exclusive access if required
	 */
	mutex_enter(&icsp->ics951601_mutex);
	if (flags & FEXCL) {
		if (icsp->ics951601_oflag == 0) {
			icsp->ics951601_oflag = FEXCL;
			err = DDI_SUCCESS;
		}
	} else if (icsp->ics951601_oflag != FEXCL) {
		icsp->ics951601_oflag = (uint16_t)FOPEN;
		err = DDI_SUCCESS;
	}
	mutex_exit(&icsp->ics951601_mutex);
	return (err);
}

static int
nsmb_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	smb_dev_t *sdp;

	if (cmd != DDI_ATTACH)
		return (DDI_FAILURE);
	/*
	 * only one instance - but we clone using the open routine
	 */
	if (ddi_get_instance(dip) > 0)
		return (DDI_FAILURE);

	mutex_enter(&dev_lck);

	/*
	 * This is the Zero'th minor device which is created.
	 */
	if (ddi_soft_state_zalloc(statep, 0) == DDI_FAILURE) {
		cmn_err(CE_WARN, "nsmb_attach: soft state alloc");
		goto attach_failed;
	}
	if (ddi_create_minor_node(dip, "nsmb", S_IFCHR, 0, DDI_PSEUDO,
	    NULL) == DDI_FAILURE) {
		cmn_err(CE_WARN, "nsmb_attach: create minor");
		goto attach_failed;
	}
	if ((sdp = ddi_get_soft_state(statep, 0)) == NULL) {
		cmn_err(CE_WARN, "nsmb_attach: get soft state");
		ddi_remove_minor_node(dip, NULL);
		goto attach_failed;
	}

	sdp->sd_dip = dip;
	sdp->sd_seq = 0;
	sdp->sd_smbfid = -1;
	mutex_exit(&dev_lck);
	ddi_report_dev(dip);
	return (DDI_SUCCESS);

attach_failed:
	ddi_soft_state_free(statep, 0);
	mutex_exit(&dev_lck);
	return (DDI_FAILURE);
}

/*ARGSUSED*/
static int
zc_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
	zc_state_t *zcs;
	int instance = ZC_INSTANCE((dev_t)arg);

	switch (infocmd) {
	case DDI_INFO_DEVT2DEVINFO:
		if ((zcs = ddi_get_soft_state(zc_soft_state, instance)) == NULL)
			return (DDI_FAILURE);
		*result = zcs->zc_devinfo;
		return (DDI_SUCCESS);
	case DDI_INFO_DEVT2INSTANCE:
		*result = (void *)(uintptr_t)instance;
		return (DDI_SUCCESS);
	}
	return (DDI_FAILURE);
}

/*ARGSUSED*/
static int
tcli_close(dev_t dev, int flag, int otyp, cred_t *cred)
{
	struct dstate *dstatep;
	minor_t minor = getminor(dev);

	if (otyp != OTYP_BLK && otyp != OTYP_CHR)
		return (EINVAL);

	dstatep = ddi_get_soft_state(dstates, MINOR_TO_INST(minor));

	if (dstatep == NULL)
		return (ENXIO);

	dstatep->oflag = 0;

	return (0);
}

/*ARGSUSED*/
static int
tcli_open(dev_t *devp, int flag, int otyp, cred_t *cred)
{
	minor_t minor;
	struct dstate *dstatep;

	if (otyp != OTYP_BLK && otyp != OTYP_CHR)
		return (EINVAL);

	minor = getminor(*devp);
	if ((dstatep = ddi_get_soft_state(dstates,
	    MINOR_TO_INST(minor))) == NULL)
		return (ENXIO);

	dstatep->oflag = 1;

	return (0);
}