xref: /titanic_44/usr/src/uts/common/io/bfe/bfe.c (revision 00d1eed8323f3add6273b62fe277d00cd8518bca)

/*
 * 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 (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
 */
#include <sys/stream.h>
#include <sys/strsun.h>
#include <sys/stat.h>
#include <sys/pci.h>
#include <sys/modctl.h>
#include <sys/kstat.h>
#include <sys/ethernet.h>
#include <sys/devops.h>
#include <sys/debug.h>
#include <sys/conf.h>
#include <sys/sysmacros.h>
#include <sys/dditypes.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/miiregs.h>
#include <sys/byteorder.h>
#include <sys/cyclic.h>
#include <sys/note.h>
#include <sys/crc32.h>
#include <sys/mac_provider.h>
#include <sys/mac_ether.h>
#include <sys/vlan.h>
#include <sys/errno.h>
#include <sys/sdt.h>
#include <sys/strsubr.h>

#include "bfe.h"
#include "bfe_hw.h"


/*
 * Broadcom BCM4401 chipsets use two rings :
 *
 * - One TX : For sending packets down the wire.
 * - One RX : For receving packets.
 *
 * Each ring can have any number of descriptors (configured during attach).
 * As of now we configure only 128 descriptor per ring (TX/RX). Each descriptor
 * has address (desc_addr) and control (desc_ctl) which holds a DMA buffer for
 * the packet and control information (like start/end of frame or end of table).
 * The descriptor table is allocated first and then a DMA buffer (for a packet)
 * is allocated and linked to each descriptor.
 *
 * Each descriptor entry is bfe_desc_t structure in bfe. During TX/RX
 * interrupt, the stat register will point to current descriptor being
 * processed.
 *
 * Here's an example of TX and RX ring :
 *
 * TX:
 *
 *   Base of the descriptor table is programmed using BFE_DMATX_CTRL control
 *   register. Each 'addr' points to DMA buffer (or packet data buffer) to
 *   be transmitted and 'ctl' has the length of the packet (usually MTU).
 *
 *  ----------------------|
 *  | addr |Descriptor 0  |
 *  | ctl  |              |
 *  ----------------------|
 *  | addr |Descriptor 1  |    SOF (start of the frame)
 *  | ctl  |              |
 *  ----------------------|
 *  | ...  |Descriptor... |    EOF (end of the frame)
 *  | ...  |              |
 *  ----------------------|
 *  | addr |Descritor 127 |
 *  | ctl  | EOT          |    EOT (End of Table)
 *  ----------------------|
 *
 * 'r_curr_desc'  : pointer to current descriptor which can be used to transmit
 *                  a packet.
 * 'r_avail_desc' : decremented whenever a packet is being sent.
 * 'r_cons_desc'  : incremented whenever a packet is sent down the wire and
 *                  notified by an interrupt to bfe driver.
 *
 * RX:
 *
 *   Base of the descriptor table is programmed using BFE_DMARX_CTRL control
 *   register. Each 'addr' points to DMA buffer (or packet data buffer). 'ctl'
 *   contains the size of the DMA buffer and all the DMA buffers are
 *   pre-allocated during attach and hence the maxmium size of the packet is
 *   also known (r_buf_len from the bfe_rint_t structure). During RX interrupt
 *   the packet length is embedded in bfe_header_t which is added by the
 *   chip in the beginning of the packet.
 *
 *  ----------------------|
 *  | addr |Descriptor 0  |
 *  | ctl  |              |
 *  ----------------------|
 *  | addr |Descriptor 1  |
 *  | ctl  |              |
 *  ----------------------|
 *  | ...  |Descriptor... |
 *  | ...  |              |
 *  ----------------------|
 *  | addr |Descriptor 127|
 *  | ctl  | EOT          |    EOT (End of Table)
 *  ----------------------|
 *
 * 'r_curr_desc'  : pointer to current descriptor while receving a packet.
 *
 */

#define	MODULE_NAME	"bfe"

/*
 * Used for checking PHY (link state, speed)
 */
#define	BFE_TIMEOUT_INTERVAL	(1000 * 1000 * 1000)


/*
 * Chip restart action and reason for restart
 */
#define	BFE_ACTION_RESTART		0x1	/* For restarting the chip */
#define	BFE_ACTION_RESTART_SETPROP	0x2	/* restart due to setprop */
#define	BFE_ACTION_RESTART_FAULT	0x4	/* restart due to fault */
#define	BFE_ACTION_RESTART_PKT		0x8	/* restart due to pkt timeout */

static	char	bfe_ident[] = "bfe driver for Broadcom BCM4401 chipsets";

/*
 * Function Prototypes for bfe driver.
 */
static	int	bfe_check_link(bfe_t *);
static	void	bfe_report_link(bfe_t *);
static	void	bfe_chip_halt(bfe_t *);
static	void	bfe_chip_reset(bfe_t *);
static	void	bfe_tx_desc_init(bfe_ring_t *);
static	void	bfe_rx_desc_init(bfe_ring_t *);
static	void	bfe_set_rx_mode(bfe_t *);
static	void	bfe_enable_chip_intrs(bfe_t *);
static	void	bfe_chip_restart(bfe_t *);
static	void	bfe_init_vars(bfe_t *);
static	void	bfe_clear_stats(bfe_t *);
static	void	bfe_gather_stats(bfe_t *);
static	void	bfe_error(dev_info_t *, char *, ...);
static	int	bfe_mac_getprop(void *, const char *, mac_prop_id_t, uint_t,
    void *);
static	int	bfe_mac_setprop(void *, const char *, mac_prop_id_t, uint_t,
    const void *);
static	int	bfe_tx_reclaim(bfe_ring_t *);
int	bfe_mac_set_ether_addr(void *, const uint8_t *);


/*
 * Macros for ddi_dma_sync().
 */
#define	SYNC_DESC(r, s, l, d)	\
	(void) ddi_dma_sync(r->r_desc_dma_handle, \
	    (off_t)(s * sizeof (bfe_desc_t)), \
	    (size_t)(l * sizeof (bfe_desc_t)), \
	    d)

#define	SYNC_BUF(r, s, b, l, d) \
	(void) ddi_dma_sync(r->r_buf_dma[s].handle, \
	    (off_t)(b), (size_t)(l), d)

/*
 * Supported Broadcom BCM4401 Cards.
 */
static bfe_cards_t bfe_cards[] = {
	{ 0x14e4, 0x170c, "BCM4401 100Base-TX"},
};


/*
 * DMA attributes for device registers, packet data (buffer) and
 * descriptor table.
 */
static struct ddi_device_acc_attr bfe_dev_attr = {
	DDI_DEVICE_ATTR_V0,
	DDI_STRUCTURE_LE_ACC,
	DDI_STRICTORDER_ACC
};

static struct ddi_device_acc_attr bfe_buf_attr = {
	DDI_DEVICE_ATTR_V0,
	DDI_NEVERSWAP_ACC,	/* native endianness */
	DDI_STRICTORDER_ACC
};

static ddi_dma_attr_t bfe_dma_attr_buf = {
	DMA_ATTR_V0,		/* dma_attr_version */
	0,			/* dma_attr_addr_lo */
	BFE_PCI_DMA - 1,	/* dma_attr_addr_hi */
	0x1fff,			/* dma_attr_count_max */
	8,			/* dma_attr_align */
	0,			/* dma_attr_burstsizes */
	1,			/* dma_attr_minxfer */
	0x1fff,			/* dma_attr_maxxfer */
	BFE_PCI_DMA - 1,	/* dma_attr_seg */
	1,			/* dma_attr_sgllen */
	1,			/* dma_attr_granular */
	0			/* dma_attr_flags */
};

static ddi_dma_attr_t bfe_dma_attr_desc = {
	DMA_ATTR_V0,		/* dma_attr_version */
	0,			/* dma_attr_addr_lo */
	BFE_PCI_DMA - 1,	/* dma_attr_addr_hi */
	BFE_PCI_DMA - 1,	/* dma_attr_count_max */
	BFE_DESC_ALIGN,		/* dma_attr_align */
	0,			/* dma_attr_burstsizes */
	1,			/* dma_attr_minxfer */
	BFE_PCI_DMA - 1,	/* dma_attr_maxxfer */
	BFE_PCI_DMA - 1,	/* dma_attr_seg */
	1,			/* dma_attr_sgllen */
	1,			/* dma_attr_granular */
	0			/* dma_attr_flags */
};

/*
 * Ethernet broadcast addresses.
 */
static uchar_t bfe_broadcast[ETHERADDRL] = {
	0xff, 0xff, 0xff, 0xff, 0xff, 0xff
};

#define	ASSERT_ALL_LOCKS(bfe) {	\
	ASSERT(mutex_owned(&bfe->bfe_tx_ring.r_lock));	\
	ASSERT(rw_write_held(&bfe->bfe_rwlock));	\
}

/*
 * Debugging and error reproting code.
 */
static void
bfe_error(dev_info_t *dip, char *fmt, ...)
{
	va_list ap;
	char	buf[256];

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

	if (dip) {
		cmn_err(CE_WARN, "%s%d: %s",
		    ddi_driver_name(dip), ddi_get_instance(dip), buf);
	} else {
		cmn_err(CE_WARN, "bfe: %s", buf);
	}
}

/*
 * Grabs all necessary locks to block any other operation on the chip.
 */
static void
bfe_grab_locks(bfe_t *bfe)
{
	bfe_ring_t *tx = &bfe->bfe_tx_ring;

	/*
	 * Grab all the locks.
	 * - bfe_rwlock : locks down whole chip including RX.
	 * - tx's r_lock : locks down only TX side.
	 */
	rw_enter(&bfe->bfe_rwlock, RW_WRITER);
	mutex_enter(&tx->r_lock);

	/*
	 * Note that we don't use RX's r_lock.
	 */
}

/*
 * Release lock on chip/drver.
 */
static void
bfe_release_locks(bfe_t *bfe)
{
	bfe_ring_t *tx = &bfe->bfe_tx_ring;

	/*
	 * Release all the locks in the order in which they were grabbed.
	 */
	mutex_exit(&tx->r_lock);
	rw_exit(&bfe->bfe_rwlock);
}


/*
 * It's used to make sure that the write to device register was successful.
 */
static int
bfe_wait_bit(bfe_t *bfe, uint32_t reg, uint32_t bit,
    ulong_t t, const int clear)
{
	ulong_t i;
	uint32_t v;

	for (i = 0; i < t; i++) {
		v = INL(bfe, reg);

		if (clear && !(v & bit))
			break;

		if (!clear && (v & bit))
			break;

		drv_usecwait(10);
	}

	/* if device still didn't see the value */
	if (i == t)
		return (-1);

	return (0);
}

/*
 * PHY functions (read, write, stop, reset and startup)
 */
static int
bfe_read_phy(bfe_t *bfe, uint32_t reg)
{
	OUTL(bfe, BFE_EMAC_ISTAT, BFE_EMAC_INT_MII);
	OUTL(bfe, BFE_MDIO_DATA, (BFE_MDIO_SB_START |
	    (BFE_MDIO_OP_READ << BFE_MDIO_OP_SHIFT) |
	    (bfe->bfe_phy_addr << BFE_MDIO_PMD_SHIFT) |
	    (reg << BFE_MDIO_RA_SHIFT) |
	    (BFE_MDIO_TA_VALID << BFE_MDIO_TA_SHIFT)));

	(void) bfe_wait_bit(bfe, BFE_EMAC_ISTAT, BFE_EMAC_INT_MII, 10, 0);

	return ((INL(bfe, BFE_MDIO_DATA) & BFE_MDIO_DATA_DATA));
}

static void
bfe_write_phy(bfe_t *bfe, uint32_t reg, uint32_t val)
{
	OUTL(bfe, BFE_EMAC_ISTAT, BFE_EMAC_INT_MII);
	OUTL(bfe,  BFE_MDIO_DATA, (BFE_MDIO_SB_START |
	    (BFE_MDIO_OP_WRITE << BFE_MDIO_OP_SHIFT) |
	    (bfe->bfe_phy_addr << BFE_MDIO_PMD_SHIFT) |
	    (reg << BFE_MDIO_RA_SHIFT) |
	    (BFE_MDIO_TA_VALID << BFE_MDIO_TA_SHIFT) |
	    (val & BFE_MDIO_DATA_DATA)));

	(void) bfe_wait_bit(bfe, BFE_EMAC_ISTAT, BFE_EMAC_INT_MII, 10, 0);
}

/*
 * It resets the PHY layer.
 */
static int
bfe_reset_phy(bfe_t *bfe)
{
	uint32_t i;

	bfe_write_phy(bfe, MII_CONTROL, MII_CONTROL_RESET);
	drv_usecwait(100);
	for (i = 0; i < 10; i++) {
		if (bfe_read_phy(bfe, MII_CONTROL) &
		    MII_CONTROL_RESET) {
			drv_usecwait(500);
			continue;
		}

		break;
	}

	if (i == 10) {
		bfe_error(bfe->bfe_dip, "Timeout waiting for PHY to reset");
		bfe->bfe_phy_state = BFE_PHY_RESET_TIMEOUT;
		return (BFE_FAILURE);
	}

	bfe->bfe_phy_state = BFE_PHY_RESET_DONE;

	return (BFE_SUCCESS);
}

