path: root/usr/src/uts/intel/io/vmxnet3s/vmxnet3_main.c

/*
 * Copyright (C) 2007-2014 VMware, Inc. All rights reserved.
 *
 * The contents of this file are subject to the terms of the Common
 * Development and Distribution License (the "License") version 1.0
 * and no later version.  You may not use this file except in
 * compliance with the License.
 *
 * You can obtain a copy of the License at
 *         http://www.opensource.org/licenses/cddl1.php
 *
 * See the License for the specific language governing permissions
 * and limitations under the License.
 */

/*
 * Copyright (c) 2012, 2016 by Delphix. All rights reserved.
 */

#include <vmxnet3.h>

/*
 * This driver is based on VMware's version 3227872, and contains additional
 * enhancements (see README.txt).
 */
#define	BUILD_NUMBER_NUMERIC	3227872

/*
 * If we run out of rxPool buffers, only allocate if the MTU is <= PAGESIZE
 * so that we don't have to incur the cost of allocating multiple contiguous
 * pages (very slow) in interrupt context.
 */
#define	VMXNET3_ALLOC_OK(dp)	((dp)->cur_mtu <= PAGESIZE)

/*
 * TODO:
 *    - Tx data ring
 *    - MAC_CAPAB_POLL support
 *    - Dynamic RX pool
 */

static int vmxnet3_getstat(void *, uint_t, uint64_t *);
static int vmxnet3_start(void *);
static void vmxnet3_stop(void *);
static int vmxnet3_setpromisc(void *, boolean_t);
static void vmxnet3_ioctl(void *arg, queue_t *wq, mblk_t *mp);
static int vmxnet3_multicst(void *, boolean_t, const uint8_t *);
static int vmxnet3_unicst(void *, const uint8_t *);
static boolean_t vmxnet3_getcapab(void *, mac_capab_t, void *);
static int vmxnet3_get_prop(void *, const char *, mac_prop_id_t, uint_t,
    void *);
static int vmxnet3_set_prop(void *, const char *, mac_prop_id_t, uint_t,
    const void *);
static void vmxnet3_prop_info(void *, const char *, mac_prop_id_t,
    mac_prop_info_handle_t);

int vmxnet3s_debug = 0;

/* MAC callbacks */
static mac_callbacks_t vmxnet3_mac_callbacks = {
	.mc_callbacks =	MC_GETCAPAB | MC_IOCTL | MC_SETPROP | MC_PROPINFO,
	.mc_getstat =	vmxnet3_getstat,
	.mc_start =	vmxnet3_start,
	.mc_stop =	vmxnet3_stop,
	.mc_setpromisc = vmxnet3_setpromisc,
	.mc_multicst =	vmxnet3_multicst,
	.mc_unicst =	vmxnet3_unicst,
	.mc_tx =	vmxnet3_tx,
	.mc_ioctl =	vmxnet3_ioctl,
	.mc_getcapab =	vmxnet3_getcapab,
	.mc_getprop =	vmxnet3_get_prop,
	.mc_setprop =	vmxnet3_set_prop,
	.mc_propinfo =	vmxnet3_prop_info
};

/* Tx DMA engine description */
static ddi_dma_attr_t vmxnet3_dma_attrs_tx = {
	.dma_attr_version =	DMA_ATTR_V0,
	.dma_attr_addr_lo =	0x0000000000000000ull,
	.dma_attr_addr_hi =	0xFFFFFFFFFFFFFFFFull,
	.dma_attr_count_max =	0xFFFFFFFFFFFFFFFFull,
	.dma_attr_align =	0x0000000000000001ull,
	.dma_attr_burstsizes =	0x0000000000000001ull,
	.dma_attr_minxfer =	0x00000001,
	.dma_attr_maxxfer =	0x000000000000FFFFull,
	.dma_attr_seg =		0xFFFFFFFFFFFFFFFFull,
	.dma_attr_sgllen =	-1,
	.dma_attr_granular =	0x00000001,
	.dma_attr_flags =	0
};

/* --- */

/*
 * Fetch the statistics of a vmxnet3 device.
 *
 * Returns:
 *	0 on success, non-zero on failure.
 */
static int
vmxnet3_getstat(void *data, uint_t stat, uint64_t *val)
{
	vmxnet3_softc_t *dp = data;
	UPT1_TxStats *txStats;
	UPT1_RxStats *rxStats;

	VMXNET3_DEBUG(dp, 3, "getstat(%u)\n", stat);

	if (!dp->devEnabled) {
		return (EBUSY);
	}

	txStats = &VMXNET3_TQDESC(dp)->stats;
	rxStats = &VMXNET3_RQDESC(dp)->stats;

	/*
	 * First touch the related register
	 */
	switch (stat) {
	case MAC_STAT_MULTIRCV:
	case MAC_STAT_BRDCSTRCV:
	case MAC_STAT_MULTIXMT:
	case MAC_STAT_BRDCSTXMT:
	case MAC_STAT_NORCVBUF:
	case MAC_STAT_IERRORS:
	case MAC_STAT_NOXMTBUF:
	case MAC_STAT_OERRORS:
	case MAC_STAT_RBYTES:
	case MAC_STAT_IPACKETS:
	case MAC_STAT_OBYTES:
	case MAC_STAT_OPACKETS:
		VMXNET3_BAR1_PUT32(dp, VMXNET3_REG_CMD, VMXNET3_CMD_GET_STATS);
		break;
	case MAC_STAT_IFSPEED:
	case MAC_STAT_COLLISIONS:
	case ETHER_STAT_LINK_DUPLEX:
		/* nothing */
		break;
	default:
		return (ENOTSUP);
	}

	/*
	 * Then fetch the corresponding stat
	 */
	switch (stat) {
	case MAC_STAT_IFSPEED:
		*val = dp->linkSpeed;
		break;
	case MAC_STAT_MULTIRCV:
		*val = rxStats->mcastPktsRxOK;
		break;
	case MAC_STAT_BRDCSTRCV:
		*val = rxStats->bcastPktsRxOK;
		break;
	case MAC_STAT_MULTIXMT:
		*val = txStats->mcastPktsTxOK;
		break;
	case MAC_STAT_BRDCSTXMT:
		*val = txStats->bcastPktsTxOK;
		break;
	case MAC_STAT_NORCVBUF:
		*val = rxStats->pktsRxOutOfBuf + dp->rx_alloc_failed;
		break;
	case MAC_STAT_IERRORS:
		*val = rxStats->pktsRxError;
		break;
	case MAC_STAT_NOXMTBUF:
		*val = txStats->pktsTxDiscard + dp->tx_pullup_failed;
		break;
	case MAC_STAT_OERRORS:
		*val = txStats->pktsTxError + dp->tx_error;
		break;
	case MAC_STAT_COLLISIONS:
		*val = 0;
		break;
	case MAC_STAT_RBYTES:
		*val = rxStats->ucastBytesRxOK + rxStats->mcastBytesRxOK +
		    rxStats->bcastBytesRxOK;
		break;
	case MAC_STAT_IPACKETS:
		*val = rxStats->ucastPktsRxOK + rxStats->mcastPktsRxOK +
		    rxStats->bcastPktsRxOK;
		break;
	case MAC_STAT_OBYTES:
		*val = txStats->ucastBytesTxOK + txStats->mcastBytesTxOK +
		    txStats->bcastBytesTxOK;
		break;
	case MAC_STAT_OPACKETS:
		*val = txStats->ucastPktsTxOK + txStats->mcastPktsTxOK +
		    txStats->bcastPktsTxOK;
		break;
	case ETHER_STAT_LINK_DUPLEX:
		*val = LINK_DUPLEX_FULL;
		break;
	default:
		ASSERT(B_FALSE);
	}

	return (0);
}