/*
 * Make sure timer function is out of our way and especially during
 * detach.
 */
static void
bfe_stop_timer(bfe_t *bfe)
{
	if (bfe->bfe_periodic_id) {
		ddi_periodic_delete(bfe->bfe_periodic_id);
		bfe->bfe_periodic_id = NULL;
	}
}

/*
 * Stops the PHY
 */
static void
bfe_stop_phy(bfe_t *bfe)
{
	bfe_write_phy(bfe, MII_CONTROL, MII_CONTROL_PWRDN |
	    MII_CONTROL_ISOLATE);

	bfe->bfe_chip.link = LINK_STATE_UNKNOWN;
	bfe->bfe_chip.speed = 0;
	bfe->bfe_chip.duplex = LINK_DUPLEX_UNKNOWN;

	bfe->bfe_phy_state = BFE_PHY_STOPPED;

	/*
	 * Report the link status to MAC layer.
	 */
	if (bfe->bfe_machdl != NULL)
		(void) bfe_report_link(bfe);
}

static int
bfe_probe_phy(bfe_t *bfe)
{
	int phy;
	uint32_t status;

	if (bfe->bfe_phy_addr) {
		status = bfe_read_phy(bfe, MII_STATUS);
		if (status != 0xffff && status != 0) {
			bfe_write_phy(bfe, MII_CONTROL, 0);
			return (BFE_SUCCESS);
		}
	}

	for (phy = 0; phy < 32; phy++) {
		bfe->bfe_phy_addr = phy;
		status = bfe_read_phy(bfe, MII_STATUS);
		if (status != 0xffff && status != 0) {
			bfe_write_phy(bfe, MII_CONTROL, 0);
			return (BFE_SUCCESS);
		}
	}

	return (BFE_FAILURE);
}

/*
 * This timeout function fires at BFE_TIMEOUT_INTERVAL to check the link
 * status.
 */
static void
bfe_timeout(void *arg)
{
	bfe_t *bfe = (bfe_t *)arg;
	int resched = 0;

	/*
	 * We don't grab any lock because bfe can't go away.
	 * untimeout() will wait for this timeout instance to complete.
	 */
	if (bfe->bfe_chip_action & BFE_ACTION_RESTART) {
		/*
		 * Restart the chip.
		 */
		bfe_grab_locks(bfe);
		bfe_chip_restart(bfe);
		bfe->bfe_chip_action &= ~BFE_ACTION_RESTART;
		bfe->bfe_chip_action &= ~BFE_ACTION_RESTART_FAULT;
		bfe->bfe_chip_action &= ~BFE_ACTION_RESTART_PKT;
		bfe_release_locks(bfe);
		mac_tx_update(bfe->bfe_machdl);
		/* Restart will register a new timeout */
		return;
	}

	rw_enter(&bfe->bfe_rwlock, RW_READER);

	if (bfe->bfe_chip_state == BFE_CHIP_ACTIVE) {
		hrtime_t hr;

		hr = gethrtime();
		if (bfe->bfe_tx_stall_time != 0 &&
		    hr > bfe->bfe_tx_stall_time) {
			DTRACE_PROBE2(chip__restart, int, bfe->bfe_unit,
			    char *, "pkt timeout");
			bfe->bfe_chip_action |=
			    (BFE_ACTION_RESTART | BFE_ACTION_RESTART_PKT);
			bfe->bfe_tx_stall_time = 0;
		}
	}

	if (bfe->bfe_phy_state == BFE_PHY_STARTED) {
		/*
		 * Report the link status to MAC layer if link status changed.
		 */
		if (bfe_check_link(bfe)) {
			bfe_report_link(bfe);
			if (bfe->bfe_chip.link == LINK_STATE_UP) {
				uint32_t val, flow;

				val = INL(bfe, BFE_TX_CTRL);
				val &= ~BFE_TX_DUPLEX;
				if (bfe->bfe_chip.duplex == LINK_DUPLEX_FULL) {
					val |= BFE_TX_DUPLEX;
					flow = INL(bfe, BFE_RXCONF);
					flow &= ~BFE_RXCONF_FLOW;
					OUTL(bfe, BFE_RXCONF, flow);

					flow = INL(bfe, BFE_MAC_FLOW);
					flow &= ~(BFE_FLOW_RX_HIWAT);
					OUTL(bfe, BFE_MAC_FLOW, flow);
				}

				resched = 1;

				OUTL(bfe, BFE_TX_CTRL, val);
				DTRACE_PROBE1(link__up,
				    int, bfe->bfe_unit);
			}
		}
	}

	rw_exit(&bfe->bfe_rwlock);

	if (resched)
		mac_tx_update(bfe->bfe_machdl);
}

/*
 * Starts PHY layer.
 */
static int
bfe_startup_phy(bfe_t *bfe)
{
	uint16_t bmsr, bmcr, anar;
	int	prog, s;
	int phyid1, phyid2;

	if (bfe_probe_phy(bfe) == BFE_FAILURE) {
		bfe->bfe_phy_state = BFE_PHY_NOTFOUND;
		return (BFE_FAILURE);
	}

	(void) bfe_reset_phy(bfe);

	phyid1 = bfe_read_phy(bfe, MII_PHYIDH);
	phyid2 = bfe_read_phy(bfe, MII_PHYIDL);
	bfe->bfe_phy_id = (phyid1 << 16) | phyid2;

	bmsr = bfe_read_phy(bfe, MII_STATUS);
	anar = bfe_read_phy(bfe, MII_AN_ADVERT);

again:
	anar &= ~(MII_ABILITY_100BASE_T4 |
	    MII_ABILITY_100BASE_TX_FD | MII_ABILITY_100BASE_TX |
	    MII_ABILITY_10BASE_T_FD | MII_ABILITY_10BASE_T);

	/*
	 * Supported hardware modes are in bmsr.
	 */
	bfe->bfe_chip.bmsr = bmsr;

	/*
	 * Assume no capabilities are supported in the hardware.
	 */
	bfe->bfe_cap_aneg = bfe->bfe_cap_100T4 =
	    bfe->bfe_cap_100fdx = bfe->bfe_cap_100hdx =
	    bfe->bfe_cap_10fdx = bfe->bfe_cap_10hdx = 0;

	/*
	 * Assume property is set.
	 */
	s = 1;
	if (!(bfe->bfe_chip_action & BFE_ACTION_RESTART_SETPROP)) {
		/*
		 * Property is not set which means bfe_mac_setprop()
		 * is not called on us.
		 */
		s = 0;
	}

	bmcr = prog = 0;

	if (bmsr & MII_STATUS_100_BASEX_FD) {
		bfe->bfe_cap_100fdx = 1;
		if (s == 0) {
			anar |= MII_ABILITY_100BASE_TX_FD;
			bfe->bfe_adv_100fdx = 1;
			prog++;
		} else if (bfe->bfe_adv_100fdx) {
			anar |= MII_ABILITY_100BASE_TX_FD;
			prog++;
		}
	}

	if (bmsr & MII_STATUS_100_BASE_T4) {
		bfe->bfe_cap_100T4 = 1;
		if (s == 0) {
			anar |= MII_ABILITY_100BASE_T4;
			bfe->bfe_adv_100T4 = 1;
			prog++;
		} else if (bfe->bfe_adv_100T4) {
			anar |= MII_ABILITY_100BASE_T4;
			prog++;
		}
	}

	if (bmsr & MII_STATUS_100_BASEX) {
		bfe->bfe_cap_100hdx = 1;
		if (s == 0) {
			anar |= MII_ABILITY_100BASE_TX;
			bfe->bfe_adv_100hdx = 1;
			prog++;
		} else if (bfe->bfe_adv_100hdx) {
			anar |= MII_ABILITY_100BASE_TX;
			prog++;
		}
	}

	if (bmsr & MII_STATUS_10_FD) {
		bfe->bfe_cap_10fdx = 1;
		if (s == 0) {
			anar |= MII_ABILITY_10BASE_T_FD;
			bfe->bfe_adv_10fdx = 1;
			prog++;
		} else if (bfe->bfe_adv_10fdx) {
			anar |= MII_ABILITY_10BASE_T_FD;
			prog++;
		}
	}

	if (bmsr & MII_STATUS_10) {
		bfe->bfe_cap_10hdx = 1;
		if (s == 0) {
			anar |= MII_ABILITY_10BASE_T;
			bfe->bfe_adv_10hdx = 1;
			prog++;
		} else if (bfe->bfe_adv_10hdx) {
			anar |= MII_ABILITY_10BASE_T;
			prog++;
		}
	}

	if (bmsr & MII_STATUS_CANAUTONEG) {
		bfe->bfe_cap_aneg = 1;
		if (s == 0) {
			bfe->bfe_adv_aneg = 1;
		}
	}

	if (prog == 0) {
		if (s == 0) {
			bfe_error(bfe->bfe_dip,
			    "No valid link mode selected. Powering down PHY");
			bfe_stop_phy(bfe);
			bfe_report_link(bfe);
			return (BFE_FAILURE);
		}

		/*
		 * If property is set then user would have goofed up. So we
		 * go back to default properties.
		 */
		bfe->bfe_chip_action &= ~BFE_ACTION_RESTART_SETPROP;
		goto again;
	}

	if (bfe->bfe_adv_aneg && (bmsr & MII_STATUS_CANAUTONEG)) {
		bmcr = (MII_CONTROL_ANE | MII_CONTROL_RSAN);
	} else {
		if (bfe->bfe_adv_100fdx)
			bmcr = (MII_CONTROL_100MB | MII_CONTROL_FDUPLEX);
		else if (bfe->bfe_adv_100hdx)
			bmcr = MII_CONTROL_100MB;
		else if (bfe->bfe_adv_10fdx)
			bmcr = MII_CONTROL_FDUPLEX;
		else
			bmcr = 0;		/* 10HDX */
	}

	if (prog)
		bfe_write_phy(bfe, MII_AN_ADVERT, anar);

	if (bmcr)
		bfe_write_phy(bfe, MII_CONTROL, bmcr);

	bfe->bfe_mii_anar = anar;
	bfe->bfe_mii_bmcr = bmcr;
	bfe->bfe_phy_state = BFE_PHY_STARTED;

	if (bfe->bfe_periodic_id == NULL) {
		bfe->bfe_periodic_id = ddi_periodic_add(bfe_timeout,
		    (void *)bfe, BFE_TIMEOUT_INTERVAL, DDI_IPL_0);

		DTRACE_PROBE1(first__timeout, int, bfe->bfe_unit);
	}

	DTRACE_PROBE4(phy_started, int, bfe->bfe_unit,
	    int, bmsr, int, bmcr, int, anar);

	return (BFE_SUCCESS);
}

/*
 * Reports link status back to MAC Layer.
 */
static void
bfe_report_link(bfe_t *bfe)
{
	mac_link_update(bfe->bfe_machdl, bfe->bfe_chip.link);
}

/*
 * Reads PHY/MII registers and get the link status for us.
 */
static int
bfe_check_link(bfe_t *bfe)
{
	uint16_t bmsr, bmcr, anar, anlpar;
	int speed, duplex, link;

	speed = bfe->bfe_chip.speed;
	duplex = bfe->bfe_chip.duplex;
	link = bfe->bfe_chip.link;

	bmsr = bfe_read_phy(bfe, MII_STATUS);
	bfe->bfe_mii_bmsr = bmsr;

	bmcr = bfe_read_phy(bfe, MII_CONTROL);

	anar = bfe_read_phy(bfe, MII_AN_ADVERT);
	bfe->bfe_mii_anar = anar;

	anlpar = bfe_read_phy(bfe, MII_AN_LPABLE);
	bfe->bfe_mii_anlpar = anlpar;

	bfe->bfe_mii_exp = bfe_read_phy(bfe, MII_AN_EXPANSION);

	/*
	 * If exp register is not present in PHY.
	 */
	if (bfe->bfe_mii_exp == 0xffff) {
		bfe->bfe_mii_exp = 0;
	}

	if ((bmsr & MII_STATUS_LINKUP) == 0) {
		bfe->bfe_chip.link = LINK_STATE_DOWN;
		bfe->bfe_chip.speed = 0;
		bfe->bfe_chip.duplex = LINK_DUPLEX_UNKNOWN;
		goto done;
	}

	bfe->bfe_chip.link = LINK_STATE_UP;

	if (!(bmcr & MII_CONTROL_ANE)) {
		/* Forced mode */
		if (bmcr & MII_CONTROL_100MB)
			bfe->bfe_chip.speed = 100000000;
		else
			bfe->bfe_chip.speed = 10000000;

		if (bmcr & MII_CONTROL_FDUPLEX)
			bfe->bfe_chip.duplex = LINK_DUPLEX_FULL;
		else
			bfe->bfe_chip.duplex = LINK_DUPLEX_HALF;

	} else if ((!(bmsr & MII_STATUS_CANAUTONEG)) ||
	    (!(bmsr & MII_STATUS_ANDONE))) {
		bfe->bfe_chip.speed = 0;
		bfe->bfe_chip.duplex = LINK_DUPLEX_UNKNOWN;
	} else if (anar & anlpar & MII_ABILITY_100BASE_TX_FD) {
		bfe->bfe_chip.speed = 100000000;
		bfe->bfe_chip.duplex = LINK_DUPLEX_FULL;
	} else if (anar & anlpar & MII_ABILITY_100BASE_T4) {
		bfe->bfe_chip.speed = 100000000;
		bfe->bfe_chip.duplex = LINK_DUPLEX_HALF;
	} else if (anar & anlpar & MII_ABILITY_100BASE_TX) {
		bfe->bfe_chip.speed = 100000000;
		bfe->bfe_chip.duplex = LINK_DUPLEX_HALF;
	} else if (anar & anlpar & MII_ABILITY_10BASE_T_FD) {
		bfe->bfe_chip.speed = 10000000;
		bfe->bfe_chip.duplex = LINK_DUPLEX_FULL;
	} else if (anar & anlpar & MII_ABILITY_10BASE_T) {
		bfe->bfe_chip.speed = 10000000;
		bfe->bfe_chip.duplex = LINK_DUPLEX_HALF;
	} else {
		bfe->bfe_chip.speed = 0;
		bfe->bfe_chip.duplex = LINK_DUPLEX_UNKNOWN;
	}

done:
	/*
	 * If speed or link status or duplex mode changed then report to
	 * MAC layer which is done by the caller.
	 */
	if (speed != bfe->bfe_chip.speed ||
	    duplex != bfe->bfe_chip.duplex ||
	    link != bfe->bfe_chip.link) {
		return (1);
	}

	return (0);
}

static void
bfe_cam_write(bfe_t *bfe, uchar_t *d, int index)
{
	uint32_t v;

	v = ((uint32_t)d[2] << 24);
	v |= ((uint32_t)d[3] << 16);
	v |= ((uint32_t)d[4] << 8);
	v |= (uint32_t)d[5];

	OUTL(bfe, BFE_CAM_DATA_LO, v);
	v = (BFE_CAM_HI_VALID |
	    (((uint32_t)d[0]) << 8) |
	    (((uint32_t)d[1])));

	OUTL(bfe, BFE_CAM_DATA_HI, v);
	OUTL(bfe, BFE_CAM_CTRL, (BFE_CAM_WRITE |
	    ((uint32_t)index << BFE_CAM_INDEX_SHIFT)));
	(void) bfe_wait_bit(bfe, BFE_CAM_CTRL, BFE_CAM_BUSY, 10, 1);
}

/*
 * Chip related functions (halt, reset, start).
 */
static void
bfe_chip_halt(bfe_t *bfe)
{
	/*
	 * Disables interrupts.
	 */
	OUTL(bfe, BFE_INTR_MASK, 0);
	FLUSH(bfe, BFE_INTR_MASK);

	OUTL(bfe,  BFE_ENET_CTRL, BFE_ENET_DISABLE);

	/*
	 * Wait until TX and RX finish their job.
	 */
	(void) bfe_wait_bit(bfe, BFE_ENET_CTRL, BFE_ENET_DISABLE, 20, 1);

	/*
	 * Disables DMA engine.
	 */
	OUTL(bfe, BFE_DMARX_CTRL, 0);
	OUTL(bfe, BFE_DMATX_CTRL, 0);

	drv_usecwait(10);

	bfe->bfe_chip_state = BFE_CHIP_HALT;
}

static void
bfe_chip_restart(bfe_t *bfe)
{
	DTRACE_PROBE2(chip__restart, int, bfe->bfe_unit,
	    int, bfe->bfe_chip_action);

	/*
	 * Halt chip and PHY.
	 */
	bfe_chip_halt(bfe);
	bfe_stop_phy(bfe);
	bfe->bfe_chip_state = BFE_CHIP_STOPPED;

	/*
	 * Init variables.
	 */
	bfe_init_vars(bfe);

	/*
	 * Reset chip and start PHY.
	 */
	bfe_chip_reset(bfe);

	/*
	 * DMA descriptor rings.
	 */
	bfe_tx_desc_init(&bfe->bfe_tx_ring);
	bfe_rx_desc_init(&bfe->bfe_rx_ring);

	bfe->bfe_chip_state = BFE_CHIP_ACTIVE;
	bfe_set_rx_mode(bfe);
	bfe_enable_chip_intrs(bfe);
}

/*
 * Disables core by stopping the clock.
 */
static void
bfe_core_disable(bfe_t *bfe)
{
	if ((INL(bfe, BFE_SBTMSLOW) & BFE_RESET))
		return;

	OUTL(bfe, BFE_SBTMSLOW, (BFE_REJECT | BFE_CLOCK));
	(void) bfe_wait_bit(bfe, BFE_SBTMSLOW, BFE_REJECT, 100, 0);
	(void) bfe_wait_bit(bfe, BFE_SBTMSHIGH, BFE_BUSY, 100, 1);
	OUTL(bfe, BFE_SBTMSLOW, (BFE_FGC | BFE_CLOCK | BFE_REJECT | BFE_RESET));
	FLUSH(bfe, BFE_SBTMSLOW);
	drv_usecwait(10);
	OUTL(bfe, BFE_SBTMSLOW, (BFE_REJECT | BFE_RESET));
	drv_usecwait(10);
}

/*
 * Resets core.
 */
static void
bfe_core_reset(bfe_t *bfe)
{
	uint32_t val;

	/*
	 * First disable the core.
	 */
	bfe_core_disable(bfe);

	OUTL(bfe, BFE_SBTMSLOW, (BFE_RESET | BFE_CLOCK | BFE_FGC));
	FLUSH(bfe, BFE_SBTMSLOW);
	drv_usecwait(1);

	if (INL(bfe, BFE_SBTMSHIGH) & BFE_SERR)
		OUTL(bfe, BFE_SBTMSHIGH, 0);

	val = INL(bfe, BFE_SBIMSTATE);
	if (val & (BFE_IBE | BFE_TO))
		OUTL(bfe, BFE_SBIMSTATE, val & ~(BFE_IBE | BFE_TO));

	OUTL(bfe, BFE_SBTMSLOW, (BFE_CLOCK | BFE_FGC));
	FLUSH(bfe, BFE_SBTMSLOW);
	drv_usecwait(1);

	OUTL(bfe, BFE_SBTMSLOW, BFE_CLOCK);
	FLUSH(bfe, BFE_SBTMSLOW);
	drv_usecwait(1);
}

static void
bfe_setup_config(bfe_t *bfe, uint32_t cores)
{
	uint32_t bar_orig, val;

	/*
	 * Change bar0 window to map sbtopci registers.
	 */
	bar_orig = pci_config_get32(bfe->bfe_conf_handle, BFE_BAR0_WIN);
	pci_config_put32(bfe->bfe_conf_handle, BFE_BAR0_WIN, BFE_REG_PCI);

	/* Just read it and don't do anything */
	val = INL(bfe, BFE_SBIDHIGH) & BFE_IDH_CORE;

	val = INL(bfe, BFE_SBINTVEC);
	val |= cores;
	OUTL(bfe, BFE_SBINTVEC, val);

	val = INL(bfe, BFE_SSB_PCI_TRANS_2);
	val |= BFE_SSB_PCI_PREF | BFE_SSB_PCI_BURST;
	OUTL(bfe, BFE_SSB_PCI_TRANS_2, val);

	/*
	 * Restore bar0 window mapping.
	 */
	pci_config_put32(bfe->bfe_conf_handle, BFE_BAR0_WIN, bar_orig);
}

/*
 * Resets chip and starts PHY.
 */
static void
bfe_chip_reset(bfe_t *bfe)
{
	uint32_t val;

	/* Set the interrupt vector for the enet core */
	bfe_setup_config(bfe, BFE_INTVEC_ENET0);

	/* check if core is up */
	val = INL(bfe, BFE_SBTMSLOW) &
	    (BFE_RESET | BFE_REJECT | BFE_CLOCK);

	if (val == BFE_CLOCK) {
		OUTL(bfe, BFE_RCV_LAZY, 0);
		OUTL(bfe, BFE_ENET_CTRL, BFE_ENET_DISABLE);
		(void) bfe_wait_bit(bfe, BFE_ENET_CTRL,
		    BFE_ENET_DISABLE, 10, 1);
		OUTL(bfe, BFE_DMATX_CTRL, 0);
		FLUSH(bfe, BFE_DMARX_STAT);
		drv_usecwait(20000);	/* 20 milli seconds */
		if (INL(bfe, BFE_DMARX_STAT) & BFE_STAT_EMASK) {
			(void) bfe_wait_bit(bfe, BFE_DMARX_STAT, BFE_STAT_SIDLE,
			    10, 0);
		}
		OUTL(bfe, BFE_DMARX_CTRL, 0);
	}

	bfe_core_reset(bfe);
	bfe_clear_stats(bfe);

	OUTL(bfe, BFE_MDIO_CTRL, 0x8d);
	val = INL(bfe, BFE_DEVCTRL);
	if (!(val & BFE_IPP))
		OUTL(bfe, BFE_ENET_CTRL, BFE_ENET_EPSEL);
	else if (INL(bfe, BFE_DEVCTRL & BFE_EPR)) {
		OUTL_AND(bfe, BFE_DEVCTRL, ~BFE_EPR);
		drv_usecwait(20000);    /* 20 milli seconds */
	}

	OUTL_OR(bfe, BFE_MAC_CTRL, BFE_CTRL_CRC32_ENAB | BFE_CTRL_LED);

	OUTL_AND(bfe, BFE_MAC_CTRL, ~BFE_CTRL_PDOWN);

	OUTL(bfe, BFE_RCV_LAZY, ((1 << BFE_LAZY_FC_SHIFT) &
	    BFE_LAZY_FC_MASK));

	OUTL_OR(bfe, BFE_RCV_LAZY, 0);

	OUTL(bfe, BFE_RXMAXLEN, bfe->bfe_rx_ring.r_buf_len);
	OUTL(bfe, BFE_TXMAXLEN, bfe->bfe_tx_ring.r_buf_len);

	OUTL(bfe, BFE_TX_WMARK, 56);

	/* Program DMA channels */
	OUTL(bfe, BFE_DMATX_CTRL, BFE_TX_CTRL_ENABLE);

	/*
	 * DMA addresses need to be added to BFE_PCI_DMA
	 */
	OUTL(bfe, BFE_DMATX_ADDR,
	    bfe->bfe_tx_ring.r_desc_cookie.dmac_laddress + BFE_PCI_DMA);

	OUTL(bfe, BFE_DMARX_CTRL, (BFE_RX_OFFSET << BFE_RX_CTRL_ROSHIFT)
	    | BFE_RX_CTRL_ENABLE);

	OUTL(bfe, BFE_DMARX_ADDR,
	    bfe->bfe_rx_ring.r_desc_cookie.dmac_laddress + BFE_PCI_DMA);

	(void) bfe_startup_phy(bfe);

	bfe->bfe_chip_state = BFE_CHIP_INITIALIZED;
}

/*
 * It enables interrupts. Should be the last step while starting chip.
 */
static void
bfe_enable_chip_intrs(bfe_t *bfe)
{
	/* Enable the chip and core */
	OUTL(bfe, BFE_ENET_CTRL, BFE_ENET_ENABLE);

	/* Enable interrupts */
	OUTL(bfe, BFE_INTR_MASK, BFE_IMASK_DEF);
}

/*
 * Common code to take care of setting RX side mode (filter).
 */
static void
bfe_set_rx_mode(bfe_t *bfe)
{
	uint32_t val;
	int i;
	ether_addr_t mac[ETHERADDRL] = {0, 0, 0, 0, 0, 0};

	/*
	 * We don't touch RX filter if we were asked to suspend. It's fine
	 * if chip is not active (no interface is plumbed on us).
	 */
	if (bfe->bfe_chip_state == BFE_CHIP_SUSPENDED)
		return;

	val = INL(bfe, BFE_RXCONF);

	val &= ~BFE_RXCONF_PROMISC;
	val &= ~BFE_RXCONF_DBCAST;

	if ((bfe->bfe_chip_mode & BFE_RX_MODE_ENABLE) == 0) {
		OUTL(bfe, BFE_CAM_CTRL, 0);
		FLUSH(bfe, BFE_CAM_CTRL);
	} else if (bfe->bfe_chip_mode & BFE_RX_MODE_PROMISC) {
		val |= BFE_RXCONF_PROMISC;
		val &= ~BFE_RXCONF_DBCAST;
	} else {
		if (bfe->bfe_chip_state == BFE_CHIP_ACTIVE) {
			/* Flush everything */
			OUTL(bfe, BFE_RXCONF, val |
			    BFE_RXCONF_PROMISC | BFE_RXCONF_ALLMULTI);
			FLUSH(bfe, BFE_RXCONF);
		}

		/* Disable CAM */
		OUTL(bfe, BFE_CAM_CTRL, 0);
		FLUSH(bfe, BFE_CAM_CTRL);

		/*
		 * We receive all multicast packets.
		 */
		val |= BFE_RXCONF_ALLMULTI;

		for (i = 0; i < BFE_MAX_MULTICAST_TABLE - 1; i++) {
			bfe_cam_write(bfe, (uchar_t *)mac, i);
		}

		bfe_cam_write(bfe, bfe->bfe_ether_addr, i);

		/* Enable CAM */
		OUTL_OR(bfe, BFE_CAM_CTRL, BFE_CAM_ENABLE);
		FLUSH(bfe, BFE_CAM_CTRL);
	}

	DTRACE_PROBE2(rx__mode__filter, int, bfe->bfe_unit,
	    int, val);

	OUTL(bfe, BFE_RXCONF, val);
	FLUSH(bfe, BFE_RXCONF);
}