/*
 * Allocate and initialize the shared data structures of a vmxnet3 device.
 *
 * Returns:
 *	0 on sucess, non-zero on failure.
 */
static int
vmxnet3_prepare_drivershared(vmxnet3_softc_t *dp)
{
	Vmxnet3_DriverShared *ds;
	size_t allocSize = sizeof (Vmxnet3_DriverShared);
	int err;

	if ((err = vmxnet3_alloc_dma_mem_1(dp, &dp->sharedData, allocSize,
	    B_TRUE)) != 0) {
		return (err);
	}
	ds = VMXNET3_DS(dp);
	(void) memset(ds, 0, allocSize);

	allocSize = sizeof (Vmxnet3_TxQueueDesc) + sizeof (Vmxnet3_RxQueueDesc);
	if ((err = vmxnet3_alloc_dma_mem_128(dp, &dp->queueDescs, allocSize,
	    B_TRUE)) != 0) {
		vmxnet3_free_dma_mem(&dp->sharedData);
		return (err);
	}
	(void) memset(dp->queueDescs.buf, 0, allocSize);

	ds->magic = VMXNET3_REV1_MAGIC;

	/* Take care of most of devRead */
	ds->devRead.misc.driverInfo.version = BUILD_NUMBER_NUMERIC;
#ifdef _LP64
	ds->devRead.misc.driverInfo.gos.gosBits = VMXNET3_GOS_BITS_64;
#else
	ds->devRead.misc.driverInfo.gos.gosBits = VMXNET3_GOS_BITS_32;
#endif
	ds->devRead.misc.driverInfo.gos.gosType = VMXNET3_GOS_TYPE_SOLARIS;
	ds->devRead.misc.driverInfo.gos.gosVer = 10;
	ds->devRead.misc.driverInfo.vmxnet3RevSpt = 1;
	ds->devRead.misc.driverInfo.uptVerSpt = 1;

	ds->devRead.misc.uptFeatures = UPT1_F_RXCSUM;
	ds->devRead.misc.mtu = dp->cur_mtu;

	/* XXX: ds->devRead.misc.maxNumRxSG */
	ds->devRead.misc.numTxQueues = 1;
	ds->devRead.misc.numRxQueues = 1;
	ds->devRead.misc.queueDescPA = dp->queueDescs.bufPA;
	ds->devRead.misc.queueDescLen = allocSize;

	/* TxQueue and RxQueue information is filled in other functions */
	ds->devRead.intrConf.autoMask = (dp->intrMaskMode == VMXNET3_IMM_AUTO);
	ds->devRead.intrConf.numIntrs = 1;
	/* XXX: ds->intr.modLevels */
	ds->devRead.intrConf.eventIntrIdx = 0;

	VMXNET3_BAR1_PUT32(dp, VMXNET3_REG_DSAL,
	    VMXNET3_ADDR_LO(dp->sharedData.bufPA));
	VMXNET3_BAR1_PUT32(dp, VMXNET3_REG_DSAH,
	    VMXNET3_ADDR_HI(dp->sharedData.bufPA));

	return (0);
}

/*
 * Destroy the shared data structures of a vmxnet3 device.
 */
static void
vmxnet3_destroy_drivershared(vmxnet3_softc_t *dp)
{
	VMXNET3_BAR1_PUT32(dp, VMXNET3_REG_DSAL, 0);
	VMXNET3_BAR1_PUT32(dp, VMXNET3_REG_DSAH, 0);

	vmxnet3_free_dma_mem(&dp->queueDescs);
	vmxnet3_free_dma_mem(&dp->sharedData);
}

/*
 * Allocate and initialize the command ring of a queue.
 *
 * Returns:
 *	0 on success, non-zero on error.
 */
static int
vmxnet3_alloc_cmdring(vmxnet3_softc_t *dp, vmxnet3_cmdring_t *cmdRing)
{
	size_t ringSize = cmdRing->size * sizeof (Vmxnet3_TxDesc);
	int err;

	if ((err = vmxnet3_alloc_dma_mem_512(dp, &cmdRing->dma, ringSize,
	    B_TRUE)) != 0) {
		return (err);
	}
	(void) memset(cmdRing->dma.buf, 0, ringSize);
	cmdRing->avail = cmdRing->size;
	cmdRing->next2fill = 0;
	cmdRing->gen = VMXNET3_INIT_GEN;

	return (0);
}

/*
 * Allocate and initialize the completion ring of a queue.
 *
 * Returns:
 *    DDI_SUCCESS or DDI_FAILURE.
 */
static int
vmxnet3_alloc_compring(vmxnet3_softc_t *dp, vmxnet3_compring_t *compRing)
{
	size_t ringSize = compRing->size * sizeof (Vmxnet3_TxCompDesc);

	if (vmxnet3_alloc_dma_mem_512(dp, &compRing->dma, ringSize,
	    B_TRUE) != DDI_SUCCESS) {
		return (DDI_FAILURE);
	}
	(void) memset(compRing->dma.buf, 0, ringSize);
	compRing->next2comp = 0;
	compRing->gen = VMXNET3_INIT_GEN;

	return (DDI_SUCCESS);
}

/*
 * Initialize the tx queue of a vmxnet3 device.
 *
 * Returns:
 *	0 on success, non-zero on failure.
 */
static int
vmxnet3_prepare_txqueue(vmxnet3_softc_t *dp)
{
	Vmxnet3_TxQueueDesc *tqdesc = VMXNET3_TQDESC(dp);
	vmxnet3_txqueue_t *txq = &dp->txQueue;
	int err;

	ASSERT(!(txq->cmdRing.size & VMXNET3_RING_SIZE_MASK));
	ASSERT(!(txq->compRing.size & VMXNET3_RING_SIZE_MASK));
	ASSERT(!txq->cmdRing.dma.buf && !txq->compRing.dma.buf);

	if ((err = vmxnet3_alloc_cmdring(dp, &txq->cmdRing)) != 0) {
		goto error;
	}
	tqdesc->conf.txRingBasePA = txq->cmdRing.dma.bufPA;
	tqdesc->conf.txRingSize = txq->cmdRing.size;
	tqdesc->conf.dataRingBasePA = 0;
	tqdesc->conf.dataRingSize = 0;

	if ((err = vmxnet3_alloc_compring(dp, &txq->compRing)) != 0) {
		goto error_cmdring;
	}
	tqdesc->conf.compRingBasePA = txq->compRing.dma.bufPA;
	tqdesc->conf.compRingSize = txq->compRing.size;

	txq->metaRing = kmem_zalloc(txq->cmdRing.size *
	    sizeof (vmxnet3_metatx_t), KM_SLEEP);
	ASSERT(txq->metaRing);

	if ((err = vmxnet3_txqueue_init(dp, txq)) != 0) {
		goto error_mpring;
	}

	return (0);

error_mpring:
	kmem_free(txq->metaRing, txq->cmdRing.size * sizeof (vmxnet3_metatx_t));
	vmxnet3_free_dma_mem(&txq->compRing.dma);
error_cmdring:
	vmxnet3_free_dma_mem(&txq->cmdRing.dma);
error:
	return (err);
}

/*
 * Initialize the rx queue of a vmxnet3 device.
 *
 * Returns:
 *	0 on success, non-zero on failure.
 */