/*
 * Reset various variable values to initial state.
 */
static void
bfe_init_vars(bfe_t *bfe)
{
	bfe->bfe_chip_mode = BFE_RX_MODE_ENABLE;

	/* Initial assumption */
	bfe->bfe_chip.link = LINK_STATE_UNKNOWN;
	bfe->bfe_chip.speed = 0;
	bfe->bfe_chip.duplex = LINK_DUPLEX_UNKNOWN;

	bfe->bfe_periodic_id = NULL;
	bfe->bfe_chip_state = BFE_CHIP_UNINITIALIZED;

	bfe->bfe_tx_stall_time = 0;
}

/*
 * Initializes TX side descriptor entries (bfe_desc_t). Each descriptor entry
 * has control (desc_ctl) and address (desc_addr) member.
 */
static void
bfe_tx_desc_init(bfe_ring_t *r)
{
	int i;
	uint32_t v;

	for (i = 0; i < r->r_ndesc; i++) {
		PUT_DESC(r, (uint32_t *)&(r->r_desc[i].desc_ctl),
		    (r->r_buf_dma[i].len & BFE_DESC_LEN));

		/*
		 * DMA addresses need to be added to BFE_PCI_DMA
		 */
		PUT_DESC(r, (uint32_t *)&(r->r_desc[i].desc_addr),
		    (r->r_buf_dma[i].cookie.dmac_laddress + BFE_PCI_DMA));
	}

	v = GET_DESC(r, (uint32_t *)&(r->r_desc[i - 1].desc_ctl));
	PUT_DESC(r, (uint32_t *)&(r->r_desc[i - 1].desc_ctl),
	    v | BFE_DESC_EOT);

	(void) SYNC_DESC(r, 0, r->r_ndesc, DDI_DMA_SYNC_FORDEV);

	r->r_curr_desc = 0;
	r->r_avail_desc = TX_NUM_DESC;
	r->r_cons_desc = 0;
}

/*
 * Initializes RX side descriptor entries (bfe_desc_t). Each descriptor entry
 * has control (desc_ctl) and address (desc_addr) member.
 */
static void
bfe_rx_desc_init(bfe_ring_t *r)
{
	int i;
	uint32_t v;

	for (i = 0; i < r->r_ndesc; i++) {
		PUT_DESC(r, (uint32_t *)&(r->r_desc[i].desc_ctl),
		    (r->r_buf_dma[i].len& BFE_DESC_LEN));

		PUT_DESC(r, (uint32_t *)&(r->r_desc[i].desc_addr),
		    (r->r_buf_dma[i].cookie.dmac_laddress + BFE_PCI_DMA));

		/* Initialize rx header (len, flags) */
		bzero(r->r_buf_dma[i].addr, sizeof (bfe_rx_header_t));

		(void) SYNC_BUF(r, i, 0, sizeof (bfe_rx_header_t),
		    DDI_DMA_SYNC_FORDEV);
	}

	v = GET_DESC(r, (uint32_t *)&(r->r_desc[i - 1].desc_ctl));
	PUT_DESC(r, (uint32_t *)&(r->r_desc[i - 1].desc_ctl),
	    v | BFE_DESC_EOT);

	(void) SYNC_DESC(r, 0, r->r_ndesc, DDI_DMA_SYNC_FORDEV);

	/* TAIL of RX Descriptor */
	OUTL(r->r_bfe, BFE_DMARX_PTR, ((i) * sizeof (bfe_desc_t)));

	r->r_curr_desc = 0;
	r->r_avail_desc = RX_NUM_DESC;
}

static int
bfe_chip_start(bfe_t *bfe)
{
	ASSERT_ALL_LOCKS(bfe);

	/*
	 * Stop the chip first & then Reset the chip. At last enable interrupts.
	 */
	bfe_chip_halt(bfe);
	bfe_stop_phy(bfe);

	/*
	 * Reset chip and start PHY.
	 */
	bfe_chip_reset(bfe);

	/*
	 * Initailize Descriptor Rings.
	 */
	bfe_tx_desc_init(&bfe->bfe_tx_ring);
	bfe_rx_desc_init(&bfe->bfe_rx_ring);

	bfe->bfe_chip_state = BFE_CHIP_ACTIVE;
	bfe->bfe_chip_mode |= BFE_RX_MODE_ENABLE;
	bfe_set_rx_mode(bfe);
	bfe_enable_chip_intrs(bfe);

	/* Check link, speed and duplex mode */
	(void) bfe_check_link(bfe);

	return (DDI_SUCCESS);
}


/*
 * Clear chip statistics.
 */
static void
bfe_clear_stats(bfe_t *bfe)
{
	ulong_t r;

	OUTL(bfe, BFE_MIB_CTRL, BFE_MIB_CLR_ON_READ);

	/*
	 * Stat registers are cleared by reading.
	 */
	for (r = BFE_TX_GOOD_O; r <= BFE_TX_PAUSE; r += 4)
		(void) INL(bfe, r);

	for (r = BFE_RX_GOOD_O; r <= BFE_RX_NPAUSE; r += 4)
		(void) INL(bfe, r);
}

/*
 * Collect chip statistics.
 */
static void
bfe_gather_stats(bfe_t *bfe)
{
	ulong_t r;
	uint32_t *v;
	uint32_t txerr = 0, rxerr = 0, coll = 0;

	v = &bfe->bfe_hw_stats.tx_good_octets;
	for (r = BFE_TX_GOOD_O; r <= BFE_TX_PAUSE; r += 4) {
		*v += INL(bfe, r);
		v++;
	}

	v = &bfe->bfe_hw_stats.rx_good_octets;
	for (r = BFE_RX_GOOD_O; r <= BFE_RX_NPAUSE; r += 4) {
		*v += INL(bfe, r);
		v++;
	}

	/*
	 * TX :
	 * -------
	 * tx_good_octets, tx_good_pkts, tx_octets
	 * tx_pkts, tx_broadcast_pkts, tx_multicast_pkts
	 * tx_len_64, tx_len_65_to_127, tx_len_128_to_255
	 * tx_len_256_to_511, tx_len_512_to_1023, tx_len_1024_to_max
	 * tx_jabber_pkts, tx_oversize_pkts, tx_fragment_pkts
	 * tx_underruns, tx_total_cols, tx_single_cols
	 * tx_multiple_cols, tx_excessive_cols, tx_late_cols
	 * tx_defered, tx_carrier_lost, tx_pause_pkts
	 *
	 * RX :
	 * -------
	 * rx_good_octets, rx_good_pkts, rx_octets
	 * rx_pkts, rx_broadcast_pkts, rx_multicast_pkts
	 * rx_len_64, rx_len_65_to_127, rx_len_128_to_255
	 * rx_len_256_to_511, rx_len_512_to_1023, rx_len_1024_to_max
	 * rx_jabber_pkts, rx_oversize_pkts, rx_fragment_pkts
	 * rx_missed_pkts, rx_crc_align_errs, rx_undersize
	 * rx_crc_errs, rx_align_errs, rx_symbol_errs
	 * rx_pause_pkts, rx_nonpause_pkts
	 */

	bfe->bfe_stats.ether_stat_carrier_errors =
	    bfe->bfe_hw_stats.tx_carrier_lost;

	/* txerr += bfe->bfe_hw_stats.tx_carrier_lost; */

	bfe->bfe_stats.ether_stat_ex_collisions =
	    bfe->bfe_hw_stats.tx_excessive_cols;
	txerr += bfe->bfe_hw_stats.tx_excessive_cols;
	coll += bfe->bfe_hw_stats.tx_excessive_cols;

	bfe->bfe_stats.ether_stat_fcs_errors =
	    bfe->bfe_hw_stats.rx_crc_errs;
	rxerr += bfe->bfe_hw_stats.rx_crc_errs;

	bfe->bfe_stats.ether_stat_first_collisions =
	    bfe->bfe_hw_stats.tx_single_cols;
	coll += bfe->bfe_hw_stats.tx_single_cols;
	bfe->bfe_stats.ether_stat_multi_collisions =
	    bfe->bfe_hw_stats.tx_multiple_cols;
	coll += bfe->bfe_hw_stats.tx_multiple_cols;

	bfe->bfe_stats.ether_stat_toolong_errors =
	    bfe->bfe_hw_stats.rx_oversize_pkts;
	rxerr += bfe->bfe_hw_stats.rx_oversize_pkts;

	bfe->bfe_stats.ether_stat_tooshort_errors =
	    bfe->bfe_hw_stats.rx_undersize;
	rxerr += bfe->bfe_hw_stats.rx_undersize;

	bfe->bfe_stats.ether_stat_tx_late_collisions +=
	    bfe->bfe_hw_stats.tx_late_cols;

	bfe->bfe_stats.ether_stat_defer_xmts +=
	    bfe->bfe_hw_stats.tx_defered;

	bfe->bfe_stats.ether_stat_macrcv_errors += rxerr;
	bfe->bfe_stats.ether_stat_macxmt_errors += txerr;

	bfe->bfe_stats.collisions += coll;
}

/*
 * Gets the state for dladm command and all.
 */