static int
vmxnet3_prepare_rxqueue(vmxnet3_softc_t *dp)
{
	Vmxnet3_RxQueueDesc *rqdesc = VMXNET3_RQDESC(dp);
	vmxnet3_rxqueue_t *rxq = &dp->rxQueue;
	int err = 0;

	ASSERT(!(rxq->cmdRing.size & VMXNET3_RING_SIZE_MASK));
	ASSERT(!(rxq->compRing.size & VMXNET3_RING_SIZE_MASK));
	ASSERT(!rxq->cmdRing.dma.buf && !rxq->compRing.dma.buf);

	if ((err = vmxnet3_alloc_cmdring(dp, &rxq->cmdRing)) != 0) {
		goto error;
	}
	rqdesc->conf.rxRingBasePA[0] = rxq->cmdRing.dma.bufPA;
	rqdesc->conf.rxRingSize[0] = rxq->cmdRing.size;
	rqdesc->conf.rxRingBasePA[1] = 0;
	rqdesc->conf.rxRingSize[1] = 0;

	if ((err = vmxnet3_alloc_compring(dp, &rxq->compRing)) != 0) {
		goto error_cmdring;
	}
	rqdesc->conf.compRingBasePA = rxq->compRing.dma.bufPA;
	rqdesc->conf.compRingSize = rxq->compRing.size;

	rxq->bufRing = kmem_zalloc(rxq->cmdRing.size *
	    sizeof (vmxnet3_bufdesc_t), KM_SLEEP);
	ASSERT(rxq->bufRing);

	if ((err = vmxnet3_rxqueue_init(dp, rxq)) != 0) {
		goto error_bufring;
	}

	return (0);

error_bufring:
	kmem_free(rxq->bufRing, rxq->cmdRing.size * sizeof (vmxnet3_bufdesc_t));
	vmxnet3_free_dma_mem(&rxq->compRing.dma);
error_cmdring:
	vmxnet3_free_dma_mem(&rxq->cmdRing.dma);
error:
	return (err);
}

/*
 * Destroy the tx queue of a vmxnet3 device.
 */
static void
vmxnet3_destroy_txqueue(vmxnet3_softc_t *dp)
{
	vmxnet3_txqueue_t *txq = &dp->txQueue;

	ASSERT(txq->metaRing);
	ASSERT(txq->cmdRing.dma.buf && txq->compRing.dma.buf);

	vmxnet3_txqueue_fini(dp, txq);

	kmem_free(txq->metaRing, txq->cmdRing.size * sizeof (vmxnet3_metatx_t));

	vmxnet3_free_dma_mem(&txq->cmdRing.dma);
	vmxnet3_free_dma_mem(&txq->compRing.dma);
}

/*
 * Destroy the rx queue of a vmxnet3 device.
 */
static void
vmxnet3_destroy_rxqueue(vmxnet3_softc_t *dp)
{
	vmxnet3_rxqueue_t *rxq = &dp->rxQueue;

	ASSERT(rxq->bufRing);
	ASSERT(rxq->cmdRing.dma.buf && rxq->compRing.dma.buf);

	vmxnet3_rxqueue_fini(dp, rxq);

	kmem_free(rxq->bufRing, rxq->cmdRing.size * sizeof (vmxnet3_bufdesc_t));

	vmxnet3_free_dma_mem(&rxq->cmdRing.dma);
	vmxnet3_free_dma_mem(&rxq->compRing.dma);
}

/*
 * Apply new RX filters settings to a vmxnet3 device.
 */
static void
vmxnet3_refresh_rxfilter(vmxnet3_softc_t *dp)
{
	Vmxnet3_DriverShared *ds = VMXNET3_DS(dp);

	ds->devRead.rxFilterConf.rxMode = dp->rxMode;
	VMXNET3_BAR1_PUT32(dp, VMXNET3_REG_CMD, VMXNET3_CMD_UPDATE_RX_MODE);
}

/*
 * Fetch the link state of a vmxnet3 device.
 */
static void
vmxnet3_refresh_linkstate(vmxnet3_softc_t *dp)
{
	uint32_t ret32;

	VMXNET3_BAR1_PUT32(dp, VMXNET3_REG_CMD, VMXNET3_CMD_GET_LINK);
	ret32 = VMXNET3_BAR1_GET32(dp, VMXNET3_REG_CMD);
	if (ret32 & 1) {
		dp->linkState = LINK_STATE_UP;
		dp->linkSpeed = (ret32 >> 16) * 1000000ULL;
	} else {
		dp->linkState = LINK_STATE_DOWN;
		dp->linkSpeed = 0;
	}
}

/*
 * Start a vmxnet3 device: allocate and initialize the shared data
 * structures and send a start command to the device.
 *
 * Returns:
 *	0 on success, non-zero error on failure.
 */
static int
vmxnet3_start(void *data)
{
	vmxnet3_softc_t *dp = data;
	Vmxnet3_TxQueueDesc *tqdesc;
	Vmxnet3_RxQueueDesc *rqdesc;
	int txQueueSize, rxQueueSize;
	uint32_t ret32;
	int err, dmaerr;

	VMXNET3_DEBUG(dp, 1, "start()\n");

	/*
	 * Allocate vmxnet3's shared data and advertise its PA
	 */
	if ((err = vmxnet3_prepare_drivershared(dp)) != 0) {
		VMXNET3_WARN(dp, "vmxnet3_prepare_drivershared() failed: %d",
		    err);
		goto error;
	}
	tqdesc = VMXNET3_TQDESC(dp);
	rqdesc = VMXNET3_RQDESC(dp);

	/*
	 * Create and initialize the tx queue
	 */
	txQueueSize = vmxnet3_getprop(dp, "TxRingSize", 32, 4096,
	    VMXNET3_DEF_TX_RING_SIZE);
	if (!(txQueueSize & VMXNET3_RING_SIZE_MASK)) {
		dp->txQueue.cmdRing.size = txQueueSize;
		dp->txQueue.compRing.size = txQueueSize;
		dp->txQueue.sharedCtrl = &tqdesc->ctrl;
		if ((err = vmxnet3_prepare_txqueue(dp)) != 0) {
			VMXNET3_WARN(dp, "vmxnet3_prepare_txqueue() failed: %d",
			    err);
			goto error_shared_data;
		}
	} else {
		VMXNET3_WARN(dp, "invalid tx ring size (%d)\n", txQueueSize);
		err = EINVAL;
		goto error_shared_data;
	}

	/*
	 * Create and initialize the rx queue
	 */
	rxQueueSize = vmxnet3_getprop(dp, "RxRingSize", 32, 4096,
	    VMXNET3_DEF_RX_RING_SIZE);
	if (!(rxQueueSize & VMXNET3_RING_SIZE_MASK)) {
		dp->rxQueue.cmdRing.size = rxQueueSize;
		dp->rxQueue.compRing.size = rxQueueSize;
		dp->rxQueue.sharedCtrl = &rqdesc->ctrl;
		if ((err = vmxnet3_prepare_rxqueue(dp)) != 0) {
			VMXNET3_WARN(dp, "vmxnet3_prepare_rxqueue() failed: %d",
			    err);
			goto error_tx_queue;
		}
	} else {
		VMXNET3_WARN(dp, "invalid rx ring size (%d)\n", rxQueueSize);
		err = EINVAL;
		goto error_tx_queue;
	}

	/*
	 * Allocate the Tx DMA handle
	 */
	if ((dmaerr = ddi_dma_alloc_handle(dp->dip, &vmxnet3_dma_attrs_tx,
	    DDI_DMA_SLEEP, NULL, &dp->txDmaHandle)) != DDI_SUCCESS) {
		VMXNET3_WARN(dp, "ddi_dma_alloc_handle() failed: %d", dmaerr);
		err = vmxnet3_dmaerr2errno(dmaerr);
		goto error_rx_queue;
	}

	/*
	 * Activate the device
	 */
	VMXNET3_BAR1_PUT32(dp, VMXNET3_REG_CMD, VMXNET3_CMD_ACTIVATE_DEV);
	ret32 = VMXNET3_BAR1_GET32(dp, VMXNET3_REG_CMD);
	if (ret32) {
		VMXNET3_WARN(dp, "ACTIVATE_DEV failed: 0x%x\n", ret32);
		err = ENXIO;
		goto error_txhandle;
	}
	dp->devEnabled = B_TRUE;

	VMXNET3_BAR0_PUT32(dp, VMXNET3_REG_RXPROD,
	    dp->txQueue.cmdRing.size - 1);

	/*
	 * Update the RX filters, must be done after ACTIVATE_DEV
	 */
	dp->rxMode = VMXNET3_RXM_UCAST | VMXNET3_RXM_BCAST;
	vmxnet3_refresh_rxfilter(dp);

	/*
	 * Get the link state now because no events will be generated
	 */
	vmxnet3_refresh_linkstate(dp);
	mac_link_update(dp->mac, dp->linkState);

	/*
	 * Finally, unmask the interrupt
	 */
	VMXNET3_BAR0_PUT32(dp, VMXNET3_REG_IMR, 0);

	return (0);

error_txhandle:
	ddi_dma_free_handle(&dp->txDmaHandle);
error_rx_queue:
	vmxnet3_destroy_rxqueue(dp);
error_tx_queue:
	vmxnet3_destroy_txqueue(dp);
error_shared_data:
	vmxnet3_destroy_drivershared(dp);
error:
	return (err);
}

/*
 * Stop a vmxnet3 device: send a stop command to the device and
 * de-allocate the shared data structures.
 */
static void
vmxnet3_stop(void *data)
{
	vmxnet3_softc_t *dp = data;

	VMXNET3_DEBUG(dp, 1, "stop()\n");

	/*
	 * Take the 2 locks related to asynchronous events.
	 * These events should always check dp->devEnabled before poking dp.
	 */
	mutex_enter(&dp->intrLock);
	mutex_enter(&dp->rxPoolLock);
	VMXNET3_BAR0_PUT32(dp, VMXNET3_REG_IMR, 1);
	dp->devEnabled = B_FALSE;
	VMXNET3_BAR1_PUT32(dp, VMXNET3_REG_CMD, VMXNET3_CMD_QUIESCE_DEV);
	mutex_exit(&dp->rxPoolLock);
	mutex_exit(&dp->intrLock);

	ddi_dma_free_handle(&dp->txDmaHandle);

	vmxnet3_destroy_rxqueue(dp);
	vmxnet3_destroy_txqueue(dp);

	vmxnet3_destroy_drivershared(dp);
}

/*
 * Set or unset promiscuous mode on a vmxnet3 device.
 */
static int
vmxnet3_setpromisc(void *data, boolean_t promisc)
{
	vmxnet3_softc_t *dp = data;

	VMXNET3_DEBUG(dp, 2, "setpromisc(%s)\n", promisc ? "TRUE" : "FALSE");

	if (promisc) {
		dp->rxMode |= VMXNET3_RXM_PROMISC;
	} else {
		dp->rxMode &= ~VMXNET3_RXM_PROMISC;
	}

	vmxnet3_refresh_rxfilter(dp);

	return (0);
}

/*
 * Add or remove a multicast address from/to a vmxnet3 device.
 *
 * Returns:
 *	0 on success, non-zero on failure.
 */
static int
vmxnet3_multicst(void *data, boolean_t add, const uint8_t *macaddr)
{
	vmxnet3_softc_t *dp = data;
	vmxnet3_dmabuf_t newMfTable;
	int ret = 0;
	uint16_t macIdx;
	size_t allocSize;

	VMXNET3_DEBUG(dp, 2, "multicst(%s, "MACADDR_FMT")\n",
	    add ? "add" : "remove", MACADDR_FMT_ARGS(macaddr));

	/*
	 * First lookup the position of the given MAC to check if it is
	 * present in the existing MF table.
	 */
	for (macIdx = 0; macIdx < dp->mfTable.bufLen; macIdx += 6) {
		if (memcmp(&dp->mfTable.buf[macIdx], macaddr, 6) == 0) {
			break;
		}
	}

	/*
	 * Check for 2 situations we can handle gracefully by bailing out:
	 * Adding an already existing filter or removing a non-existing one.
	 */
	if (add && macIdx < dp->mfTable.bufLen) {
		VMXNET3_WARN(dp, MACADDR_FMT " already in MC filter list "
		    "@ %u\n", MACADDR_FMT_ARGS(macaddr), macIdx / 6);
		ASSERT(B_FALSE);
		goto done;
	}
	if (!add && macIdx == dp->mfTable.bufLen) {
		VMXNET3_WARN(dp, MACADDR_FMT " not in MC filter list @ %u\n",
		    MACADDR_FMT_ARGS(macaddr), macIdx / 6);
		ASSERT(B_FALSE);
		goto done;
	}

	/*
	 * Create the new MF table
	 */
	allocSize = dp->mfTable.bufLen + (add ? 6 : -6);
	if (allocSize) {
		ret = vmxnet3_alloc_dma_mem_1(dp, &newMfTable, allocSize,
		    B_TRUE);
		ASSERT(ret == 0);
		if (add) {
			(void) memcpy(newMfTable.buf, dp->mfTable.buf,
			    dp->mfTable.bufLen);
			(void) memcpy(newMfTable.buf + dp->mfTable.bufLen,
			    macaddr, 6);
		} else {
			(void) memcpy(newMfTable.buf, dp->mfTable.buf,
			    macIdx);
			(void) memcpy(newMfTable.buf + macIdx,
			    dp->mfTable.buf + macIdx + 6,
			    dp->mfTable.bufLen - macIdx - 6);
		}
	} else {
		newMfTable.buf = NULL;
		newMfTable.bufPA = 0;
		newMfTable.bufLen = 0;
	}

	/*
	 * Now handle 2 corner cases: if we're creating the first filter or
	 * removing the last one, we have to update rxMode accordingly.
	 */
	if (add && newMfTable.bufLen == 6) {
		ASSERT(!(dp->rxMode & VMXNET3_RXM_MCAST));
		dp->rxMode |= VMXNET3_RXM_MCAST;
		vmxnet3_refresh_rxfilter(dp);
	}
	if (!add && dp->mfTable.bufLen == 6) {
		ASSERT(newMfTable.buf == NULL);
		ASSERT(dp->rxMode & VMXNET3_RXM_MCAST);
		dp->rxMode &= ~VMXNET3_RXM_MCAST;
		vmxnet3_refresh_rxfilter(dp);
	}

	/*
	 * Now replace the old MF table with the new one
	 */
	if (dp->mfTable.buf) {
		vmxnet3_free_dma_mem(&dp->mfTable);
	}
	dp->mfTable = newMfTable;
	VMXNET3_DS(dp)->devRead.rxFilterConf.mfTablePA = newMfTable.bufPA;
	VMXNET3_DS(dp)->devRead.rxFilterConf.mfTableLen = newMfTable.bufLen;

done:
	/* Always update the filters */
	VMXNET3_BAR1_PUT32(dp, VMXNET3_REG_CMD, VMXNET3_CMD_UPDATE_MAC_FILTERS);

	return (ret);
}