int
bfe_mac_getstat(void *arg, uint_t stat, uint64_t *val)
{
	bfe_t *bfe = (bfe_t *)arg;
	uint64_t	v;
	int err = 0;

	rw_enter(&bfe->bfe_rwlock, RW_READER);


	switch (stat) {
	default:
		err = ENOTSUP;
		break;

	case MAC_STAT_IFSPEED:
		/*
		 * MAC layer will ask for IFSPEED first and hence we
		 * collect it only once.
		 */
		if (bfe->bfe_chip_state == BFE_CHIP_ACTIVE) {
			/*
			 * Update stats from the hardware.
			 */
			bfe_gather_stats(bfe);
		}
		v = bfe->bfe_chip.speed;
		break;

	case ETHER_STAT_ADV_CAP_100T4:
		v = bfe->bfe_adv_100T4;
		break;

	case ETHER_STAT_ADV_CAP_100FDX:
		v = (bfe->bfe_mii_anar & MII_ABILITY_100BASE_TX_FD) != 0;
		break;

	case ETHER_STAT_ADV_CAP_100HDX:
		v = (bfe->bfe_mii_anar & MII_ABILITY_100BASE_TX) != 0;
		break;

	case ETHER_STAT_ADV_CAP_10FDX:
		v = (bfe->bfe_mii_anar & MII_ABILITY_10BASE_T_FD) != 0;
		break;

	case ETHER_STAT_ADV_CAP_10HDX:
		v = (bfe->bfe_mii_anar & MII_ABILITY_10BASE_T) != 0;
		break;

	case ETHER_STAT_ADV_CAP_ASMPAUSE:
		v = 0;
		break;

	case ETHER_STAT_ADV_CAP_AUTONEG:
		v = bfe->bfe_adv_aneg;
		break;

	case ETHER_STAT_ADV_CAP_PAUSE:
		v = (bfe->bfe_mii_anar & MII_ABILITY_PAUSE) != 0;
		break;

	case ETHER_STAT_ADV_REMFAULT:
		v = (bfe->bfe_mii_anar & MII_AN_ADVERT_REMFAULT) != 0;
		break;

	case ETHER_STAT_ALIGN_ERRORS:
		/* MIB */
		v = bfe->bfe_stats.ether_stat_align_errors;
		break;

	case ETHER_STAT_CAP_100T4:
		v = (bfe->bfe_mii_bmsr & MII_STATUS_100_BASE_T4) != 0;
		break;

	case ETHER_STAT_CAP_100FDX:
		v = (bfe->bfe_mii_bmsr & MII_STATUS_100_BASEX_FD) != 0;
		break;

	case ETHER_STAT_CAP_100HDX:
		v = (bfe->bfe_mii_bmsr & MII_STATUS_100_BASEX) != 0;
		break;

	case ETHER_STAT_CAP_10FDX:
		v = (bfe->bfe_mii_bmsr & MII_STATUS_10_FD) != 0;
		break;

	case ETHER_STAT_CAP_10HDX:
		v = (bfe->bfe_mii_bmsr & MII_STATUS_10) != 0;
		break;

	case ETHER_STAT_CAP_ASMPAUSE:
		v = 0;
		break;

	case ETHER_STAT_CAP_AUTONEG:
		v = ((bfe->bfe_mii_bmsr & MII_STATUS_CANAUTONEG) != 0);
		break;

	case ETHER_STAT_CAP_PAUSE:
		v = 1;
		break;

	case ETHER_STAT_CAP_REMFAULT:
		v = (bfe->bfe_mii_bmsr & MII_STATUS_REMFAULT) != 0;
		break;

	case ETHER_STAT_CARRIER_ERRORS:
		v = bfe->bfe_stats.ether_stat_carrier_errors;
		break;

	case ETHER_STAT_JABBER_ERRORS:
		err = ENOTSUP;
		break;

	case ETHER_STAT_DEFER_XMTS:
		v = bfe->bfe_stats.ether_stat_defer_xmts;
		break;

	case ETHER_STAT_EX_COLLISIONS:
		/* MIB */
		v = bfe->bfe_stats.ether_stat_ex_collisions;
		break;

	case ETHER_STAT_FCS_ERRORS:
		/* MIB */
		v = bfe->bfe_stats.ether_stat_fcs_errors;
		break;

	case ETHER_STAT_FIRST_COLLISIONS:
		/* MIB */
		v = bfe->bfe_stats.ether_stat_first_collisions;
		break;

	case ETHER_STAT_LINK_ASMPAUSE:
		v = 0;
		break;

	case ETHER_STAT_LINK_AUTONEG:
		v = (bfe->bfe_mii_bmcr & MII_CONTROL_ANE) != 0 &&
		    (bfe->bfe_mii_bmsr & MII_STATUS_ANDONE) != 0;
		break;

	case ETHER_STAT_LINK_DUPLEX:
		v = bfe->bfe_chip.duplex;
		break;

	case ETHER_STAT_LP_CAP_100T4:
		v = (bfe->bfe_mii_anlpar & MII_ABILITY_100BASE_T4) != 0;
		break;

	case ETHER_STAT_LP_CAP_100FDX:
		v = (bfe->bfe_mii_anlpar & MII_ABILITY_100BASE_TX_FD) != 0;
		break;

	case ETHER_STAT_LP_CAP_100HDX:
		v = (bfe->bfe_mii_anlpar & MII_ABILITY_100BASE_TX) != 0;
		break;

	case ETHER_STAT_LP_CAP_10FDX:
		v = (bfe->bfe_mii_anlpar & MII_ABILITY_10BASE_T_FD) != 0;
		break;

	case ETHER_STAT_LP_CAP_10HDX:
		v = (bfe->bfe_mii_anlpar & MII_ABILITY_10BASE_T) != 0;
		break;

	case ETHER_STAT_LP_CAP_ASMPAUSE:
		v = 0;
		break;

	case ETHER_STAT_LP_CAP_AUTONEG:
		v = (bfe->bfe_mii_exp & MII_AN_EXP_LPCANAN) != 0;
		break;

	case ETHER_STAT_LP_CAP_PAUSE:
		v = (bfe->bfe_mii_anlpar & MII_ABILITY_PAUSE) != 0;
		break;

	case ETHER_STAT_LP_REMFAULT:
		v = (bfe->bfe_mii_anlpar & MII_STATUS_REMFAULT) != 0;
		break;

	case ETHER_STAT_MACRCV_ERRORS:
		v = bfe->bfe_stats.ether_stat_macrcv_errors;
		break;

	case ETHER_STAT_MACXMT_ERRORS:
		v = bfe->bfe_stats.ether_stat_macxmt_errors;
		break;

	case ETHER_STAT_MULTI_COLLISIONS:
		v = bfe->bfe_stats.ether_stat_multi_collisions;
		break;

	case ETHER_STAT_SQE_ERRORS:
		err = ENOTSUP;
		break;

	case ETHER_STAT_TOOLONG_ERRORS:
		v = bfe->bfe_stats.ether_stat_toolong_errors;
		break;

	case ETHER_STAT_TOOSHORT_ERRORS:
		v = bfe->bfe_stats.ether_stat_tooshort_errors;
		break;

	case ETHER_STAT_TX_LATE_COLLISIONS:
		v = bfe->bfe_stats.ether_stat_tx_late_collisions;
		break;

	case ETHER_STAT_XCVR_ADDR:
		v = bfe->bfe_phy_addr;
		break;

	case ETHER_STAT_XCVR_ID:
		v = bfe->bfe_phy_id;
		break;

	case MAC_STAT_BRDCSTRCV:
		v = bfe->bfe_stats.brdcstrcv;
		break;

	case MAC_STAT_BRDCSTXMT:
		v = bfe->bfe_stats.brdcstxmt;
		break;

	case MAC_STAT_MULTIXMT:
		v = bfe->bfe_stats.multixmt;
		break;

	case MAC_STAT_COLLISIONS:
		v = bfe->bfe_stats.collisions;
		break;

	case MAC_STAT_IERRORS:
		v = bfe->bfe_stats.ierrors;
		break;

	case MAC_STAT_IPACKETS:
		v = bfe->bfe_stats.ipackets;
		break;

	case MAC_STAT_MULTIRCV:
		v = bfe->bfe_stats.multircv;
		break;

	case MAC_STAT_NORCVBUF:
		v = bfe->bfe_stats.norcvbuf;
		break;

	case MAC_STAT_NOXMTBUF:
		v = bfe->bfe_stats.noxmtbuf;
		break;

	case MAC_STAT_OBYTES:
		v = bfe->bfe_stats.obytes;
		break;

	case MAC_STAT_OERRORS:
		/* MIB */
		v = bfe->bfe_stats.ether_stat_macxmt_errors;
		break;

	case MAC_STAT_OPACKETS:
		v = bfe->bfe_stats.opackets;
		break;

	case MAC_STAT_RBYTES:
		v = bfe->bfe_stats.rbytes;
		break;

	case MAC_STAT_UNDERFLOWS:
		v = bfe->bfe_stats.underflows;
		break;

	case MAC_STAT_OVERFLOWS:
		v = bfe->bfe_stats.overflows;
		break;
	}

	rw_exit(&bfe->bfe_rwlock);

	*val = v;
	return (err);
}

int
bfe_mac_getprop(void *arg, const char *name, mac_prop_id_t num, uint_t sz,
    void *val)
{
	bfe_t		*bfe = (bfe_t *)arg;
	int		err = 0;

	switch (num) {
	case MAC_PROP_DUPLEX:
		ASSERT(sz >= sizeof (link_duplex_t));
		bcopy(&bfe->bfe_chip.duplex, val, sizeof (link_duplex_t));
		break;

	case MAC_PROP_SPEED:
		ASSERT(sz >= sizeof (uint64_t));
		bcopy(&bfe->bfe_chip.speed, val, sizeof (uint64_t));
		break;

	case MAC_PROP_AUTONEG:
		*(uint8_t *)val = bfe->bfe_adv_aneg;
		break;

	case MAC_PROP_ADV_100FDX_CAP:
		*(uint8_t *)val = bfe->bfe_adv_100fdx;
		break;

	case MAC_PROP_EN_100FDX_CAP:
		*(uint8_t *)val = bfe->bfe_adv_100fdx;
		break;

	case MAC_PROP_ADV_100HDX_CAP:
		*(uint8_t *)val = bfe->bfe_adv_100hdx;
		break;

	case MAC_PROP_EN_100HDX_CAP:
		*(uint8_t *)val = bfe->bfe_adv_100hdx;
		break;

	case MAC_PROP_ADV_10FDX_CAP:
		*(uint8_t *)val = bfe->bfe_adv_10fdx;
		break;

	case MAC_PROP_EN_10FDX_CAP:
		*(uint8_t *)val = bfe->bfe_adv_10fdx;
		break;

	case MAC_PROP_ADV_10HDX_CAP:
		*(uint8_t *)val = bfe->bfe_adv_10hdx;
		break;

	case MAC_PROP_EN_10HDX_CAP:
		*(uint8_t *)val = bfe->bfe_adv_10hdx;
		break;

	case MAC_PROP_ADV_100T4_CAP:
		*(uint8_t *)val = bfe->bfe_adv_100T4;
		break;

	case MAC_PROP_EN_100T4_CAP:
		*(uint8_t *)val = bfe->bfe_adv_100T4;
		break;

	default:
		err = ENOTSUP;
	}

	return (err);
}


static void
bfe_mac_propinfo(void *arg, const char *name, mac_prop_id_t num,
    mac_prop_info_handle_t prh)
{
	bfe_t		*bfe = (bfe_t *)arg;

	switch (num) {
	case MAC_PROP_DUPLEX:
	case MAC_PROP_SPEED:
	case MAC_PROP_ADV_100FDX_CAP:
	case MAC_PROP_ADV_100HDX_CAP:
	case MAC_PROP_ADV_10FDX_CAP:
	case MAC_PROP_ADV_10HDX_CAP:
	case MAC_PROP_ADV_100T4_CAP:
	case MAC_PROP_EN_100T4_CAP:
		mac_prop_info_set_perm(prh, MAC_PROP_PERM_READ);
		break;

	case MAC_PROP_AUTONEG:
		mac_prop_info_set_default_uint8(prh, bfe->bfe_cap_aneg);
		break;

	case MAC_PROP_EN_100FDX_CAP:
		mac_prop_info_set_default_uint8(prh, bfe->bfe_cap_100fdx);
		break;

	case MAC_PROP_EN_100HDX_CAP:
		mac_prop_info_set_default_uint8(prh, bfe->bfe_cap_100hdx);
		break;

	case MAC_PROP_EN_10FDX_CAP:
		mac_prop_info_set_default_uint8(prh, bfe->bfe_cap_10fdx);
		break;

	case MAC_PROP_EN_10HDX_CAP:
		mac_prop_info_set_default_uint8(prh, bfe->bfe_cap_10hdx);
		break;
	}
}


/*ARGSUSED*/
int
bfe_mac_setprop(void *arg, const char *name, mac_prop_id_t num, uint_t sz,
    const void *val)
{
	bfe_t		*bfe = (bfe_t *)arg;
	uint8_t		*advp;
	uint8_t		*capp;
	int 		r = 0;

	switch (num) {
	case MAC_PROP_EN_100FDX_CAP:
		advp = &bfe->bfe_adv_100fdx;
		capp = &bfe->bfe_cap_100fdx;
		break;

	case MAC_PROP_EN_100HDX_CAP:
		advp = &bfe->bfe_adv_100hdx;
		capp = &bfe->bfe_cap_100hdx;
		break;

	case MAC_PROP_EN_10FDX_CAP:
		advp = &bfe->bfe_adv_10fdx;
		capp = &bfe->bfe_cap_10fdx;
		break;

	case MAC_PROP_EN_10HDX_CAP:
		advp = &bfe->bfe_adv_10hdx;
		capp = &bfe->bfe_cap_10hdx;
		break;

	case MAC_PROP_AUTONEG:
		advp = &bfe->bfe_adv_aneg;
		capp = &bfe->bfe_cap_aneg;
		break;

	default:
		return (ENOTSUP);
	}

	if (*capp == 0)
		return (ENOTSUP);

	bfe_grab_locks(bfe);

	if (*advp != *(const uint8_t *)val) {
		*advp = *(const uint8_t *)val;

		bfe->bfe_chip_action = BFE_ACTION_RESTART_SETPROP;
		if (bfe->bfe_chip_state == BFE_CHIP_ACTIVE) {
			/*
			 * We need to stop the timer before grabbing locks
			 * otherwise we can land-up in deadlock with untimeout.
			 */
			bfe_stop_timer(bfe);

			bfe->bfe_chip_action |= BFE_ACTION_RESTART;

			bfe_chip_restart(bfe);

			/*
			 * We leave SETPROP because properties can be
			 * temporary.
			 */
			bfe->bfe_chip_action &= ~(BFE_ACTION_RESTART);
			r = 1;
		}
	}

	bfe_release_locks(bfe);

	/* kick-off a potential stopped downstream */
	if (r)
		mac_tx_update(bfe->bfe_machdl);

	return (0);
}


int
bfe_mac_set_ether_addr(void *arg, const uint8_t *ea)
{
	bfe_t *bfe = (bfe_t *)arg;

	bfe_grab_locks(bfe);
	bcopy(ea, bfe->bfe_ether_addr, ETHERADDRL);
	bfe_set_rx_mode(bfe);
	bfe_release_locks(bfe);
	return (0);
}

int
bfe_mac_start(void *arg)
{
	bfe_t *bfe = (bfe_t *)arg;

	bfe_grab_locks(bfe);
	if (bfe_chip_start(bfe) == DDI_FAILURE) {
		bfe_release_locks(bfe);
		return (EINVAL);
	}

	bfe_release_locks(bfe);

	mac_tx_update(bfe->bfe_machdl);

	return (0);
}

void
bfe_mac_stop(void *arg)
{
	bfe_t *bfe = (bfe_t *)arg;

	/*
	 * We need to stop the timer before grabbing locks otherwise
	 * we can land-up in deadlock with untimeout.
	 */
	bfe_stop_timer(bfe);

	bfe_grab_locks(bfe);

	/*
	 * First halt the chip by disabling interrupts.
	 */
	bfe_chip_halt(bfe);
	bfe_stop_phy(bfe);

	bfe->bfe_chip_state = BFE_CHIP_STOPPED;

	/*
	 * This will leave the PHY running.
	 */
	bfe_chip_reset(bfe);

	/*
	 * Disable RX register.
	 */
	bfe->bfe_chip_mode &= ~BFE_RX_MODE_ENABLE;
	bfe_set_rx_mode(bfe);

	bfe_release_locks(bfe);
}

/*
 * Send a packet down the wire.
 */