/*
 * Set the mac address of a vmxnet3 device.
 *
 * Returns:
 *	0
 */
static int
vmxnet3_unicst(void *data, const uint8_t *macaddr)
{
	vmxnet3_softc_t *dp = data;
	uint32_t val32;

	VMXNET3_DEBUG(dp, 2, "unicst("MACADDR_FMT")\n",
	    MACADDR_FMT_ARGS(macaddr));

	val32 = *((uint32_t *)(macaddr + 0));
	VMXNET3_BAR1_PUT32(dp, VMXNET3_REG_MACL, val32);
	val32 = *((uint16_t *)(macaddr + 4));
	VMXNET3_BAR1_PUT32(dp, VMXNET3_REG_MACH, val32);

	(void) memcpy(dp->macaddr, macaddr, 6);

	return (0);
}

/*
 * Change the MTU as seen by the driver. This is only supported when
 * the mac is stopped.
 *
 * Returns:
 *	EBUSY if the device is enabled.
 *	EINVAL for invalid MTU values.
 *	0 on success.
 */
static int
vmxnet3_change_mtu(vmxnet3_softc_t *dp, uint32_t new_mtu)
{
	int ret;

	if (dp->devEnabled)
		return (EBUSY);

	if (new_mtu == dp->cur_mtu) {
		VMXNET3_WARN(dp, "New MTU is same as old mtu : %d.\n", new_mtu);
		return (0);
	}

	if (new_mtu < VMXNET3_MIN_MTU || new_mtu > VMXNET3_MAX_MTU) {
		VMXNET3_WARN(dp, "New MTU not in valid range [%d, %d].\n",
		    VMXNET3_MIN_MTU, VMXNET3_MAX_MTU);
		return (EINVAL);
	} else if (new_mtu > ETHERMTU && !dp->allow_jumbo) {
		VMXNET3_WARN(dp, "MTU cannot be greater than %d because "
		    "accept-jumbo is not enabled.\n", ETHERMTU);
		return (EINVAL);
	}

	dp->cur_mtu = new_mtu;
	dp->alloc_ok = VMXNET3_ALLOC_OK(dp);

	if ((ret = mac_maxsdu_update(dp->mac, new_mtu)) != 0)
		VMXNET3_WARN(dp, "Unable to update mac with %d mtu: %d",
		    new_mtu, ret);

	return (ret);
}

/* ARGSUSED */
static int
vmxnet3_get_prop(void *data, const char *prop_name, mac_prop_id_t prop_id,
    uint_t prop_val_size, void *prop_val)
{
	vmxnet3_softc_t *dp = data;
	int ret = 0;

	switch (prop_id) {
	case MAC_PROP_MTU:
		ASSERT(prop_val_size >= sizeof (uint32_t));
		bcopy(&dp->cur_mtu, prop_val, sizeof (uint32_t));
		break;
	default:
		ret = ENOTSUP;
		break;
	}
	return (ret);
}

/* ARGSUSED */
static int
vmxnet3_set_prop(void *data, const char *prop_name, mac_prop_id_t prop_id,
    uint_t prop_val_size, const void *prop_val)
{
	vmxnet3_softc_t *dp = data;
	int ret;

	switch (prop_id) {
	case MAC_PROP_MTU: {
		uint32_t new_mtu;
		ASSERT(prop_val_size >= sizeof (uint32_t));
		bcopy(prop_val, &new_mtu, sizeof (new_mtu));
		ret = vmxnet3_change_mtu(dp, new_mtu);
		break;
	}
	default:
		ret = ENOTSUP;
		break;
	}

	return (ret);
}

/* ARGSUSED */
static void
vmxnet3_prop_info(void *data, const char *prop_name, mac_prop_id_t prop_id,
    mac_prop_info_handle_t prop_handle)
{
	switch (prop_id) {
	case MAC_PROP_MTU:
		mac_prop_info_set_range_uint32(prop_handle, VMXNET3_MIN_MTU,
		    VMXNET3_MAX_MTU);
		break;
	default:
		break;
	}
}

/*
 * DDI/DDK callback to handle IOCTL in driver. Currently it only handles
 * ND_SET ioctl. Rest all are ignored. The ND_SET is used to set/reset
 * accept-jumbo ndd parameted for the interface.
 *
 * Side effects:
 *	MTU can be changed and device can be reset. An ACK or NACK is conveyed
 *	to the calling function from the mblk which was used to call this
 *	function.
 */
static void
vmxnet3_ioctl(void *arg, queue_t *wq, mblk_t *mp)
{
	vmxnet3_softc_t *dp = arg;
	int ret = EINVAL;
	IOCP iocp;
	mblk_t *mp1;
	char *valp, *param;
	int data;

	iocp = (void *)mp->b_rptr;
	iocp->ioc_error = 0;

	switch (iocp->ioc_cmd) {
	case ND_SET:
		/*
		 * The mblk in continuation would contain the ndd parameter name
		 * and data value to be set
		 */
		mp1 = mp->b_cont;
		if (!mp1) {
			VMXNET3_WARN(dp, "Error locating parameter name.\n");
			ret = EINVAL;
			break;
		}

		/* Force null termination */
		mp1->b_datap->db_lim[-1] = '\0';

		/*
		 * From /usr/src/uts/common/inet/nd.c : nd_getset()
		 * "logic throughout nd_xxx assumes single data block for ioctl.
		 *  However, existing code sends in some big buffers."
		 */
		if (mp1->b_cont) {
			freemsg(mp1->b_cont);
			mp1->b_cont = NULL;
		}

		valp = (char *)mp1->b_rptr;	/* Points to param name */
		ASSERT(valp);
		param = valp;
		VMXNET3_DEBUG(dp, 3, "ND Set ioctl for %s\n", param);

		/*
		 * Go past the end of this null terminated string to get the
		 * data value.
		 */
		while (*valp && valp <= (char *)mp1->b_wptr)
			valp++;

		if (valp > (char *)mp1->b_wptr) {
			/*
			 * We are already beyond the readable area of mblk and
			 * still haven't found the end of param string.
			 */
			VMXNET3_WARN(dp,
			    "No data value found to be set to param\n");
			data = -1;
		} else {
			/* Now this points to data string */
			valp++;
			/* Get numeric value of first letter */
			data = (int)*valp - (int)'0';
		}

		if (strcmp("accept-jumbo", param) == 0) {
			if (data == 1) {
				VMXNET3_DEBUG(dp, 2,
				    "Accepting jumbo frames\n");
				dp->allow_jumbo = B_TRUE;
				ret = vmxnet3_change_mtu(dp, VMXNET3_MAX_MTU);
			} else if (data == 0) {
				VMXNET3_DEBUG(dp, 2,
				    "Rejecting jumbo frames\n");
				dp->allow_jumbo = B_FALSE;
				ret = vmxnet3_change_mtu(dp, ETHERMTU);
			} else {
				VMXNET3_WARN(dp, "Invalid data value to be set,"
				    " use 0 or 1\n");
				ret = -1;
			}
		}
		freemsg(mp1);
		mp->b_cont = NULL;
		break;

	default:
		if (mp->b_cont) {
			freemsg(mp->b_cont);
			mp->b_cont = NULL;
		}
		ret = -1;
		break;
	}

	if (ret == 0)
		miocack(wq, mp, 0, 0);
	else
		miocnak(wq, mp, 0, EINVAL);
}

/*
 * Get the capabilities of a vmxnet3 device.
 *
 * Returns:
 *	B_TRUE if the capability is supported, B_FALSE otherwise.
 */
static boolean_t
vmxnet3_getcapab(void *data, mac_capab_t capab, void *arg)
{
	vmxnet3_softc_t *dp = data;
	boolean_t ret;

	switch (capab) {
	case MAC_CAPAB_HCKSUM: {
		uint32_t *txflags = arg;
		*txflags = HCKSUM_INET_PARTIAL;
		ret = B_TRUE;
		break;
	}
	case MAC_CAPAB_LSO: {
		mac_capab_lso_t *lso = arg;
		lso->lso_flags = LSO_TX_BASIC_TCP_IPV4;
		lso->lso_basic_tcp_ipv4.lso_max = IP_MAXPACKET;
		ret = vmxnet3_getprop(dp, "EnableLSO", 0, 1, 1);
		break;
	}
	default:
		ret = B_FALSE;
	}

	VMXNET3_DEBUG(dp, 2, "getcapab(0x%x) -> %s\n", capab,
	    ret ? "yes" : "no");

	return (ret);
}

/*
 * Reset a vmxnet3 device. Only to be used when the device is wedged.
 *
 * Side effects:
 *	The device is reset.
 */
static void
vmxnet3_reset(void *data)
{
	int ret;

	vmxnet3_softc_t *dp = data;

	VMXNET3_DEBUG(dp, 1, "vmxnet3_reset()\n");

	atomic_inc_32(&dp->reset_count);
	vmxnet3_stop(dp);
	VMXNET3_BAR1_PUT32(dp, VMXNET3_REG_CMD, VMXNET3_CMD_RESET_DEV);
	if ((ret = vmxnet3_start(dp)) != 0)
		VMXNET3_WARN(dp, "failed to reset the device: %d", ret);
}

/*
 * Process pending events on a vmxnet3 device.
 *
 * Returns:
 *	B_TRUE if the link state changed, B_FALSE otherwise.
 */
static boolean_t
vmxnet3_intr_events(vmxnet3_softc_t *dp)
{
	Vmxnet3_DriverShared *ds = VMXNET3_DS(dp);
	boolean_t linkStateChanged = B_FALSE;
	uint32_t events = ds->ecr;

	if (events) {
		VMXNET3_DEBUG(dp, 2, "events(0x%x)\n", events);
		if (events & (VMXNET3_ECR_RQERR | VMXNET3_ECR_TQERR)) {
			Vmxnet3_TxQueueDesc *tqdesc = VMXNET3_TQDESC(dp);
			Vmxnet3_RxQueueDesc *rqdesc = VMXNET3_RQDESC(dp);

			VMXNET3_BAR1_PUT32(dp, VMXNET3_REG_CMD,
			    VMXNET3_CMD_GET_QUEUE_STATUS);
			if (tqdesc->status.stopped) {
				VMXNET3_WARN(dp, "tq error 0x%x\n",
				    tqdesc->status.error);
			}
			if (rqdesc->status.stopped) {
				VMXNET3_WARN(dp, "rq error 0x%x\n",
				    rqdesc->status.error);
			}

			if (ddi_taskq_dispatch(dp->resetTask, vmxnet3_reset,
			    dp, DDI_NOSLEEP) == DDI_SUCCESS) {
				VMXNET3_WARN(dp, "reset scheduled\n");
			} else {
				VMXNET3_WARN(dp,
				    "ddi_taskq_dispatch() failed\n");
			}
		}
		if (events & VMXNET3_ECR_LINK) {
			vmxnet3_refresh_linkstate(dp);
			linkStateChanged = B_TRUE;
		}
		if (events & VMXNET3_ECR_DIC) {
			VMXNET3_DEBUG(dp, 1, "device implementation change\n");
		}
		VMXNET3_BAR1_PUT32(dp, VMXNET3_REG_ECR, events);
	}

	return (linkStateChanged);
}

/*
 * Interrupt handler of a vmxnet3 device.
 *
 * Returns:
 *	DDI_INTR_CLAIMED or DDI_INTR_UNCLAIMED.
 */
/* ARGSUSED1 */
static uint_t
vmxnet3_intr(caddr_t data1, caddr_t data2)
{
	vmxnet3_softc_t *dp = (void *) data1;

	VMXNET3_DEBUG(dp, 3, "intr()\n");

	mutex_enter(&dp->intrLock);

	if (dp->devEnabled) {
		boolean_t linkStateChanged;
		boolean_t mustUpdateTx;
		mblk_t *mps;

		if (dp->intrType == DDI_INTR_TYPE_FIXED &&
		    !VMXNET3_BAR1_GET32(dp, VMXNET3_REG_ICR)) {
			goto intr_unclaimed;
		}

		if (dp->intrMaskMode == VMXNET3_IMM_ACTIVE) {
			VMXNET3_BAR0_PUT32(dp, VMXNET3_REG_IMR, 1);
		}

		linkStateChanged = vmxnet3_intr_events(dp);
		mustUpdateTx = vmxnet3_tx_complete(dp, &dp->txQueue);
		mps = vmxnet3_rx_intr(dp, &dp->rxQueue);

		mutex_exit(&dp->intrLock);
		VMXNET3_BAR0_PUT32(dp, VMXNET3_REG_IMR, 0);

		if (linkStateChanged) {
			mac_link_update(dp->mac, dp->linkState);
		}
		if (mustUpdateTx) {
			mac_tx_update(dp->mac);
		}
		if (mps) {
			mac_rx(dp->mac, NULL, mps);
		}

		return (DDI_INTR_CLAIMED);
	}

intr_unclaimed:
	mutex_exit(&dp->intrLock);
	return (DDI_INTR_UNCLAIMED);
}

static int
vmxnet3_kstat_update(kstat_t *ksp, int rw)
{
	vmxnet3_softc_t *dp = ksp->ks_private;
	vmxnet3_kstats_t *statp = ksp->ks_data;

	if (rw == KSTAT_WRITE)
		return (EACCES);

	statp->reset_count.value.ul = dp->reset_count;
	statp->tx_pullup_needed.value.ul = dp->tx_pullup_needed;
	statp->tx_ring_full.value.ul = dp->tx_ring_full;
	statp->rx_alloc_buf.value.ul = dp->rx_alloc_buf;
	statp->rx_pool_empty.value.ul = dp->rx_pool_empty;
	statp->rx_num_bufs.value.ul = dp->rx_num_bufs;

	return (0);
}

static int
vmxnet3_kstat_init(vmxnet3_softc_t *dp)
{
	vmxnet3_kstats_t *statp;

	dp->devKstats = kstat_create(VMXNET3_MODNAME, dp->instance,
	    "statistics", "dev",  KSTAT_TYPE_NAMED,
	    sizeof (vmxnet3_kstats_t) / sizeof (kstat_named_t), 0);
	if (dp->devKstats == NULL)
		return (DDI_FAILURE);

	dp->devKstats->ks_update = vmxnet3_kstat_update;
	dp->devKstats->ks_private = dp;

	statp = dp->devKstats->ks_data;

	kstat_named_init(&statp->reset_count, "reset_count", KSTAT_DATA_ULONG);
	kstat_named_init(&statp->tx_pullup_needed, "tx_pullup_needed",
	    KSTAT_DATA_ULONG);
	kstat_named_init(&statp->tx_ring_full, "tx_ring_full",
	    KSTAT_DATA_ULONG);
	kstat_named_init(&statp->rx_alloc_buf, "rx_alloc_buf",
	    KSTAT_DATA_ULONG);
	kstat_named_init(&statp->rx_pool_empty, "rx_pool_empty",
	    KSTAT_DATA_ULONG);
	kstat_named_init(&statp->rx_num_bufs, "rx_num_bufs",
	    KSTAT_DATA_ULONG);

	kstat_install(dp->devKstats);

	return (DDI_SUCCESS);
}