static int
bfe_send_a_packet(bfe_t *bfe, mblk_t *mp)
{
	bfe_ring_t *r = &bfe->bfe_tx_ring;
	uint32_t cur = r->r_curr_desc;
	uint32_t next;
	size_t	pktlen = msgsize(mp);
	uchar_t *buf;
	uint32_t v;

	ASSERT(MUTEX_HELD(&r->r_lock));
	ASSERT(mp != NULL);

	if (pktlen > r->r_buf_len) {
		freemsg(mp);
		return (BFE_SUCCESS);
	}

	/*
	 * There is a big reason why we don't check for '0'. It becomes easy
	 * for us to not roll over the ring since we are based on producer (tx)
	 * and consumer (reclaim by an interrupt) model. Especially when we
	 * run out of TX descriptor, chip will send a single interrupt and
	 * both producer and consumer counter will be same. So we keep a
	 * difference of 1 always.
	 */
	if (r->r_avail_desc <= 1) {
		bfe->bfe_stats.noxmtbuf++;
		bfe->bfe_tx_resched = 1;
		return (BFE_FAILURE);
	}

	/*
	 * Get the DMA buffer to hold packet.
	 */
	buf = (uchar_t *)r->r_buf_dma[cur].addr;

	mcopymsg(mp, buf);	/* it also frees mp */

	/*
	 * Gather statistics.
	 */
	if (buf[0] & 0x1) {
		if (bcmp(buf, bfe_broadcast, ETHERADDRL) != 0)
			bfe->bfe_stats.multixmt++;
		else
			bfe->bfe_stats.brdcstxmt++;
	}
	bfe->bfe_stats.opackets++;
	bfe->bfe_stats.obytes += pktlen;


	/*
	 * Program the DMA descriptor (start and end of frame are same).
	 */
	next = cur;
	v = (pktlen & BFE_DESC_LEN) | BFE_DESC_IOC | BFE_DESC_SOF |
	    BFE_DESC_EOF;

	if (cur == (TX_NUM_DESC - 1))
		v |= BFE_DESC_EOT;

	PUT_DESC(r, (uint32_t *)&(r->r_desc[cur].desc_ctl), v);

	/*
	 * DMA addresses need to be added to BFE_PCI_DMA
	 */
	PUT_DESC(r, (uint32_t *)&(r->r_desc[cur].desc_addr),
	    (r->r_buf_dma[cur].cookie.dmac_laddress + BFE_PCI_DMA));

	/*
	 * Sync the packet data for the device.
	 */
	(void) SYNC_BUF(r, cur, 0, pktlen, DDI_DMA_SYNC_FORDEV);

	/* Move to next descriptor slot */
	BFE_INC_SLOT(next, TX_NUM_DESC);

	(void) SYNC_DESC(r, 0, r->r_ndesc, DDI_DMA_SYNC_FORDEV);

	r->r_curr_desc = next;

	/*
	 * The order should be 1,2,3,... for BFE_DMATX_PTR if 0,1,2,3,...
	 * descriptor slot are being programmed.
	 */
	OUTL(bfe, BFE_DMATX_PTR, next * sizeof (bfe_desc_t));
	FLUSH(bfe, BFE_DMATX_PTR);

	r->r_avail_desc--;

	/*
	 * Let timeout know that it must reset the chip if a
	 * packet is not sent down the wire for more than 5 seconds.
	 */
	bfe->bfe_tx_stall_time = gethrtime() + (5 * 1000000000ULL);

	return (BFE_SUCCESS);
}

mblk_t *
bfe_mac_transmit_packet(void *arg, mblk_t *mp)
{
	bfe_t *bfe = (bfe_t *)arg;
	bfe_ring_t *r = &bfe->bfe_tx_ring;
	mblk_t	*nmp;

	mutex_enter(&r->r_lock);

	if (bfe->bfe_chip_state != BFE_CHIP_ACTIVE) {
		DTRACE_PROBE1(tx__chip__not__active, int, bfe->bfe_unit);

		freemsgchain(mp);
		mutex_exit(&r->r_lock);
		return (NULL);
	}


	while (mp != NULL) {
		nmp = mp->b_next;
		mp->b_next = NULL;

		if (bfe_send_a_packet(bfe, mp) == BFE_FAILURE) {
			mp->b_next = nmp;
			break;
		}
		mp = nmp;
	}

	mutex_exit(&r->r_lock);

	return (mp);
}

int
bfe_mac_set_promisc(void *arg, boolean_t promiscflag)
{
	bfe_t *bfe = (bfe_t *)arg;

	bfe_grab_locks(bfe);
	if (bfe->bfe_chip_state != BFE_CHIP_ACTIVE) {
		bfe_release_locks(bfe);
		return (EIO);
	}

	if (promiscflag) {
		/* Set Promiscous on */
		bfe->bfe_chip_mode |= BFE_RX_MODE_PROMISC;
	} else {
		bfe->bfe_chip_mode &= ~BFE_RX_MODE_PROMISC;
	}

	bfe_set_rx_mode(bfe);
	bfe_release_locks(bfe);

	return (0);
}

int
bfe_mac_set_multicast(void *arg, boolean_t add, const uint8_t *macaddr)
{
	/*
	 * It was too much of pain to implement multicast in CAM. Instead
	 * we never disable multicast filter.
	 */
	return (0);
}

static mac_callbacks_t bfe_mac_callbacks = {
	MC_SETPROP | MC_GETPROP | MC_PROPINFO,
	bfe_mac_getstat,	/* gets stats */
	bfe_mac_start,		/* starts mac */
	bfe_mac_stop,		/* stops mac */
	bfe_mac_set_promisc,	/* sets promisc mode for snoop */
	bfe_mac_set_multicast,	/* multicast implementation */
	bfe_mac_set_ether_addr,	/* sets ethernet address (unicast) */
	bfe_mac_transmit_packet, /* transmits packet */
	NULL,
	NULL,			/* ioctl */
	NULL,			/* getcap */
	NULL,			/* open */
	NULL,			/* close */
	bfe_mac_setprop,
	bfe_mac_getprop,
	bfe_mac_propinfo
};

static void
bfe_error_handler(bfe_t *bfe, int intr_mask)
{
	uint32_t v;

	if (intr_mask & BFE_ISTAT_RFO) {
		bfe->bfe_stats.overflows++;
		bfe->bfe_chip_action |=
		    (BFE_ACTION_RESTART | BFE_ACTION_RESTART_FAULT);
		goto action;
	}

	if (intr_mask & BFE_ISTAT_TFU) {
		bfe->bfe_stats.underflows++;
		return;
	}

	/* Descriptor Protocol Error */
	if (intr_mask & BFE_ISTAT_DPE) {
		bfe_error(bfe->bfe_dip,
		    "Descriptor Protocol Error. Halting Chip");
		bfe->bfe_chip_action |=
		    (BFE_ACTION_RESTART | BFE_ACTION_RESTART_FAULT);
		goto action;
	}

	/* Descriptor Error */
	if (intr_mask & BFE_ISTAT_DSCE) {
		bfe_error(bfe->bfe_dip, "Descriptor Error. Restarting Chip");
		goto action;
	}

	/* Receive Descr. Underflow */
	if (intr_mask & BFE_ISTAT_RDU) {
		bfe_error(bfe->bfe_dip,
		    "Receive Descriptor Underflow. Restarting Chip");
		bfe->bfe_stats.ether_stat_macrcv_errors++;
		bfe->bfe_chip_action |=
		    (BFE_ACTION_RESTART | BFE_ACTION_RESTART_FAULT);
		goto action;
	}

	v = INL(bfe, BFE_DMATX_STAT);

	/* Error while sending a packet */
	if (v & BFE_STAT_EMASK) {
		bfe->bfe_stats.ether_stat_macxmt_errors++;
		bfe_error(bfe->bfe_dip,
		    "Error while sending a packet. Restarting Chip");
	}

	/* Error while receiving a packet */
	v = INL(bfe, BFE_DMARX_STAT);
	if (v & BFE_RX_FLAG_ERRORS) {
		bfe->bfe_stats.ierrors++;
		bfe_error(bfe->bfe_dip,
		    "Error while receiving a packet. Restarting Chip");
	}


	bfe->bfe_chip_action |=
	    (BFE_ACTION_RESTART | BFE_ACTION_RESTART_FAULT);

action:
	bfe_chip_halt(bfe);
}

/*
 * It will recycle a RX descriptor slot.
 */
static void
bfe_rx_desc_buf_reinit(bfe_t *bfe, uint_t slot)
{
	bfe_ring_t *r = &bfe->bfe_rx_ring;
	uint32_t v;

	slot %= RX_NUM_DESC;

	bzero(r->r_buf_dma[slot].addr, sizeof (bfe_rx_header_t));

	(void) SYNC_BUF(r, slot, 0, BFE_RX_OFFSET, DDI_DMA_SYNC_FORDEV);

	v = r->r_buf_dma[slot].len  & BFE_DESC_LEN;
	if (slot == (RX_NUM_DESC - 1))
		v |= BFE_DESC_EOT;

	PUT_DESC(r, (uint32_t *)&(r->r_desc[slot].desc_ctl), v);

	/*
	 * DMA addresses need to be added to BFE_PCI_DMA
	 */
	PUT_DESC(r, (uint32_t *)&(r->r_desc[slot].desc_addr),
	    (r->r_buf_dma[slot].cookie.dmac_laddress + BFE_PCI_DMA));
}

/*
 * Gets called from interrupt context to handle RX interrupt.
 */
static mblk_t *
bfe_receive(bfe_t *bfe, int intr_mask)
{
	int rxstat, current;
	mblk_t	*mp = NULL, *rx_head, *rx_tail;
	uchar_t	*rx_header;
	uint16_t len;
	uchar_t	*bp;
	bfe_ring_t *r = &bfe->bfe_rx_ring;
	int i;

	rxstat = INL(bfe, BFE_DMARX_STAT);
	current = (rxstat & BFE_STAT_CDMASK) / sizeof (bfe_desc_t);
	i = r->r_curr_desc;

	rx_head = rx_tail = NULL;

	DTRACE_PROBE3(receive, int, bfe->bfe_unit,
	    int, r->r_curr_desc,
	    int, current);

	for (i = r->r_curr_desc; i != current;
	    BFE_INC_SLOT(i, RX_NUM_DESC)) {

		/*
		 * Sync the buffer associated with the descriptor table entry.
		 */
		(void) SYNC_BUF(r, i, 0, r->r_buf_dma[i].len,
		    DDI_DMA_SYNC_FORKERNEL);

		rx_header = (void *)r->r_buf_dma[i].addr;

		/*
		 * We do this to make sure we are endian neutral. Chip is
		 * big endian.
		 *
		 * The header looks like :-
		 *
		 *  Offset 0  -> uint16_t len
		 *  Offset 2  -> uint16_t flags
		 *  Offset 4  -> uint16_t pad[12]
		 */
		len = (rx_header[1] << 8) | rx_header[0];
		len -= 4;	/* CRC bytes need to be removed */

		/*
		 * Don't receive this packet if pkt length is greater than
		 * MTU + VLAN_TAGSZ.
		 */
		if (len > r->r_buf_len) {
			/* Recycle slot for later use */
			bfe_rx_desc_buf_reinit(bfe, i);
			continue;
		}

		if ((mp = allocb(len + VLAN_TAGSZ, BPRI_MED)) != NULL) {
			mp->b_rptr += VLAN_TAGSZ;
			bp = mp->b_rptr;
			mp->b_wptr = bp + len;

			/* sizeof (bfe_rx_header_t) + 2 */
			bcopy(r->r_buf_dma[i].addr +
			    BFE_RX_OFFSET, bp, len);

			mp->b_next = NULL;
			if (rx_tail == NULL)
				rx_head = rx_tail = mp;
			else {
				rx_tail->b_next = mp;
				rx_tail = mp;
			}

			/* Number of packets received so far */
			bfe->bfe_stats.ipackets++;

			/* Total bytes of packets received so far */
			bfe->bfe_stats.rbytes += len;

			if (bcmp(mp->b_rptr, bfe_broadcast, ETHERADDRL) == 0)
				bfe->bfe_stats.brdcstrcv++;
			else
				bfe->bfe_stats.multircv++;
		} else {
			bfe->bfe_stats.norcvbuf++;
			/* Recycle the slot for later use */
			bfe_rx_desc_buf_reinit(bfe, i);
			break;
		}

		/*
		 * Reinitialize the current descriptor slot's buffer so that
		 * it can be reused.
		 */
		bfe_rx_desc_buf_reinit(bfe, i);
	}

	r->r_curr_desc = i;

	(void) SYNC_DESC(r, 0, r->r_ndesc, DDI_DMA_SYNC_FORDEV);

	return (rx_head);
}

static int
bfe_tx_reclaim(bfe_ring_t *r)
{
	uint32_t cur, start;
	uint32_t v;

	cur = INL(r->r_bfe, BFE_DMATX_STAT) & BFE_STAT_CDMASK;
	cur = cur / sizeof (bfe_desc_t);

	/*
	 * Start with the last descriptor consumed by the chip.
	 */
	start = r->r_cons_desc;

	DTRACE_PROBE3(tx__reclaim, int, r->r_bfe->bfe_unit,
	    int, start,
	    int, cur);

	/*
	 * There will be at least one descriptor to process.
	 */
	while (start != cur) {
		r->r_avail_desc++;
		v = r->r_buf_dma[start].len  & BFE_DESC_LEN;
		if (start == (TX_NUM_DESC - 1))
			v |= BFE_DESC_EOT;

		PUT_DESC(r, (uint32_t *)&(r->r_desc[start].desc_ctl), v);
		PUT_DESC(r, (uint32_t *)&(r->r_desc[start].desc_addr),
		    (r->r_buf_dma[start].cookie.dmac_laddress + BFE_PCI_DMA));

		/* Move to next descriptor in TX ring */
		BFE_INC_SLOT(start, TX_NUM_DESC);
	}

	(void) ddi_dma_sync(r->r_desc_dma_handle,
	    0, (r->r_ndesc * sizeof (bfe_desc_t)),
	    DDI_DMA_SYNC_FORDEV);

	r->r_cons_desc = start; 	/* consumed pointer */
	r->r_bfe->bfe_tx_stall_time = 0;

	return (cur);
}