/*
 * Probe and attach a vmxnet3 instance to the stack.
 *
 * Returns:
 *	DDI_SUCCESS or DDI_FAILURE.
 */
static int
vmxnet3_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	vmxnet3_softc_t *dp;
	mac_register_t *macr;
	uint16_t vendorId, devId, ret16;
	uint32_t ret32;
	int ret, err;
	uint_t uret;

	if (cmd != DDI_ATTACH) {
		goto error;
	}

	/*
	 * Allocate the soft state
	 */
	dp = kmem_zalloc(sizeof (vmxnet3_softc_t), KM_SLEEP);
	ASSERT(dp);

	dp->dip = dip;
	dp->instance = ddi_get_instance(dip);
	dp->cur_mtu = ETHERMTU;
	dp->allow_jumbo = B_TRUE;
	dp->alloc_ok = VMXNET3_ALLOC_OK(dp);

	VMXNET3_DEBUG(dp, 1, "attach()\n");

	ddi_set_driver_private(dip, dp);

	/*
	 * Get access to the PCI bus configuration space
	 */
	if (pci_config_setup(dip, &dp->pciHandle) != DDI_SUCCESS) {
		VMXNET3_WARN(dp, "pci_config_setup() failed\n");
		goto error_soft_state;
	}

	/*
	 * Make sure the chip is a vmxnet3 device
	 */
	vendorId = pci_config_get16(dp->pciHandle, PCI_CONF_VENID);
	devId = pci_config_get16(dp->pciHandle, PCI_CONF_DEVID);
	if (vendorId != PCI_VENDOR_ID_VMWARE ||
	    devId != PCI_DEVICE_ID_VMWARE_VMXNET3) {
		VMXNET3_WARN(dp, "wrong PCI venid/devid (0x%x, 0x%x)\n",
		    vendorId, devId);
		goto error_pci_config;
	}

	/*
	 * Make sure we can access the registers through the I/O space
	 */
	ret16 = pci_config_get16(dp->pciHandle, PCI_CONF_COMM);
	ret16 |= PCI_COMM_IO | PCI_COMM_ME;
	pci_config_put16(dp->pciHandle, PCI_CONF_COMM, ret16);

	/*
	 * Map the I/O space in memory
	 */
	if (ddi_regs_map_setup(dip, 1, &dp->bar0, 0, 0, &vmxnet3_dev_attr,
	    &dp->bar0Handle) != DDI_SUCCESS) {
		VMXNET3_WARN(dp, "ddi_regs_map_setup() for BAR0 failed\n");
		goto error_pci_config;
	}

	if (ddi_regs_map_setup(dip, 2, &dp->bar1, 0, 0, &vmxnet3_dev_attr,
	    &dp->bar1Handle) != DDI_SUCCESS) {
		VMXNET3_WARN(dp, "ddi_regs_map_setup() for BAR1 failed\n");
		goto error_regs_map_0;
	}

	/*
	 * Check the version number of the virtual device
	 */
	if (VMXNET3_BAR1_GET32(dp, VMXNET3_REG_VRRS) & 1) {
		VMXNET3_BAR1_PUT32(dp, VMXNET3_REG_VRRS, 1);
	} else {
		VMXNET3_WARN(dp, "incompatible h/w version\n");
		goto error_regs_map_1;
	}

	if (VMXNET3_BAR1_GET32(dp, VMXNET3_REG_UVRS) & 1) {
		VMXNET3_BAR1_PUT32(dp, VMXNET3_REG_UVRS, 1);
	} else {
		VMXNET3_WARN(dp, "incompatible upt version\n");
		goto error_regs_map_1;
	}

	if (vmxnet3_kstat_init(dp) != DDI_SUCCESS) {
		VMXNET3_WARN(dp, "unable to initialize kstats");
		goto error_regs_map_1;
	}

	/*
	 * Read the MAC address from the device
	 */
	ret32 = VMXNET3_BAR1_GET32(dp, VMXNET3_REG_MACL);
	*((uint32_t *)(dp->macaddr + 0)) = ret32;
	ret32 = VMXNET3_BAR1_GET32(dp, VMXNET3_REG_MACH);
	*((uint16_t *)(dp->macaddr + 4)) = ret32;

	/*
	 * Register with the MAC framework
	 */
	if (!(macr = mac_alloc(MAC_VERSION))) {
		VMXNET3_WARN(dp, "mac_alloc() failed\n");
		goto error_kstat;
	}

	macr->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
	macr->m_driver = dp;
	macr->m_dip = dip;
	macr->m_instance = 0;
	macr->m_src_addr = dp->macaddr;
	macr->m_dst_addr = NULL;
	macr->m_callbacks = &vmxnet3_mac_callbacks;
	macr->m_min_sdu = 0;
	macr->m_max_sdu = ETHERMTU;
	macr->m_margin = VLAN_TAGSZ;
	macr->m_pdata = NULL;
	macr->m_pdata_size = 0;

	ret = mac_register(macr, &dp->mac);
	mac_free(macr);
	if (ret != DDI_SUCCESS) {
		VMXNET3_WARN(dp, "mac_register() failed\n");
		goto error_kstat;
	}

	/*
	 * Register the interrupt(s) in this order of preference:
	 * MSI-X, MSI, INTx
	 */
	VMXNET3_BAR1_PUT32(dp, VMXNET3_REG_CMD, VMXNET3_CMD_GET_CONF_INTR);
	ret32 = VMXNET3_BAR1_GET32(dp, VMXNET3_REG_CMD);
	switch (ret32 & 0x3) {
	case VMXNET3_IT_AUTO:
	case VMXNET3_IT_MSIX:
		dp->intrType = DDI_INTR_TYPE_MSIX;
		err = ddi_intr_alloc(dip, &dp->intrHandle, dp->intrType, 0, 1,
		    &ret, DDI_INTR_ALLOC_STRICT);
		if (err == DDI_SUCCESS)
			break;
		VMXNET3_DEBUG(dp, 2, "DDI_INTR_TYPE_MSIX failed, err:%d\n",
		    err);
		/* FALLTHROUGH */
	case VMXNET3_IT_MSI:
		dp->intrType = DDI_INTR_TYPE_MSI;
		if (ddi_intr_alloc(dip, &dp->intrHandle, dp->intrType, 0, 1,
		    &ret, DDI_INTR_ALLOC_STRICT) == DDI_SUCCESS)
			break;
		VMXNET3_DEBUG(dp, 2, "DDI_INTR_TYPE_MSI failed\n");
		/* FALLTHROUGH */
	case VMXNET3_IT_INTX:
		dp->intrType = DDI_INTR_TYPE_FIXED;
		if (ddi_intr_alloc(dip, &dp->intrHandle, dp->intrType, 0, 1,
		    &ret, DDI_INTR_ALLOC_STRICT) == DDI_SUCCESS) {
			break;
		}
		VMXNET3_DEBUG(dp, 2, "DDI_INTR_TYPE_INTX failed\n");
		/* FALLTHROUGH */
	default:
		VMXNET3_WARN(dp, "ddi_intr_alloc() failed\n");
		goto error_mac;
	}
	dp->intrMaskMode = (ret32 >> 2) & 0x3;
	if (dp->intrMaskMode == VMXNET3_IMM_LAZY) {
		VMXNET3_WARN(dp, "Lazy masking is not supported\n");
		goto error_intr;
	}

	if (ddi_intr_get_pri(dp->intrHandle, &uret) != DDI_SUCCESS) {
		VMXNET3_WARN(dp, "ddi_intr_get_pri() failed\n");
		goto error_intr;
	}

	VMXNET3_DEBUG(dp, 2, "intrType=0x%x, intrMaskMode=0x%x, intrPrio=%u\n",
	    dp->intrType, dp->intrMaskMode, uret);

	/*
	 * Create a task queue to reset the device if it wedges.
	 */
	dp->resetTask = ddi_taskq_create(dip, "vmxnet3_reset_task", 1,
	    TASKQ_DEFAULTPRI, 0);
	if (!dp->resetTask) {
		VMXNET3_WARN(dp, "ddi_taskq_create() failed()\n");
		goto error_intr;
	}

	/*
	 * Initialize our mutexes now that we know the interrupt priority
	 * This _must_ be done before ddi_intr_enable()
	 */
	mutex_init(&dp->intrLock, NULL, MUTEX_DRIVER, DDI_INTR_PRI(uret));
	mutex_init(&dp->txLock, NULL, MUTEX_DRIVER, DDI_INTR_PRI(uret));
	mutex_init(&dp->rxPoolLock, NULL, MUTEX_DRIVER, DDI_INTR_PRI(uret));

	if (ddi_intr_add_handler(dp->intrHandle, vmxnet3_intr,
	    dp, NULL) != DDI_SUCCESS) {
		VMXNET3_WARN(dp, "ddi_intr_add_handler() failed\n");
		goto error_mutexes;
	}

	err = ddi_intr_get_cap(dp->intrHandle, &dp->intrCap);
	if (err != DDI_SUCCESS) {
		VMXNET3_WARN(dp, "ddi_intr_get_cap() failed %d", err);
		goto error_intr_handler;
	}

	if (dp->intrCap & DDI_INTR_FLAG_BLOCK) {
		err = ddi_intr_block_enable(&dp->intrHandle, 1);
		if (err != DDI_SUCCESS) {
			VMXNET3_WARN(dp, "ddi_intr_block_enable() failed, "
			    "err:%d\n", err);
			goto error_intr_handler;
		}
	} else {
		err = ddi_intr_enable(dp->intrHandle);
		if ((err != DDI_SUCCESS)) {
			VMXNET3_WARN(dp, "ddi_intr_enable() failed, err:%d\n",
			    err);
			goto error_intr_handler;
		}
	}

	return (DDI_SUCCESS);