static int
bfe_tx_done(bfe_t *bfe, int intr_mask)
{
	bfe_ring_t *r = &bfe->bfe_tx_ring;
	int resched = 0;

	mutex_enter(&r->r_lock);
	(void) bfe_tx_reclaim(r);

	if (bfe->bfe_tx_resched) {
		resched = 1;
		bfe->bfe_tx_resched = 0;
	}
	mutex_exit(&r->r_lock);

	return (resched);
}

/*
 * ISR for interrupt handling
 */
static uint_t
bfe_interrupt(caddr_t arg1, caddr_t arg2)
{
	bfe_t *bfe =  (void *)arg1;
	uint32_t	intr_stat;
	mblk_t *rx_head = NULL;
	int resched = 0;

	/*
	 * Grab the lock to avoid stopping the chip while this interrupt
	 * is handled.
	 */
	rw_enter(&bfe->bfe_rwlock, RW_READER);

	/*
	 * It's necessary to read intr stat again because masking interrupt
	 * register does not really mask interrupts coming from the chip.
	 */
	intr_stat = INL(bfe, BFE_INTR_STAT);
	intr_stat &= BFE_IMASK_DEF;
	OUTL(bfe, BFE_INTR_STAT, intr_stat);
	(void) INL(bfe, BFE_INTR_STAT);

	if (intr_stat == 0) {
		rw_exit(&bfe->bfe_rwlock);
		return (DDI_INTR_UNCLAIMED);
	}

	DTRACE_PROBE2(bfe__interrupt, int, bfe->bfe_unit,
	    int, intr_stat);

	if (bfe->bfe_chip_state != BFE_CHIP_ACTIVE) {
		/*
		 * If chip is suspended then we just return.
		 */
		if (bfe->bfe_chip_state == BFE_CHIP_SUSPENDED) {
			rw_exit(&bfe->bfe_rwlock);
			DTRACE_PROBE1(interrupt__chip__is__suspend, int,
			    bfe->bfe_unit);
			return (DDI_INTR_CLAIMED);
		}

		/*
		 * Halt the chip again i.e basically disable interrupts.
		 */
		bfe_chip_halt(bfe);
		rw_exit(&bfe->bfe_rwlock);
		DTRACE_PROBE1(interrupt__chip__not__active, int,
		    bfe->bfe_unit);
		return (DDI_INTR_CLAIMED);
	}

	/* A packet was received */
	if (intr_stat & BFE_ISTAT_RX) {
		rx_head = bfe_receive(bfe, intr_stat);
	}

	/* A packet was sent down the wire */
	if (intr_stat & BFE_ISTAT_TX) {
		resched = bfe_tx_done(bfe, intr_stat);
	}

	/* There was an error */
	if (intr_stat & BFE_ISTAT_ERRORS) {
		bfe_error_handler(bfe, intr_stat);
	}

	rw_exit(&bfe->bfe_rwlock);

	/*
	 * Pass the list of packets received from chip to MAC layer.
	 */
	if (rx_head) {
		mac_rx(bfe->bfe_machdl, 0, rx_head);
	}

	/*
	 * Let the MAC start sending pkts to a potential stopped stream.
	 */
	if (resched)
		mac_tx_update(bfe->bfe_machdl);

	return (DDI_INTR_CLAIMED);
}

/*
 * Removes registered interrupt handler.
 */
static void
bfe_remove_intr(bfe_t *bfe)
{
	(void) ddi_intr_remove_handler(bfe->bfe_intrhdl);
	(void) ddi_intr_free(bfe->bfe_intrhdl);
}

/*
 * Add an interrupt for the driver.
 */
static int
bfe_add_intr(bfe_t *bfe)
{
	int	nintrs = 1;
	int ret;

	ret = ddi_intr_alloc(bfe->bfe_dip, &bfe->bfe_intrhdl,
	    DDI_INTR_TYPE_FIXED,	/* type */
	    0,	/* inumber */
	    1,	/* count */
	    &nintrs,	/* actual nintrs */
	    DDI_INTR_ALLOC_STRICT);

	if (ret != DDI_SUCCESS) {
		bfe_error(bfe->bfe_dip, "ddi_intr_alloc() failed"
		    " : ret : %d", ret);
		return (DDI_FAILURE);
	}

	ret = ddi_intr_add_handler(bfe->bfe_intrhdl, bfe_interrupt, bfe, NULL);
	if (ret != DDI_SUCCESS) {
		bfe_error(bfe->bfe_dip, "ddi_intr_add_handler() failed");
		(void) ddi_intr_free(bfe->bfe_intrhdl);
		return (DDI_FAILURE);
	}

	ret = ddi_intr_get_pri(bfe->bfe_intrhdl, &bfe->bfe_intrpri);
	if (ret != DDI_SUCCESS) {
		bfe_error(bfe->bfe_dip, "ddi_intr_get_pri() failed");
		bfe_remove_intr(bfe);
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}


/*
 * Identify chipset family.
 */
static int
bfe_identify_hardware(bfe_t *bfe)
{
	uint16_t	vid, did;
	int i;

	vid = pci_config_get16(bfe->bfe_conf_handle, PCI_CONF_VENID);
	did = pci_config_get16(bfe->bfe_conf_handle, PCI_CONF_DEVID);

	for (i = 0; i < (sizeof (bfe_cards) / sizeof (bfe_cards_t)); i++) {
		if (bfe_cards[i].vendor_id == vid &&
		    bfe_cards[i].device_id == did) {
			return (BFE_SUCCESS);
		}
	}

	bfe_error(bfe->bfe_dip, "bfe driver is attaching to unknown pci%d,%d"
	    " vendor/device-id card", vid, did);

	return (BFE_SUCCESS);
}

/*
 * Maps device registers.
 */
static int
bfe_regs_map(bfe_t *bfe)
{
	dev_info_t *dip = bfe->bfe_dip;
	int ret;

	ret = ddi_regs_map_setup(dip, 1, &bfe->bfe_mem_regset.addr, 0, 0,
	    &bfe_dev_attr, &bfe->bfe_mem_regset.hdl);

	if (ret != DDI_SUCCESS) {
		bfe_error(bfe->bfe_dip, "ddi_regs_map_setup failed");
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

static void
bfe_unmap_regs(bfe_t *bfe)
{
	ddi_regs_map_free(&bfe->bfe_mem_regset.hdl);
}

static int
bfe_get_chip_config(bfe_t *bfe)
{
	uint32_t	prom[BFE_EEPROM_SIZE];
	int i;

	/*
	 * Read EEPROM in prom[]
	 */
	for (i = 0; i < BFE_EEPROM_SIZE; i++) {
		prom[i] = INL(bfe, BFE_EEPROM_BASE + i * sizeof (uint32_t));
	}

	bfe->bfe_dev_addr[0] = bfe->bfe_ether_addr[0] =
	    INB(bfe, BFE_EEPROM_BASE + 79);

	bfe->bfe_dev_addr[1] = bfe->bfe_ether_addr[1] =
	    INB(bfe, BFE_EEPROM_BASE + 78);

	bfe->bfe_dev_addr[2] = bfe->bfe_ether_addr[2] =
	    INB(bfe, BFE_EEPROM_BASE + 81);

	bfe->bfe_dev_addr[3] = bfe->bfe_ether_addr[3] =
	    INB(bfe, BFE_EEPROM_BASE + 80);

	bfe->bfe_dev_addr[4] = bfe->bfe_ether_addr[4] =
	    INB(bfe, BFE_EEPROM_BASE + 83);

	bfe->bfe_dev_addr[5] = bfe->bfe_ether_addr[5] =
	    INB(bfe, BFE_EEPROM_BASE + 82);

	bfe->bfe_phy_addr = -1;

	return (DDI_SUCCESS);
}

/*
 * Ring Management routines
 */
static int
bfe_ring_buf_alloc(bfe_t *bfe, bfe_ring_t *r, int slot, int d)
{
	int err;
	uint_t count = 0;

	err = ddi_dma_alloc_handle(bfe->bfe_dip,
	    &bfe_dma_attr_buf, DDI_DMA_SLEEP, NULL,
	    &r->r_buf_dma[slot].handle);

	if (err != DDI_SUCCESS) {
		bfe_error(bfe->bfe_dip, " bfe_ring_buf_alloc() :"
		    " alloc_handle failed");
		goto fail0;
	}

	err = ddi_dma_mem_alloc(r->r_buf_dma[slot].handle,
	    r->r_buf_len, &bfe_buf_attr, DDI_DMA_STREAMING,
	    DDI_DMA_SLEEP, NULL, &r->r_buf_dma[slot].addr,
	    &r->r_buf_dma[slot].len,
	    &r->r_buf_dma[slot].acchdl);

	if (err != DDI_SUCCESS) {
		bfe_error(bfe->bfe_dip, " bfe_ring_buf_alloc() :"
		    " mem_alloc failed :%d", err);
		goto fail1;
	}

	err = ddi_dma_addr_bind_handle(r->r_buf_dma[slot].handle,
	    NULL, r->r_buf_dma[slot].addr,
	    r->r_buf_dma[slot].len,
	    (DDI_DMA_RDWR | DDI_DMA_STREAMING),
	    DDI_DMA_SLEEP, NULL,
	    &r->r_buf_dma[slot].cookie,
	    &count);

	if (err != DDI_DMA_MAPPED) {
		bfe_error(bfe->bfe_dip, " bfe_ring_buf_alloc() :"
		    " bind_handle failed");
		goto fail2;
	}

	if (count > 1) {
		bfe_error(bfe->bfe_dip, " bfe_ring_buf_alloc() :"
		    " more than one DMA cookie");
		(void) ddi_dma_unbind_handle(r->r_buf_dma[slot].handle);
		goto fail2;
	}

	return (DDI_SUCCESS);
fail2:
	ddi_dma_mem_free(&r->r_buf_dma[slot].acchdl);
fail1:
	ddi_dma_free_handle(&r->r_buf_dma[slot].handle);
fail0:
	return (DDI_FAILURE);
}

static void
bfe_ring_buf_free(bfe_ring_t *r, int slot)
{
	if (r->r_buf_dma == NULL)
		return;

	(void) ddi_dma_unbind_handle(r->r_buf_dma[slot].handle);
	ddi_dma_mem_free(&r->r_buf_dma[slot].acchdl);
	ddi_dma_free_handle(&r->r_buf_dma[slot].handle);
}

static void
bfe_buffer_free(bfe_ring_t *r)
{
	int i;

	for (i = 0; i < r->r_ndesc; i++) {
		bfe_ring_buf_free(r, i);
	}
}

static void
bfe_ring_desc_free(bfe_ring_t *r)
{
	(void) ddi_dma_unbind_handle(r->r_desc_dma_handle);
	ddi_dma_mem_free(&r->r_desc_acc_handle);
	ddi_dma_free_handle(&r->r_desc_dma_handle);
	kmem_free(r->r_buf_dma, r->r_ndesc * sizeof (bfe_dma_t));

	r->r_buf_dma = NULL;
	r->r_desc = NULL;
}


static int
bfe_ring_desc_alloc(bfe_t *bfe, bfe_ring_t *r, int d)
{
	int err, i, fail = 0;
	caddr_t	ring;
	size_t	size_krnl = 0, size_dma = 0, ring_len = 0;
	ddi_dma_cookie_t cookie;
	uint_t	count = 0;

	ASSERT(bfe != NULL);

	size_krnl = r->r_ndesc * sizeof (bfe_dma_t);
	size_dma = r->r_ndesc * sizeof (bfe_desc_t);
	r->r_buf_dma = kmem_zalloc(size_krnl, KM_SLEEP);


	err = ddi_dma_alloc_handle(bfe->bfe_dip, &bfe_dma_attr_desc,
	    DDI_DMA_SLEEP, NULL, &r->r_desc_dma_handle);

	if (err != DDI_SUCCESS) {
		bfe_error(bfe->bfe_dip, "bfe_ring_desc_alloc() failed on"
		    " ddi_dma_alloc_handle()");
		kmem_free(r->r_buf_dma, size_krnl);
		return (DDI_FAILURE);
	}


	err = ddi_dma_mem_alloc(r->r_desc_dma_handle,
	    size_dma, &bfe_buf_attr,
	    DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL,
	    &ring, &ring_len, &r->r_desc_acc_handle);

	if (err != DDI_SUCCESS) {
		bfe_error(bfe->bfe_dip, "bfe_ring_desc_alloc() failed on"
		    " ddi_dma_mem_alloc()");
		ddi_dma_free_handle(&r->r_desc_dma_handle);
		kmem_free(r->r_buf_dma, size_krnl);
		return (DDI_FAILURE);
	}

	err = ddi_dma_addr_bind_handle(r->r_desc_dma_handle,
	    NULL, ring, ring_len,
	    DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
	    DDI_DMA_SLEEP, NULL,
	    &cookie, &count);

	if (err != DDI_SUCCESS) {
		bfe_error(bfe->bfe_dip, "bfe_ring_desc_alloc() failed on"
		    " ddi_dma_addr_bind_handle()");
		ddi_dma_mem_free(&r->r_desc_acc_handle);
		ddi_dma_free_handle(&r->r_desc_dma_handle);
		kmem_free(r->r_buf_dma, size_krnl);
		return (DDI_FAILURE);
	}

	/*
	 * We don't want to have multiple cookies. Descriptor should be
	 * aligned to PAGESIZE boundary.
	 */
	ASSERT(count == 1);

	/* The actual descriptor for the ring */
	r->r_desc_len = ring_len;
	r->r_desc_cookie = cookie;

	r->r_desc = (void *)ring;

	bzero(r->r_desc, size_dma);
	bzero(r->r_desc, ring_len);

	/* For each descriptor, allocate a DMA buffer */
	fail = 0;
	for (i = 0; i < r->r_ndesc; i++) {
		if (bfe_ring_buf_alloc(bfe, r, i, d) != DDI_SUCCESS) {
			i--;
			fail = 1;
			break;
		}
	}

	if (fail) {
		while (i-- >= 0) {
			bfe_ring_buf_free(r, i);
		}

		/* We don't need the descriptor anymore */
		bfe_ring_desc_free(r);
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

static int
bfe_rings_alloc(bfe_t *bfe)
{
	/* TX */
	mutex_init(&bfe->bfe_tx_ring.r_lock, NULL, MUTEX_DRIVER, NULL);
	bfe->bfe_tx_ring.r_lockp = &bfe->bfe_tx_ring.r_lock;
	bfe->bfe_tx_ring.r_buf_len = BFE_MTU + sizeof (struct ether_header) +
	    VLAN_TAGSZ + ETHERFCSL;
	bfe->bfe_tx_ring.r_ndesc = TX_NUM_DESC;
	bfe->bfe_tx_ring.r_bfe = bfe;
	bfe->bfe_tx_ring.r_avail_desc = TX_NUM_DESC;

	/* RX */
	mutex_init(&bfe->bfe_rx_ring.r_lock, NULL, MUTEX_DRIVER, NULL);
	bfe->bfe_rx_ring.r_lockp = &bfe->bfe_rx_ring.r_lock;
	bfe->bfe_rx_ring.r_buf_len = BFE_MTU + sizeof (struct ether_header) +
	    VLAN_TAGSZ + ETHERFCSL + RX_HEAD_ROOM;
	bfe->bfe_rx_ring.r_ndesc = RX_NUM_DESC;
	bfe->bfe_rx_ring.r_bfe = bfe;
	bfe->bfe_rx_ring.r_avail_desc = RX_NUM_DESC;

	/* Allocate TX Ring */
	if (bfe_ring_desc_alloc(bfe, &bfe->bfe_tx_ring,
	    DDI_DMA_WRITE) != DDI_SUCCESS)
		return (DDI_FAILURE);

	/* Allocate RX Ring */
	if (bfe_ring_desc_alloc(bfe, &bfe->bfe_rx_ring,
	    DDI_DMA_READ) != DDI_SUCCESS) {
		cmn_err(CE_NOTE, "RX ring allocation failed");
		bfe_ring_desc_free(&bfe->bfe_tx_ring);
		return (DDI_FAILURE);
	}

	bfe->bfe_tx_ring.r_flags = BFE_RING_ALLOCATED;
	bfe->bfe_rx_ring.r_flags = BFE_RING_ALLOCATED;

	return (DDI_SUCCESS);
}

static int
bfe_resume(dev_info_t *dip)
{
	bfe_t *bfe;
	int err = DDI_SUCCESS;

	if ((bfe = ddi_get_driver_private(dip)) == NULL) {
		bfe_error(dip, "Unexpected error (no driver private data)"
		    " while resume");
		return (DDI_FAILURE);
	}

	/*
	 * Grab all the locks first.
	 */
	bfe_grab_locks(bfe);
	bfe->bfe_chip_state = BFE_CHIP_RESUME;

	bfe_init_vars(bfe);
	/* PHY will also start running */
	bfe_chip_reset(bfe);
	if (bfe_chip_start(bfe) == DDI_FAILURE) {
		bfe_error(dip, "Could not resume chip");
		err = DDI_FAILURE;
	}

	bfe_release_locks(bfe);

	if (err == DDI_SUCCESS)
		mac_tx_update(bfe->bfe_machdl);

	return (err);
}

static int
bfe_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	int	unit;
	bfe_t	*bfe;
	mac_register_t	*macreg;
	int	ret;

	switch (cmd) {
	case DDI_RESUME:
		return (bfe_resume(dip));

	case DDI_ATTACH:
		break;

	default:
		return (DDI_FAILURE);
	}


	unit = ddi_get_instance(dip);

	bfe = kmem_zalloc(sizeof (bfe_t), KM_SLEEP);
	bfe->bfe_dip = dip;
	bfe->bfe_unit = unit;

	if (pci_config_setup(dip, &bfe->bfe_conf_handle) != DDI_SUCCESS) {
		bfe_error(dip, "pci_config_setup failed");
		goto fail0;
	}

	/*
	 * Enable IO space, Bus Master and Memory Space accessess.
	 */
	ret = pci_config_get16(bfe->bfe_conf_handle, PCI_CONF_COMM);
	pci_config_put16(bfe->bfe_conf_handle, PCI_CONF_COMM,
	    PCI_COMM_IO | PCI_COMM_MAE | PCI_COMM_ME | ret);

	ddi_set_driver_private(dip, bfe);

	/* Identify hardware */
	if (bfe_identify_hardware(bfe) == BFE_FAILURE) {
		bfe_error(dip, "Could not identify device");
		goto fail1;
	}

	if (bfe_regs_map(bfe) != DDI_SUCCESS) {
		bfe_error(dip, "Could not map device registers");
		goto fail1;
	}

	(void) bfe_get_chip_config(bfe);

	/*
	 * Register with MAC layer
	 */
	if ((macreg = mac_alloc(MAC_VERSION)) == NULL) {
		bfe_error(dip, "mac_alloc() failed");
		goto fail2;
	}

	macreg->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
	macreg->m_driver = bfe;
	macreg->m_dip = dip;
	macreg->m_instance = unit;
	macreg->m_src_addr = bfe->bfe_ether_addr;
	macreg->m_callbacks = &bfe_mac_callbacks;
	macreg->m_min_sdu = 0;
	macreg->m_max_sdu = ETHERMTU;
	macreg->m_margin = VLAN_TAGSZ;

	if ((ret = mac_register(macreg, &bfe->bfe_machdl)) != 0) {
		bfe_error(dip, "mac_register() failed with %d error", ret);
		mac_free(macreg);
		goto fail2;
	}

	mac_free(macreg);

	rw_init(&bfe->bfe_rwlock, NULL, RW_DRIVER,
	    DDI_INTR_PRI(bfe->bfe_intrpri));

	if (bfe_add_intr(bfe) != DDI_SUCCESS) {
		bfe_error(dip, "Could not add interrupt");
		goto fail3;
	}

	if (bfe_rings_alloc(bfe) != DDI_SUCCESS) {
		bfe_error(dip, "Could not allocate TX/RX Ring");
		goto fail4;
	}

	/* Init and then reset the chip */
	bfe->bfe_chip_action = 0;
	bfe_init_vars(bfe);

	/* PHY will also start running */
	bfe_chip_reset(bfe);

	/*
	 * Even though we enable the interrupts here but chip's interrupt
	 * is not enabled yet. It will be enabled once we plumb the interface.
	 */
	if (ddi_intr_enable(bfe->bfe_intrhdl) != DDI_SUCCESS) {
		bfe_error(dip, "Could not enable interrupt");
		goto fail4;
	}

	return (DDI_SUCCESS);

fail4:
	bfe_remove_intr(bfe);
fail3:
	(void) mac_unregister(bfe->bfe_machdl);
fail2:
	bfe_unmap_regs(bfe);
fail1:
	pci_config_teardown(&bfe->bfe_conf_handle);
fail0:
	kmem_free(bfe, sizeof (bfe_t));
	return (DDI_FAILURE);
}

static int
bfe_detach(dev_info_t *devinfo, ddi_detach_cmd_t cmd)
{
	bfe_t *bfe;

	bfe = ddi_get_driver_private(devinfo);

	switch (cmd) {
	case DDI_DETACH:
		/*
		 * We need to stop the timer before grabbing locks otherwise
		 * we can land-up in deadlock with untimeout.
		 */
		bfe_stop_timer(bfe);

		/*
		 * First unregister with MAC layer before stopping DMA
		 * engine.
		 */
		if (mac_unregister(bfe->bfe_machdl) != DDI_SUCCESS)
			return (DDI_FAILURE);

		bfe->bfe_machdl = NULL;

		/*
		 * Quiesce the chip first.
		 */
		bfe_grab_locks(bfe);
		bfe_chip_halt(bfe);
		bfe_stop_phy(bfe);
		bfe_release_locks(bfe);

		(void) ddi_intr_disable(bfe->bfe_intrhdl);

		/* Make sure timer is gone. */
		bfe_stop_timer(bfe);

		/*
		 * Free the DMA resources for buffer and then descriptors
		 */
		if (bfe->bfe_tx_ring.r_flags == BFE_RING_ALLOCATED) {
			/* TX */
			bfe_buffer_free(&bfe->bfe_tx_ring);
			bfe_ring_desc_free(&bfe->bfe_tx_ring);
		}

		if (bfe->bfe_rx_ring.r_flags == BFE_RING_ALLOCATED) {
			/* RX */
			bfe_buffer_free(&bfe->bfe_rx_ring);
			bfe_ring_desc_free(&bfe->bfe_rx_ring);
		}

		bfe_remove_intr(bfe);
		bfe_unmap_regs(bfe);
		pci_config_teardown(&bfe->bfe_conf_handle);

		mutex_destroy(&bfe->bfe_tx_ring.r_lock);
		mutex_destroy(&bfe->bfe_rx_ring.r_lock);
		rw_destroy(&bfe->bfe_rwlock);

		kmem_free(bfe, sizeof (bfe_t));

		ddi_set_driver_private(devinfo, NULL);
		return (DDI_SUCCESS);

	case DDI_SUSPEND:
		/*
		 * We need to stop the timer before grabbing locks otherwise
		 * we can land-up in deadlock with untimeout.
		 */
		bfe_stop_timer(bfe);

		/*
		 * Grab all the locks first.
		 */
		bfe_grab_locks(bfe);
		bfe_chip_halt(bfe);
		bfe_stop_phy(bfe);
		bfe->bfe_chip_state = BFE_CHIP_SUSPENDED;
		bfe_release_locks(bfe);

		return (DDI_SUCCESS);

	default:
		return (DDI_FAILURE);
	}
}

/*
 * Quiesce the card for fast reboot
 */
int
bfe_quiesce(dev_info_t *dev_info)
{
	bfe_t *bfe;

	bfe = ddi_get_driver_private(dev_info);

	bfe_chip_halt(bfe);
	bfe_stop_phy(bfe);
	bfe->bfe_chip_state = BFE_CHIP_QUIESCED;

	return (DDI_SUCCESS);
}

static struct cb_ops bfe_cb_ops = {
	nulldev,		/* cb_open */
	nulldev,		/* cb_close */
	nodev,			/* cb_strategy */
	nodev,			/* cb_print */
	nodev,			/* cb_dump */
	nodev,			/* cb_read */
	nodev,			/* cb_write */
	nodev,			/* cb_ioctl */
	nodev,			/* cb_devmap */
	nodev,			/* cb_mmap */
	nodev,			/* cb_segmap */
	nochpoll,		/* cb_chpoll */
	ddi_prop_op,		/* cb_prop_op */
	NULL,			/* cb_stream */
	D_MP | D_HOTPLUG,	/* cb_flag */
	CB_REV,			/* cb_rev */
	nodev,			/* cb_aread */
	nodev			/* cb_awrite */
};

static struct dev_ops bfe_dev_ops = {
	DEVO_REV,	/* devo_rev */
	0,		/* devo_refcnt */
	NULL,		/* devo_getinfo */
	nulldev,	/* devo_identify */
	nulldev,	/* devo_probe */
	bfe_attach,	/* devo_attach */
	bfe_detach,	/* devo_detach */
	nodev,		/* devo_reset */
	&bfe_cb_ops,	/* devo_cb_ops */
	NULL,		/* devo_bus_ops */
	ddi_power,	/* devo_power */
	bfe_quiesce	/* devo_quiesce */
};

static struct modldrv bfe_modldrv = {
	&mod_driverops,
	bfe_ident,
	&bfe_dev_ops
};

static struct modlinkage modlinkage = {
	MODREV_1, (void *)&bfe_modldrv, NULL
};

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}

int
_init(void)
{
	int	status;

	mac_init_ops(&bfe_dev_ops, MODULE_NAME);
	status = mod_install(&modlinkage);
	if (status == DDI_FAILURE)
		mac_fini_ops(&bfe_dev_ops);
	return (status);
}

int
_fini(void)
{
	int status;

	status = mod_remove(&modlinkage);
	if (status == 0) {
		mac_fini_ops(&bfe_dev_ops);
	}
	return (status);
}