error_intr_handler:
	(void) ddi_intr_remove_handler(dp->intrHandle);
error_mutexes:
	mutex_destroy(&dp->rxPoolLock);
	mutex_destroy(&dp->txLock);
	mutex_destroy(&dp->intrLock);
	ddi_taskq_destroy(dp->resetTask);
error_intr:
	(void) ddi_intr_free(dp->intrHandle);
error_mac:
	(void) mac_unregister(dp->mac);
error_kstat:
	kstat_delete(dp->devKstats);
error_regs_map_1:
	ddi_regs_map_free(&dp->bar1Handle);
error_regs_map_0:
	ddi_regs_map_free(&dp->bar0Handle);
error_pci_config:
	pci_config_teardown(&dp->pciHandle);
error_soft_state:
	kmem_free(dp, sizeof (vmxnet3_softc_t));
error:
	return (DDI_FAILURE);
}

/*
 * Detach a vmxnet3 instance from the stack.
 *
 * Returns:
 *	DDI_SUCCESS or DDI_FAILURE.
 */
static int
vmxnet3_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	vmxnet3_softc_t *dp = ddi_get_driver_private(dip);
	unsigned int retries = 0;
	int ret;

	VMXNET3_DEBUG(dp, 1, "detach()\n");

	if (cmd != DDI_DETACH) {
		return (DDI_FAILURE);
	}

	while (dp->rx_num_bufs > 0) {
		if (retries++ < 10) {
			VMXNET3_WARN(dp, "rx pending (%u), waiting 1 second\n",
			    dp->rx_num_bufs);
			delay(drv_usectohz(1000000));
		} else {
			VMXNET3_WARN(dp, "giving up\n");
			return (DDI_FAILURE);
		}
	}

	if (dp->intrCap & DDI_INTR_FLAG_BLOCK) {
		ret = ddi_intr_block_disable(&dp->intrHandle, 1);
	} else {
		ret = ddi_intr_disable(dp->intrHandle);
	}
	if (ret != DDI_SUCCESS) {
		VMXNET3_WARN(dp, "unable to disable interrupts");
		return (DDI_FAILURE);
	}
	if (ddi_intr_remove_handler(dp->intrHandle) != DDI_SUCCESS) {
		VMXNET3_WARN(dp, "unable to remove interrupt handler");
		return (DDI_FAILURE);
	}
	(void) ddi_intr_free(dp->intrHandle);

	VERIFY(mac_unregister(dp->mac) == 0);

	kstat_delete(dp->devKstats);

	if (dp->mfTable.buf) {
		vmxnet3_free_dma_mem(&dp->mfTable);
	}

	mutex_destroy(&dp->rxPoolLock);
	mutex_destroy(&dp->txLock);
	mutex_destroy(&dp->intrLock);
	ddi_taskq_destroy(dp->resetTask);

	ddi_regs_map_free(&dp->bar1Handle);
	ddi_regs_map_free(&dp->bar0Handle);
	pci_config_teardown(&dp->pciHandle);

	kmem_free(dp, sizeof (vmxnet3_softc_t));

	return (DDI_SUCCESS);
}

/*
 * Structures used by the module loader
 */

#define	VMXNET3_IDENT "VMware Ethernet v3 " VMXNET3_DRIVER_VERSION_STRING

DDI_DEFINE_STREAM_OPS(
	vmxnet3_dev_ops,
	nulldev,
	nulldev,
	vmxnet3_attach,
	vmxnet3_detach,
	nodev,
	NULL,
	D_NEW | D_MP,
	NULL,
	ddi_quiesce_not_supported);

static struct modldrv vmxnet3_modldrv = {
	&mod_driverops,		/* drv_modops */
	VMXNET3_IDENT,		/* drv_linkinfo */
	&vmxnet3_dev_ops	/* drv_dev_ops */
};

static struct modlinkage vmxnet3_modlinkage = {
	MODREV_1,			/* ml_rev */
	{ &vmxnet3_modldrv, NULL }	/* ml_linkage */
};

/* Module load entry point */
int
_init(void)
{
	int ret;

	mac_init_ops(&vmxnet3_dev_ops, VMXNET3_MODNAME);
	ret = mod_install(&vmxnet3_modlinkage);
	if (ret != DDI_SUCCESS) {
		mac_fini_ops(&vmxnet3_dev_ops);
	}

	return (ret);
}

/* Module unload entry point */
int
_fini(void)
{
	int ret;

	ret = mod_remove(&vmxnet3_modlinkage);
	if (ret == DDI_SUCCESS) {
		mac_fini_ops(&vmxnet3_dev_ops);
	}

	return (ret);
}

/* Module info entry point */
int
_info(struct modinfo *modinfop)
{
	return (mod_info(&vmxnet3_modlinkage, modinfop));
}