xref: /illumos-gate/usr/src/uts/common/io/bnx/bnxgldv3.c (revision fe803bd5)

/*
 * Copyright 2014-2017 Cavium, Inc.
 * The contents of this file are subject to the terms of the Common Development
 * and Distribution License, v.1,  (the "License").
 *
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the License at available
 * at http://opensource.org/licenses/CDDL-1.0
 *
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2019, Joyent, Inc.
 * Copyright 2023 Oxide Computer Company
 */

#include "bnxgld.h"
#include "bnxhwi.h"
#include "bnxsnd.h"
#include "bnxrcv.h"
#include "bnxcfg.h"

#include <sys/mac_provider.h>
#include <sys/mac_ether.h>
#include <sys/dlpi.h>
#include <sys/policy.h>

/*
 * Name:    bnx_m_start
 *
 * Input:   ptr to driver device structure.
 *
 * Return:  DDI_SUCCESS or DDI_FAILURE
 *
 * Description:
 *          This routine is called by GLD to enable device for
 *          packet reception and enable interrupts.
 */
static int
bnx_m_start(void *arg)
{
	int rc;
	um_device_t *umdevice;

	umdevice = (um_device_t *)arg;

	mutex_enter(&umdevice->os_param.gld_mutex);

	if (umdevice->dev_start == B_TRUE) {
		/* We're already started.  Success! */
		rc = 0;
		goto done;
	}

	/* Always report the initial link state as unknown. */
	bnx_gld_link(umdevice, LINK_STATE_UNKNOWN);

	umdevice->link_updates_ok = B_TRUE;

	if (bnx_hdwr_acquire(umdevice)) {
		rc = EIO;
		goto done;
	}

	umdevice->dev_start = B_TRUE;

	rc = 0;

done:
	mutex_exit(&umdevice->os_param.gld_mutex);

	return (rc);
}

/*
 * Name:    bnx_m_stop
 *
 * Input:   ptr to driver device structure.
 *
 * Return:  DDI_SUCCESS or DDI_FAILURE
 *
 * Description:
 *          This routine stops packet reception by clearing RX MASK
 *          register. Also interrupts are disabled for this device.
 */
static void
bnx_m_stop(void *arg)
{
	um_device_t *umdevice;

	umdevice = (um_device_t *)arg;

	mutex_enter(&umdevice->os_param.gld_mutex);

	if (umdevice->dev_start == B_TRUE) {
		umdevice->dev_start = B_FALSE;
		umdevice->link_updates_ok = B_FALSE;

		bnx_hdwr_release(umdevice);

		/* Report the link state back to unknown. */
		bnx_gld_link(umdevice, LINK_STATE_UNKNOWN);

		umdevice->dev_var.indLink   = 0;
		umdevice->dev_var.indMedium = 0;
	}

	mutex_exit(&umdevice->os_param.gld_mutex);
}



/*
 * Name:    bnx_m_unicast
 *
 * Input:   ptr to driver device structure,
 *          pointer to buffer containing MAC address.
 *
 * Return:  DDI_SUCCESS or DDI_FAILURE
 *
 * Description:
 */
static int
bnx_m_unicast(void *arg, const uint8_t *macaddr)
{
	int rc;
	um_device_t *umdevice;
	lm_device_t *lmdevice;

	umdevice = (um_device_t *)arg;
	lmdevice = &(umdevice->lm_dev);

	mutex_enter(&umdevice->os_param.gld_mutex);

	/* Validate MAC address */
	if (IS_ETH_MULTICAST(macaddr)) {
		cmn_err(CE_WARN, "%s: Attempt to program a multicast / "
		    "broadcast address as a MAC address.", umdevice->dev_name);
		rc = EINVAL;
		goto done;
	}

	if (umdevice->dev_start == B_TRUE) {
		if (lm_set_mac_addr(lmdevice, 0,
		    &(lmdevice->params.mac_addr[0])) != LM_STATUS_SUCCESS) {
			cmn_err(CE_WARN, "%s: failed to program MAC address.",
			    umdevice->dev_name);
			rc = EIO;
			goto done;
		}
	}

	bcopy(macaddr, &(lmdevice->params.mac_addr[0]), ETHERADDRL);

	rc = 0;

done:
	mutex_exit(&umdevice->os_param.gld_mutex);

	return (rc);
}

static int
bnx_mc_add(um_device_t *umdevice, const uint8_t *const mc_addr)
{
	int rc;
	int index;
	lm_status_t   lmstatus;
	lm_device_t *lmdevice;

	lmdevice = &(umdevice->lm_dev);

	index = bnx_find_mchash_collision(&(lmdevice->mc_table), mc_addr);
	if (index == -1) {
		lmstatus = lm_add_mc(lmdevice, (u8_t *)mc_addr);
		if (lmstatus == LM_STATUS_SUCCESS) {
			umdevice->dev_var.rx_filter_mask |=
			    LM_RX_MASK_ACCEPT_MULTICAST;
			rc = 0;
		} else {
			rc = ENOMEM;
		}
	} else {
		lmdevice->mc_table.addr_arr[index].ref_cnt++;
		rc = 0;
	}

	return (rc);
}

static int
bnx_mc_del(um_device_t *umdevice, const uint8_t *const mc_addr)
{
	int rc;
	int index;
	lm_status_t lmstatus;
	lm_device_t *lmdevice;

	lmdevice = &(umdevice->lm_dev);

	index = bnx_find_mchash_collision(&(lmdevice->mc_table), mc_addr);
	if (index == -1) {
		rc = ENXIO;
	} else {
		lmstatus = lm_del_mc(lmdevice,
		    lmdevice->mc_table.addr_arr[index].mc_addr);
		if (lmstatus == LM_STATUS_SUCCESS) {
			if (lmdevice->mc_table.entry_cnt == 0) {
				umdevice->dev_var.rx_filter_mask &=
				    ~LM_RX_MASK_ACCEPT_MULTICAST;
			}

			rc = 0;
		} else {
			rc = ENXIO;
		}
	}

	return (rc);
}



/*
 * Name:    bnx_m_multicast
 *
 * Input:   ptr to driver device structure,
 *          boolean describing whether to enable or disable this address,
 *          pointer to buffer containing multicast address.
 *
 * Return:  DDI_SUCCESS or DDI_FAILURE
 *
 * Description:
 *          This function is used to enable or disable multicast packet
 *          reception for particular multicast addresses.
 */
static int
bnx_m_multicast(void * arg, boolean_t multiflag, const uint8_t *multicastaddr)
{
	um_device_t *umdevice;
	int rc;

	umdevice = (um_device_t *)arg;

	mutex_enter(&umdevice->os_param.gld_mutex);

	if (umdevice->dev_start != B_TRUE) {
		rc = EAGAIN;
		goto done;
	}

	switch (multiflag) {
		case B_TRUE:
			rc = bnx_mc_add(umdevice, multicastaddr);
			break;

		case B_FALSE:
			rc = bnx_mc_del(umdevice, multicastaddr);
			break;

		default:
			rc = EINVAL;
			break;
	}

done:
	mutex_exit(&umdevice->os_param.gld_mutex);

	return (rc);
}



/*
 * Name:    bnx_m_promiscuous
 *
 * Input:   ptr to driver device structure,
 *          boolean describing whether to enable or disable promiscuous mode.
 *
 * Return:  DDI_SUCCESS or DDI_FAILURE
 *
 * Description:
 *          This function enables promiscuous mode for this device.
 *		'flags' argument determines the type of mode being set,
 *		"PROMISC_PHY" enables reception of all packet types including
 *		bad/error packets. "PROMISC_MULTI" mode will enable all
 *		multicast packets, unicasts and broadcast packets to be
 *		received. "PROMISC_NONE" will enable only broadcast and
 *		unicast packets.
 */
static int
bnx_m_promiscuous(void *arg, boolean_t promiscflag)
{
	int rc;
	um_device_t *umdevice;

	umdevice = (um_device_t *)arg;

	mutex_enter(&umdevice->os_param.gld_mutex);

	if (umdevice->dev_start != B_TRUE) {
		rc = EAGAIN;
		goto done;
	}

	switch (promiscflag) {
		case B_TRUE:
			umdevice->dev_var.rx_filter_mask |=
			    LM_RX_MASK_PROMISCUOUS_MODE;
			break;

		case B_FALSE:
			umdevice->dev_var.rx_filter_mask &=
			    ~LM_RX_MASK_PROMISCUOUS_MODE;
			break;

		default:
			rc = EINVAL;
			goto done;
	}

	(void) lm_set_rx_mask(&(umdevice->lm_dev), RX_FILTER_USER_IDX0,
	    umdevice->dev_var.rx_filter_mask);

	rc = 0;

done:
	mutex_exit(&umdevice->os_param.gld_mutex);

	return (rc);
}


static mblk_t *
bnx_m_tx(void *arg, mblk_t *mp)
{
	int rc;
	mblk_t *nmp;
	um_device_t *umdevice;

	umdevice = (um_device_t *)arg;

	rw_enter(&umdevice->os_param.gld_snd_mutex, RW_READER);

	if (umdevice->dev_start != B_TRUE ||
	    umdevice->nddcfg.link_speed == 0) {
		freemsgchain(mp);
		mp = NULL;
		goto done;
	}

	nmp = NULL;

	while (mp) {
		/* Save the next pointer, in case we do double copy. */
		nmp = mp->b_next;
		mp->b_next = NULL;

		rc = bnx_xmit_ring_xmit_mblk(umdevice, 0, mp);

		if (rc == BNX_SEND_GOODXMIT) {
			mp = nmp;
			continue;
		}

		if (rc == BNX_SEND_DEFERPKT)
			mp = nmp;
		else
			mp->b_next = nmp;

		break;
	}

done:
	rw_exit(&umdevice->os_param.gld_snd_mutex);

	return (mp);
}


static u64_t
shift_left32(u32_t val)
{
	lm_u64_t tmp;

	/* FIXME -- Get rid of shift_left32() */

	tmp.as_u32.low = 0;
	tmp.as_u32.high = val;

	return (tmp.as_u64);
}

static mac_ether_media_t
bnx_um_to_media(um_device_t *um)
{
	if (um->nddcfg.link_speed == 0) {
		return (ETHER_MEDIA_NONE);
	}

	/*
	 * bnx only supports 2.5G and 1G fiber. It does not support 100BASE-FX.
	 * Similarly, it is too old to support 2500BASE-T and the NetExtreme II
	 * programmer's guide makes it clear it only ever supported 100BASE-TX
	 * and never -T2 or -T4.
	 */
	if (um->dev_var.isfiber) {
		switch (um->nddcfg.link_speed) {
		case 2500:
			return (ETHER_MEDIA_2500BASE_X);
		case 1000:
			return (ETHER_MEDIA_1000BASE_X);
		default:
			break;
		}
	} else {
		switch (um->nddcfg.link_speed) {
		case 1000:
			return (ETHER_MEDIA_1000BASE_T);
		case 100:
			return (ETHER_MEDIA_100BASE_TX);
		case 10:
			return (ETHER_MEDIA_10BASE_T);
		default:
			break;
		}
	}

	return (ETHER_MEDIA_UNKNOWN);
}

/*
 * Name:    bnx_m_stats
 *
 * Input:   ptr to mac info structure, ptr to gld_stats struct
 *
 * Return:  DDI_SUCCESS or DDI_FAILURE
 *
 * Description: bnx_m_stats() populates gld_stats structure elements
 *              from latest data from statistic block.
 */
static int
bnx_m_stats(void * arg, uint_t stat, uint64_t *val)
{
	int rc;
	um_device_t *umdevice;
	lm_device_t *lmdevice;
	const bnx_lnk_cfg_t *linkconf;

	umdevice = (um_device_t *)arg;

	if (umdevice == NULL || val == NULL) {
		return (EINVAL);
	}

	lmdevice = &(umdevice->lm_dev);

	/* FIXME -- Fix STATS collections */

	if (umdevice->dev_var.isfiber) {
		linkconf = &bnx_serdes_config;
	} else {
		linkconf = &bnx_copper_config;
	}

	mutex_enter(&umdevice->os_param.gld_mutex);

	if (umdevice->dev_start != B_TRUE) {
		rc = EAGAIN;
		goto done;
	}

	*val = 0;
	switch (stat) {
	case MAC_STAT_IFSPEED:
		*val = umdevice->nddcfg.link_speed * 1000000ull;
		break;
	case MAC_STAT_MULTIRCV:
		*val += shift_left32(
		    lmdevice->vars.stats_virt->stat_IfHCInMulticastPkts_hi);
		*val +=
		    lmdevice->vars.stats_virt->stat_IfHCInMulticastPkts_lo;
		break;
	case MAC_STAT_BRDCSTRCV:
		*val += shift_left32(
		    lmdevice->vars.stats_virt->stat_IfHCInBroadcastPkts_hi);
		*val +=
		    lmdevice->vars.stats_virt->stat_IfHCInBroadcastPkts_lo;
		break;
	case MAC_STAT_MULTIXMT:
		*val += shift_left32(
		    lmdevice->vars.stats_virt->stat_IfHCOutMulticastPkts_hi);
		*val +=
		    lmdevice->vars.stats_virt->stat_IfHCOutMulticastPkts_lo;
		break;
	case MAC_STAT_BRDCSTXMT:
		*val += shift_left32(
		    lmdevice->vars.stats_virt->stat_IfHCOutBroadcastPkts_hi);
		*val +=
		    lmdevice->vars.stats_virt->stat_IfHCOutBroadcastPkts_lo;
		break;
	case MAC_STAT_NORCVBUF:
		*val = lmdevice->vars.stats_virt->stat_IfInMBUFDiscards;
		break;
	case ETHER_STAT_MACRCV_ERRORS:
	case MAC_STAT_IERRORS:
		*val = lmdevice->vars.stats_virt->stat_Dot3StatsFCSErrors +
		    lmdevice->vars.stats_virt->stat_Dot3StatsAlignmentErrors +
		    lmdevice->vars.stats_virt->stat_EtherStatsUndersizePkts +
		    lmdevice->vars.stats_virt->stat_EtherStatsOverrsizePkts;
		break;
	case MAC_STAT_OERRORS:
		*val = lmdevice->vars.stats_virt->
		    stat_emac_tx_stat_dot3statsinternalmactransmiterrors;
		break;
	case MAC_STAT_COLLISIONS:
		*val = lmdevice->vars.stats_virt->stat_EtherStatsCollisions;
		break;
	case MAC_STAT_RBYTES:
		*val += shift_left32(
		    lmdevice->vars.stats_virt->stat_IfHCInOctets_hi);
		*val +=
		    lmdevice->vars.stats_virt->stat_IfHCInOctets_lo;
		break;
	case MAC_STAT_IPACKETS:
		*val += shift_left32(lmdevice->vars.stats_virt->
		    stat_IfHCInUcastPkts_hi);
		*val += lmdevice->vars.stats_virt->stat_IfHCInUcastPkts_lo;

		*val += shift_left32(lmdevice->vars.stats_virt->
		    stat_IfHCInMulticastPkts_hi);
		*val += lmdevice->vars.stats_virt->stat_IfHCInMulticastPkts_lo;

		*val += shift_left32(lmdevice->vars.stats_virt->
		    stat_IfHCInBroadcastPkts_hi);
		*val += lmdevice->vars.stats_virt->stat_IfHCInBroadcastPkts_lo;
		break;
	case MAC_STAT_OBYTES:
		*val += shift_left32(
		    lmdevice->vars.stats_virt->stat_IfHCOutOctets_hi);
		*val +=
		    lmdevice->vars.stats_virt->stat_IfHCOutOctets_lo;
		break;
	case MAC_STAT_OPACKETS:
		*val += shift_left32(lmdevice->vars.stats_virt->
		    stat_IfHCOutUcastPkts_hi);
		*val += lmdevice->vars.stats_virt->stat_IfHCOutUcastPkts_lo;

		*val += shift_left32(lmdevice->vars.stats_virt->
		    stat_IfHCOutMulticastPkts_hi);
		*val += lmdevice->vars.stats_virt->stat_IfHCOutMulticastPkts_lo;

		*val += shift_left32(lmdevice->vars.stats_virt->
		    stat_IfHCOutBroadcastPkts_hi);
		*val += lmdevice->vars.stats_virt->stat_IfHCOutBroadcastPkts_lo;
		break;
	case ETHER_STAT_ALIGN_ERRORS:
		*val = lmdevice->vars.stats_virt->stat_Dot3StatsAlignmentErrors;
		break;
	case ETHER_STAT_FCS_ERRORS:
		*val = lmdevice->vars.stats_virt->stat_Dot3StatsFCSErrors;
		break;
	case ETHER_STAT_FIRST_COLLISIONS:
		*val = lmdevice->vars.stats_virt->
		    stat_Dot3StatsSingleCollisionFrames;
		break;
	case ETHER_STAT_MULTI_COLLISIONS:
		*val = lmdevice->vars.stats_virt->
		    stat_Dot3StatsMultipleCollisionFrames;
		break;
	case ETHER_STAT_DEFER_XMTS:
		*val = lmdevice->vars.stats_virt->
		    stat_Dot3StatsDeferredTransmissions;
		break;
	case ETHER_STAT_TX_LATE_COLLISIONS:
		*val = lmdevice->vars.stats_virt->
		    stat_Dot3StatsLateCollisions;
		break;
	case ETHER_STAT_EX_COLLISIONS:
		*val = lmdevice->vars.stats_virt->
		    stat_Dot3StatsExcessiveCollisions;
		break;
	case ETHER_STAT_MACXMT_ERRORS:
		*val = lmdevice->vars.stats_virt->
		    stat_emac_tx_stat_dot3statsinternalmactransmiterrors;
		break;
	case ETHER_STAT_CARRIER_ERRORS:
		*val = lmdevice->vars.stats_virt->
		    stat_Dot3StatsCarrierSenseErrors;
		break;
	case ETHER_STAT_TOOLONG_ERRORS:
		*val = lmdevice->vars.stats_virt->
		    stat_EtherStatsOverrsizePkts;
		break;
#if (MAC_VERSION > 1)
	case ETHER_STAT_TOOSHORT_ERRORS:
		*val = lmdevice->vars.stats_virt->
		    stat_EtherStatsUndersizePkts;
		break;
#endif
	case ETHER_STAT_XCVR_ADDR:
		*val = lmdevice->params.phy_addr;
		break;
	case ETHER_STAT_XCVR_ID:
		*val = lmdevice->hw_info.phy_id;
		break;
	case ETHER_STAT_XCVR_INUSE:
		*val = (uint64_t)bnx_um_to_media(umdevice);
		break;
	case ETHER_STAT_CAP_1000FDX:
		*val = 1;
		break;
	case ETHER_STAT_CAP_1000HDX:
		*val = linkconf->param_1000hdx;
		break;
	case ETHER_STAT_CAP_100FDX:
		*val = linkconf->param_100fdx;
		break;
	case ETHER_STAT_CAP_100HDX:
		*val = linkconf->param_100hdx;
		break;
	case ETHER_STAT_CAP_10FDX:
		*val = linkconf->param_10fdx;
		break;
	case ETHER_STAT_CAP_10HDX:
		*val = linkconf->param_10hdx;
		break;
	case ETHER_STAT_CAP_ASMPAUSE:
		*val = 1;
		break;
	case ETHER_STAT_CAP_PAUSE:
		*val = 1;
		break;
	case ETHER_STAT_CAP_AUTONEG:
		*val = 1;
		break;
#if (MAC_VERSION > 1)
	case ETHER_STAT_CAP_REMFAULT:
		*val = 1;
		break;
#endif
	case ETHER_STAT_ADV_CAP_1000FDX:
		*val = umdevice->curcfg.lnkcfg.param_1000fdx;
		break;
	case ETHER_STAT_ADV_CAP_1000HDX:
		*val = umdevice->curcfg.lnkcfg.param_1000hdx;
		break;
	case ETHER_STAT_ADV_CAP_100FDX:
		*val = umdevice->curcfg.lnkcfg.param_100fdx;
		break;
	case ETHER_STAT_ADV_CAP_100HDX:
		*val = umdevice->curcfg.lnkcfg.param_100hdx;
		break;
	case ETHER_STAT_ADV_CAP_10FDX:
		*val = umdevice->curcfg.lnkcfg.param_10fdx;
		break;
	case ETHER_STAT_ADV_CAP_10HDX:
		*val = umdevice->curcfg.lnkcfg.param_10hdx;
		break;
	case ETHER_STAT_ADV_CAP_ASMPAUSE:
		*val = 1;
		break;
	case ETHER_STAT_ADV_CAP_PAUSE:
		*val = 1;
		break;
	case ETHER_STAT_ADV_CAP_AUTONEG:
		*val = umdevice->curcfg.lnkcfg.link_autoneg;
		break;
#if (MAC_VERSION > 1)
	case ETHER_STAT_ADV_REMFAULT:
		*val = 1;
		break;
#endif
	case ETHER_STAT_LP_CAP_1000FDX:
		*val = umdevice->remote.param_1000fdx;
		break;
	case ETHER_STAT_LP_CAP_1000HDX:
		*val = umdevice->remote.param_1000hdx;
		break;
	case ETHER_STAT_LP_CAP_100FDX:
		*val = umdevice->remote.param_100fdx;
		break;
	case ETHER_STAT_LP_CAP_100HDX:
		*val = umdevice->remote.param_100hdx;
		break;
	case ETHER_STAT_LP_CAP_10FDX:
		*val = umdevice->remote.param_10fdx;
		break;
	case ETHER_STAT_LP_CAP_10HDX:
		*val = umdevice->remote.param_10hdx;
		break;
	case ETHER_STAT_LP_CAP_ASMPAUSE:
		/* FIXME -- Implement LP_ASYM_PAUSE stat */
		break;
	case ETHER_STAT_LP_CAP_PAUSE:
		/* FIXME -- Implement LP_PAUSE stat */
		break;
	case ETHER_STAT_LP_CAP_AUTONEG:
		*val = umdevice->remote.link_autoneg;
		break;
#if (MAC_VERSION > 1)
	case ETHER_STAT_LP_REMFAULT:
		/* FIXME -- Implement LP_REMFAULT stat */
		break;
#endif
	case ETHER_STAT_LINK_ASMPAUSE:
		/* FIXME -- Implement ASMPAUSE stat */
		break;
	case ETHER_STAT_LINK_PAUSE:
		/* FIXME -- Implement PAUSE stat */
		break;
	case ETHER_STAT_LINK_AUTONEG:
		*val = umdevice->curcfg.lnkcfg.link_autoneg;
		break;
	case ETHER_STAT_LINK_DUPLEX:
		*val = umdevice->nddcfg.link_duplex == B_TRUE ?
		    LINK_DUPLEX_FULL: LINK_DUPLEX_HALF;
		break;
	default:
		rc = ENOTSUP;
	}

	rc = 0;

done:
	mutex_exit(&umdevice->os_param.gld_mutex);

	return (rc);
}

static boolean_t
bnx_m_getcapab(void *arg, mac_capab_t cap, void *cap_data)
{
	um_device_t *umdevice;

	umdevice = (um_device_t *)arg;

	switch (cap) {
	case MAC_CAPAB_HCKSUM: {
		uint32_t *txflags = cap_data;

		*txflags = 0;

		if (umdevice->dev_var.enabled_oflds &
		    (LM_OFFLOAD_TX_IP_CKSUM | LM_OFFLOAD_RX_IP_CKSUM)) {
			*txflags |= HCKSUM_IPHDRCKSUM;
		}

		if (umdevice->dev_var.enabled_oflds &
		    (LM_OFFLOAD_TX_TCP_CKSUM | LM_OFFLOAD_TX_UDP_CKSUM |
		    LM_OFFLOAD_RX_TCP_CKSUM | LM_OFFLOAD_RX_UDP_CKSUM)) {
			*txflags |= HCKSUM_INET_FULL_V4;
		}
		break;
	}
	default:
		return (B_FALSE);
	}

	return (B_TRUE);
}

static int
bnx_refresh_rx_tx_pkts(um_device_t *umdevice)
{
	if (umdevice->os_param.active_resc_flag & DRV_RESOURCE_HDWR_REGISTER) {
		bnx_hdwr_fini(umdevice);
		/*
		 * Initialize the adapter resource.  Mainly allocating memory
		 * needed by the driver, such as packet descriptors, shared
		 * memory, etc.
		 */
		if (lm_init_resc(&(umdevice->lm_dev)) != LM_STATUS_SUCCESS) {
			return (EIO);
		}

		if (bnx_txpkts_init(umdevice)) {
			return (EIO);
		}

		if (bnx_rxpkts_init(umdevice)) {
			return (EIO);
		}
	}
	return (0);
}

static int
bnx_set_priv_prop(um_device_t *umdevice, const char *pr_name,
    uint_t pr_valsize, const void *pr_val)
{
	boolean_t refresh = B_FALSE;
	long result;
	int err = 0;

	if (strcmp(pr_name, "_adv_2500fdx_cap") == 0) {
		if (lm_get_medium(&umdevice->lm_dev) != LM_MEDIUM_TYPE_FIBER) {
			return (ENOTSUP);
		}
		if (ddi_strtol(pr_val, (char **)NULL, 0, &result)) {
			return (EINVAL);
		}
		if (result != 1 && result != 0) {
			return (EINVAL);
		}
		if (umdevice->hwinit.lnkcfg.param_2500fdx != (uint32_t)result) {
			umdevice->hwinit.lnkcfg.param_2500fdx =
			    (uint32_t)result;
			umdevice->curcfg.lnkcfg.param_2500fdx =
			    (uint32_t)result;
			bnx_update_phy(umdevice);
		}
	} else if (strcmp(pr_name, "_checksum") == 0) {
		if (umdevice->dev_start == B_TRUE) {
			return (EBUSY);
		}
		if (ddi_strtol(pr_val, (char **)NULL, 0, &result)) {
			return (EINVAL);
		}
		switch (result) {
			case USER_OPTION_CKSUM_TX_ONLY:
				umdevice->dev_var.enabled_oflds =
				    LM_OFFLOAD_TX_IP_CKSUM |
				    LM_OFFLOAD_TX_TCP_CKSUM |
				    LM_OFFLOAD_TX_UDP_CKSUM;
				break;

			case USER_OPTION_CKSUM_RX_ONLY:
				umdevice->dev_var.enabled_oflds =
				    LM_OFFLOAD_RX_IP_CKSUM |
				    LM_OFFLOAD_RX_TCP_CKSUM |
				    LM_OFFLOAD_RX_UDP_CKSUM;
				break;

			case USER_OPTION_CKSUM_TX_RX:
				umdevice->dev_var.enabled_oflds =
				    LM_OFFLOAD_TX_IP_CKSUM |
				    LM_OFFLOAD_RX_IP_CKSUM |
				    LM_OFFLOAD_TX_TCP_CKSUM |
				    LM_OFFLOAD_RX_TCP_CKSUM |
				    LM_OFFLOAD_TX_UDP_CKSUM |
				    LM_OFFLOAD_RX_UDP_CKSUM;
				break;

			case USER_OPTION_CKSUM_NONE:
				umdevice->dev_var.enabled_oflds =
				    LM_OFFLOAD_NONE;
				break;

			default:
				return (EINVAL);
		}
	} else if (strcmp(pr_name, "_tx_descriptor_count") == 0) {
		if (umdevice->dev_start == B_TRUE) {
			return (EBUSY);
		}
		if (ddi_strtol(pr_val, (char **)NULL, 0, &result)) {
			return (EINVAL);
		}
		if (result < USER_OPTION_TX_DESC_CNT_MIN ||
		    result > USER_OPTION_TX_DESC_CNT_MAX) {
			return (EINVAL);
		}
		_TX_QINFO(umdevice, 0).desc_cnt = result;
		umdevice->lm_dev.params.l2_tx_bd_page_cnt[0] =
		    result / MAX_BD_PER_PAGE;
		if (result % MAX_BD_PER_PAGE) {
			umdevice->lm_dev.params.l2_tx_bd_page_cnt[0]++;
		}
		if (umdevice->lm_dev.params.l2_tx_bd_page_cnt[0] > 127) {
			umdevice->lm_dev.params.l2_tx_bd_page_cnt[0] = 127;
		}
		refresh = B_TRUE;
	} else if (strcmp(pr_name, "_rx_descriptor_count") == 0) {
		if (umdevice->dev_start == B_TRUE) {
			return (EBUSY);
		}
		if (ddi_strtol(pr_val, (char **)NULL, 0, &result)) {
			return (EINVAL);
		}
		if (result < USER_OPTION_RX_DESC_CNT_MIN ||
		    result > USER_OPTION_RX_DESC_CNT_MAX) {
			return (EINVAL);
		}
		umdevice->lm_dev.params.l2_rx_desc_cnt[0] = result;
		result = (result * BNX_RECV_MAX_FRAGS) / MAX_BD_PER_PAGE;
		umdevice->lm_dev.params.l2_rx_bd_page_cnt[0] = result;
		if (result % MAX_BD_PER_PAGE) {
			umdevice->lm_dev.params.l2_rx_bd_page_cnt[0]++;
		}
		refresh = B_TRUE;
	}
#if 0
	/* Initialized by init_hc() */
	else if (strcmp(pr_name, "_tx_coalesce_ticks") == 0) {
		if (umdevice->dev_start == B_TRUE) {
			return (EBUSY);
		}
		if (ddi_strtol(pr_val, (char **)NULL, 0, &result)) {
			return (EINVAL);
		}
		if (result < USER_OPTION_TICKS_MIN ||
		    result > USER_OPTION_TICKS_MAX) {
			return (EINVAL);
		}
		umdevice->lm_dev.params.tx_ticks = result;
	} else if (strcmp(pr_name, "_tx_coalesce_ticks_int") == 0) {
		if (umdevice->dev_start == B_TRUE) {
			return (EBUSY);
		}
		if (ddi_strtol(pr_val, (char **)NULL, 0, &result)) {
			return (EINVAL);
		}
		if (result < USER_OPTION_TICKS_INT_MIN ||
		    result > USER_OPTION_TICKS_INT_MAX) {
			return (EINVAL);
		}
		umdevice->lm_dev.params.tx_ticks_int = result;
	} else if (strcmp(pr_name, "_rx_coalesce_ticks") == 0) {
		if (umdevice->dev_start == B_TRUE) {
			return (EBUSY);
		}
		if (ddi_strtol(pr_val, (char **)NULL, 0, &result)) {
			return (EINVAL);
		}
		if (result < USER_OPTION_TICKS_MIN ||
		    result > USER_OPTION_TICKS_MAX) {
			return (EINVAL);
		}
		umdevice->lm_dev.params.rx_ticks = result;
	} else if (strcmp(pr_name, "_rx_coalesce_ticks_int") == 0) {
		if (umdevice->dev_start == B_TRUE) {
			return (EBUSY);
		}
		if (ddi_strtol(pr_val, (char **)NULL, 0, &result)) {
			return (EINVAL);
		}
		if (result < USER_OPTION_TICKS_INT_MIN ||
		    result > USER_OPTION_TICKS_INT_MAX) {
			return (EINVAL);
		}
		umdevice->lm_dev.params.rx_ticks_int = result;
	} else if (strcmp(pr_name, "_tx_coalesce_frames") == 0) {
		if (umdevice->dev_start == B_TRUE) {
			return (EBUSY);
		}
		if (ddi_strtol(pr_val, (char **)NULL, 0, &result)) {
			return (EINVAL);
		}
		if (result < USER_OPTION_FRAMES_MIN ||
		    result > USER_OPTION_FRAMES_MAX) {
			return (EINVAL);
		}
		umdevice->lm_dev.params.tx_quick_cons_trip = result;
	} else if (strcmp(pr_name, "_tx_coalesce_frames_int") == 0) {
		if (umdevice->dev_start == B_TRUE) {
			return (EBUSY);
		}
		if (ddi_strtol(pr_val, (char **)NULL, 0, &result)) {
			return (EINVAL);
		}
		if (result < USER_OPTION_FRAMES_MIN ||
		    result > USER_OPTION_FRAMES_MAX) {
			return (EINVAL);
		}
		umdevice->lm_dev.params.tx_quick_cons_trip_int = result;
	} else if (strcmp(pr_name, "_rx_coalesce_frames") == 0) {
		if (umdevice->dev_start == B_TRUE) {
			return (EBUSY);
		}
		if (ddi_strtol(pr_val, (char **)NULL, 0, &result)) {
			return (EINVAL);
		}
		if (result < USER_OPTION_FRAMES_MIN ||
		    result > USER_OPTION_FRAMES_MAX) {
			return (EINVAL);
		}
		umdevice->lm_dev.params.rx_quick_cons_trip = result;
	} else if (strcmp(pr_name, "_rx_coalesce_frames_int") == 0) {
		if (umdevice->dev_start == B_TRUE) {
			return (EBUSY);
		}
		if (ddi_strtol(pr_val, (char **)NULL, 0, &result)) {
			return (EINVAL);
		}
		if (result < USER_OPTION_FRAMES_MIN ||
		    result > USER_OPTION_FRAMES_MAX) {
			return (EINVAL);
		}
		umdevice->lm_dev.params.rx_quick_cons_trip_int = result;
	} else if (strcmp(pr_name, "_statticks") == 0) {
		if (umdevice->dev_start == B_TRUE) {
			return (EBUSY);
		}
		if (ddi_strtol(pr_val, (char **)NULL, 0, &result)) {
			return (EINVAL);
		}
		if (result < USER_OPTION_STATSTICKS_MIN ||
		    result > USER_OPTION_STATSTICKS_MAX) {
			return (EINVAL);
		}
		umdevice->lm_dev.params.stats_ticks = result;
	}
#endif
	else if (strcmp(pr_name, "_disable_msix") == 0) {
		err = ENOTSUP;
	} else {
		err = ENOTSUP;
	}

	if (!err && refresh) {
		err = bnx_refresh_rx_tx_pkts(umdevice);
	}
	return (err);
}


static int
bnx_m_setprop(void *arg, const char *pr_name, mac_prop_id_t pr_num,
    uint_t pr_valsize, const void *pr_val)
{
	um_device_t *umdevice = arg;
	boolean_t reprogram = B_FALSE;
	boolean_t rxpause;
	boolean_t txpause;
	uint32_t mtu;
	link_flowctrl_t fl;
	int err = 0;

	mutex_enter(&umdevice->os_param.gld_mutex);

	if (lm_get_medium(&umdevice->lm_dev) == LM_MEDIUM_TYPE_FIBER) {
		if (pr_num == MAC_PROP_EN_100FDX_CAP ||
		    pr_num == MAC_PROP_EN_100HDX_CAP ||
		    pr_num == MAC_PROP_EN_10FDX_CAP ||
		    pr_num == MAC_PROP_EN_10HDX_CAP) {
			mutex_exit(&umdevice->os_param.gld_mutex);
			return (ENOTSUP);
		}
	}

	switch (pr_num) {
		/* read-only properties */
		case MAC_PROP_ADV_1000FDX_CAP:
		case MAC_PROP_ADV_1000HDX_CAP:
		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_STATUS:
		case MAC_PROP_SPEED:
		case MAC_PROP_DUPLEX:
		case MAC_PROP_MEDIA:
		default:

			err = ENOTSUP;
			break;


/* BEGIN CSTYLED */
#define	BNX_SETPROP_CASE(cap, param)							\
		case cap:								\
			if (umdevice->hwinit.lnkcfg.param != *(uint8_t *)pr_val) {	\
				umdevice->hwinit.lnkcfg.param = *(uint8_t *)pr_val;	\
				umdevice->curcfg.lnkcfg.param = *(uint8_t *)pr_val;	\
				reprogram = B_TRUE;					\
			}								\
			break
/* END CSTYLED */


		BNX_SETPROP_CASE(MAC_PROP_EN_1000FDX_CAP, param_1000fdx);
		BNX_SETPROP_CASE(MAC_PROP_EN_1000HDX_CAP, param_1000hdx);
		BNX_SETPROP_CASE(MAC_PROP_EN_100FDX_CAP, param_100fdx);
		BNX_SETPROP_CASE(MAC_PROP_EN_100HDX_CAP, param_100hdx);
		BNX_SETPROP_CASE(MAC_PROP_EN_10FDX_CAP, param_10fdx);
		BNX_SETPROP_CASE(MAC_PROP_EN_10HDX_CAP, param_10hdx);
		BNX_SETPROP_CASE(MAC_PROP_AUTONEG, link_autoneg);

		case MAC_PROP_FLOWCTRL:
			bcopy(pr_val, &fl, sizeof (fl));
			switch (fl) {
				case LINK_FLOWCTRL_NONE:

					rxpause = B_FALSE;
					txpause = B_FALSE;
					break;

				case LINK_FLOWCTRL_RX:

					rxpause = B_TRUE;
					txpause = B_FALSE;
					break;

				case LINK_FLOWCTRL_TX:

					rxpause = B_FALSE;
					txpause = B_TRUE;
					break;

				case LINK_FLOWCTRL_BI:

					rxpause = B_TRUE;
					txpause = B_TRUE;
					break;

				default:

					err = ENOTSUP;
					break;
			}

			if (err == 0) {
				if (umdevice->hwinit.lnkcfg.param_tx_pause !=
				    txpause ||
				    umdevice->hwinit.lnkcfg.param_rx_pause !=
				    rxpause) {
					umdevice->hwinit.lnkcfg.param_tx_pause =
					    txpause;
					umdevice->hwinit.lnkcfg.param_rx_pause =
					    rxpause;
					umdevice->curcfg.lnkcfg.param_tx_pause =
					    txpause;
					umdevice->curcfg.lnkcfg.param_rx_pause =
					    rxpause;
					reprogram = B_TRUE;
				}
			}

			break;

		case MAC_PROP_MTU:
			if (umdevice->dev_start == B_TRUE) {
				err = EBUSY;
				break;
			}

			bcopy(pr_val, &mtu, sizeof (mtu));

			if (mtu < USER_OPTION_MTU_MIN ||
			    mtu > USER_OPTION_MTU_MAX) {
				err = EINVAL;
				break;
			}

			if (umdevice->dev_var.mtu == mtu) {
				break;
			}

			umdevice->dev_var.mtu = mtu;
			umdevice->lm_dev.params.mtu = umdevice->dev_var.mtu
			    + sizeof (struct ether_header) + VLAN_TAGSZ;

			if (bnx_refresh_rx_tx_pkts(umdevice) != 0) {
				err = EIO;
			} else {
				reprogram = B_TRUE;
			}
			break;

		case MAC_PROP_PRIVATE:
			err = bnx_set_priv_prop(umdevice, pr_name, pr_valsize,
			    pr_val);
			reprogram = B_TRUE;
			break;
	}

	if (!err && reprogram) {
		bnx_update_phy(umdevice);
	}

	mutex_exit(&umdevice->os_param.gld_mutex);

	return (err);
}

static int
bnx_get_priv_prop(um_device_t *umdevice, const char *pr_name,
    uint_t pr_valsize, void *pr_val)
{
	int value;

	if (strcmp(pr_name, "_adv_2500fdx_cap") == 0) {
		if (lm_get_medium(&umdevice->lm_dev) !=
		    LM_MEDIUM_TYPE_FIBER) {
			return (ENOTSUP);
		}
		value = umdevice->curcfg.lnkcfg.param_2500fdx;
	} else if (strcmp(pr_name, "_checksum") == 0) {
		value = umdevice->dev_var.enabled_oflds;
	} else if (strcmp(pr_name, "_tx_descriptor_count") == 0) {
		value = _TX_QINFO(umdevice, 0).desc_cnt;
	} else if (strcmp(pr_name, "_rx_descriptor_count") == 0) {
		value = umdevice->lm_dev.params.l2_rx_desc_cnt[0];
	} else if (strcmp(pr_name, "_tx_coalesce_ticks") == 0) {
		value = umdevice->lm_dev.params.tx_ticks;
	} else if (strcmp(pr_name, "_tx_coalesce_ticks_int") == 0) {
		value = umdevice->lm_dev.params.tx_ticks_int;
	} else if (strcmp(pr_name, "_rx_coalesce_ticks") == 0) {
		value = umdevice->lm_dev.params.rx_ticks;
	} else if (strcmp(pr_name, "_rx_coalesce_ticks_int") == 0) {
		value = umdevice->lm_dev.params.rx_ticks_int;
	} else if (strcmp(pr_name, "_tx_coalesce_frames") == 0) {
		value = umdevice->lm_dev.params.tx_quick_cons_trip;
	} else if (strcmp(pr_name, "_tx_coalesce_frames_int") == 0) {
		value = umdevice->lm_dev.params.tx_quick_cons_trip_int;
	} else if (strcmp(pr_name, "_rx_coalesce_frames") == 0) {
		value = umdevice->lm_dev.params.rx_quick_cons_trip;
	} else if (strcmp(pr_name, "_rx_coalesce_frames_int") == 0) {
		value = umdevice->lm_dev.params.rx_quick_cons_trip_int;
	} else if (strcmp(pr_name, "_statticks") == 0) {
		value = umdevice->lm_dev.params.stats_ticks;
	} else if (strcmp(pr_name, "_disable_msix") == 0) {
		value = umdevice->dev_var.disableMsix;
	} else {
		return (ENOTSUP);
	}

	(void) snprintf(pr_val, pr_valsize, "%d", value);
	return (0);

}

static int
bnx_m_getprop(void *arg, const char *pr_name, mac_prop_id_t pr_num,
    uint_t pr_valsize, void *pr_val)
{
	um_device_t *umdevice = arg;
	link_duplex_t link_duplex;
	uint64_t link_speed;
	link_state_t link_state;
	link_flowctrl_t fl;
	mac_ether_media_t media;

	if (lm_get_medium(&umdevice->lm_dev) == LM_MEDIUM_TYPE_FIBER) {
		if (pr_num == MAC_PROP_EN_100FDX_CAP ||
		    pr_num == MAC_PROP_EN_100HDX_CAP ||
		    pr_num == MAC_PROP_EN_10FDX_CAP ||
		    pr_num == MAC_PROP_EN_10HDX_CAP) {
			return (ENOTSUP);
		}
	}

	switch (pr_num) {
		case MAC_PROP_DUPLEX:
			link_duplex = umdevice->nddcfg.link_duplex == B_TRUE ?
			    LINK_DUPLEX_FULL: LINK_DUPLEX_HALF;

			ASSERT(pr_valsize >= sizeof (link_duplex_t));

			bcopy(&link_duplex, pr_val, sizeof (link_duplex_t));
			break;

		case MAC_PROP_SPEED:
			link_speed = umdevice->nddcfg.link_speed * 1000000ull;

			ASSERT(pr_valsize >= sizeof (link_speed));

			bcopy(&link_speed, pr_val, sizeof (link_speed));
			break;

		case MAC_PROP_STATUS:
			link_state = umdevice->nddcfg.link_speed ?
			    LINK_STATE_UP : LINK_STATE_DOWN;

			ASSERT(pr_valsize >= sizeof (link_state_t));

			bcopy(&link_state, pr_val, sizeof (link_state));
			break;

		case MAC_PROP_MEDIA:
			media = bnx_um_to_media(umdevice);

			ASSERT(pr_valsize >= sizeof (mac_ether_media_t));

			bcopy(&media, pr_val, sizeof (link_state));
			break;

		case MAC_PROP_AUTONEG:
			*(uint8_t *)pr_val =
			    umdevice->curcfg.lnkcfg.link_autoneg;
			break;

		case MAC_PROP_FLOWCTRL:
			ASSERT(pr_valsize >= sizeof (fl));

			boolean_t txpause =
			    umdevice->curcfg.lnkcfg.param_tx_pause;
			boolean_t rxpause =
			    umdevice->curcfg.lnkcfg.param_rx_pause;
			if (txpause) {
				if (rxpause) {
					fl = LINK_FLOWCTRL_BI;
				} else {
					fl = LINK_FLOWCTRL_TX;
				}
			} else {
				if (rxpause) {
					fl = LINK_FLOWCTRL_RX;
				} else {
					fl = LINK_FLOWCTRL_NONE;
				}
			}
			bcopy(&fl, pr_val, sizeof (fl));
			break;

		case MAC_PROP_ADV_1000FDX_CAP:
			*(uint8_t *)pr_val =
			    umdevice->curcfg.lnkcfg.param_1000fdx;
			break;

		case MAC_PROP_EN_1000FDX_CAP:
			*(uint8_t *)pr_val =
			    umdevice->curcfg.lnkcfg.param_1000fdx;
			break;

		case MAC_PROP_ADV_1000HDX_CAP:
			*(uint8_t *)pr_val =
			    umdevice->curcfg.lnkcfg.param_1000hdx;
			break;

		case MAC_PROP_EN_1000HDX_CAP:
			*(uint8_t *)pr_val =
			    umdevice->curcfg.lnkcfg.param_1000hdx;
			break;

		case MAC_PROP_ADV_100FDX_CAP:
			*(uint8_t *)pr_val =
			    umdevice->curcfg.lnkcfg.param_100fdx;
			break;

		case MAC_PROP_EN_100FDX_CAP:
			*(uint8_t *)pr_val =
			    umdevice->curcfg.lnkcfg.param_100fdx;
			break;

		case MAC_PROP_ADV_100HDX_CAP:
			*(uint8_t *)pr_val =
			    umdevice->curcfg.lnkcfg.param_100hdx;
			break;

		case MAC_PROP_EN_100HDX_CAP:
			*(uint8_t *)pr_val =
			    umdevice->curcfg.lnkcfg.param_100hdx;
			break;

		case MAC_PROP_ADV_10FDX_CAP:
			*(uint8_t *)pr_val =
			    umdevice->curcfg.lnkcfg.param_10fdx;
			break;

		case MAC_PROP_EN_10FDX_CAP:
			*(uint8_t *)pr_val =
			    umdevice->curcfg.lnkcfg.param_10fdx;
			break;

		case MAC_PROP_ADV_10HDX_CAP:
			*(uint8_t *)pr_val =
			    umdevice->curcfg.lnkcfg.param_10hdx;
			break;

		case MAC_PROP_EN_10HDX_CAP:
			*(uint8_t *)pr_val =
			    umdevice->curcfg.lnkcfg.param_10hdx;
			break;

		case MAC_PROP_PRIVATE:
			return (bnx_get_priv_prop(umdevice, pr_name, pr_valsize,
			    pr_val));

		default:

			return (ENOTSUP);

	}

	return (0);

}

static void
bnx_priv_propinfo(um_device_t *umdevice, const char *pr_name,
    mac_prop_info_handle_t prh)
{
	char valstr[64];
	int value;

	if (strcmp(pr_name, "_adv_2500fdx_cap") == 0) {
		if (lm_get_medium(&umdevice->lm_dev) != LM_MEDIUM_TYPE_FIBER) {
			return;
		}
		value = umdevice->curcfg.lnkcfg.param_2500fdx;
	} else if (strcmp(pr_name, "_checksum") == 0) {
		value = umdevice->dev_var.enabled_oflds;
	} else if (strcmp(pr_name, "_tx_descriptor_count") == 0) {
		value = _TX_QINFO(umdevice, 0).desc_cnt;
	} else if (strcmp(pr_name, "_rx_descriptor_count") == 0) {
		value = umdevice->lm_dev.params.l2_rx_desc_cnt[0];
	} else if (strcmp(pr_name, "_tx_coalesce_ticks") == 0) {
		value = umdevice->lm_dev.params.tx_ticks;
	} else if (strcmp(pr_name, "_tx_coalesce_ticks_int") == 0) {
		value = umdevice->lm_dev.params.tx_ticks_int;
	} else if (strcmp(pr_name, "_rx_coalesce_ticks") == 0) {
		value = umdevice->lm_dev.params.rx_ticks;
	} else if (strcmp(pr_name, "_rx_coalesce_ticks_int") == 0) {
		value = umdevice->lm_dev.params.rx_ticks_int;
	} else if (strcmp(pr_name, "_tx_coalesce_frames") == 0) {
		value = umdevice->lm_dev.params.tx_quick_cons_trip;
	} else if (strcmp(pr_name, "_tx_coalesce_frames_int") == 0) {
		value = umdevice->lm_dev.params.tx_quick_cons_trip_int;
	} else if (strcmp(pr_name, "_rx_coalesce_frames") == 0) {
		value = umdevice->lm_dev.params.rx_quick_cons_trip;
	} else if (strcmp(pr_name, "_rx_coalesce_frames_int") == 0) {
		value = umdevice->lm_dev.params.rx_quick_cons_trip_int;
	} else if (strcmp(pr_name, "_statticks") == 0) {
		value = umdevice->lm_dev.params.stats_ticks;
	} else if (strcmp(pr_name, "_disable_msix") == 0) {
		value = umdevice->dev_var.disableMsix;
	} else {
		return;
	}

	(void) snprintf(valstr, sizeof (valstr), "%d", value);
	mac_prop_info_set_default_str(prh, valstr);

}

static void
bnx_m_propinfo(void *arg, const char *pr_name, mac_prop_id_t pr_num,
    mac_prop_info_handle_t prh)
{
	um_device_t *umdevice = arg;

	if (lm_get_medium(&umdevice->lm_dev) == LM_MEDIUM_TYPE_FIBER) {
		if (pr_num == MAC_PROP_EN_100FDX_CAP ||
		    pr_num == MAC_PROP_ADV_100FDX_CAP ||
		    pr_num == MAC_PROP_EN_100HDX_CAP ||
		    pr_num == MAC_PROP_ADV_100HDX_CAP ||
		    pr_num == MAC_PROP_EN_10FDX_CAP ||
		    pr_num == MAC_PROP_ADV_10FDX_CAP ||
		    pr_num == MAC_PROP_EN_10HDX_CAP ||
		    pr_num == MAC_PROP_ADV_10HDX_CAP) {
			mac_prop_info_set_default_uint8(prh, 0);
			return;
		}
	}
	switch (pr_num) {
		case MAC_PROP_ADV_1000FDX_CAP:
		case MAC_PROP_ADV_1000HDX_CAP:
		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_STATUS:
		case MAC_PROP_SPEED:
		case MAC_PROP_DUPLEX:

			mac_prop_info_set_perm(prh, MAC_PROP_PERM_READ);
			break;

		case MAC_PROP_EN_1000FDX_CAP:

			mac_prop_info_set_default_uint8(prh, 1);
			break;

		case MAC_PROP_EN_1000HDX_CAP:
		case MAC_PROP_EN_100FDX_CAP:
		case MAC_PROP_EN_100HDX_CAP:
		case MAC_PROP_EN_10FDX_CAP:
		case MAC_PROP_EN_10HDX_CAP:

			if (lm_get_medium(&umdevice->lm_dev) ==
			    LM_MEDIUM_TYPE_FIBER) {
				mac_prop_info_set_default_uint8(prh, 0);
			} else {
				mac_prop_info_set_default_uint8(prh, 1);
			}
			break;

		case MAC_PROP_AUTONEG:

			mac_prop_info_set_default_uint8(prh, 1);
			break;

		case MAC_PROP_FLOWCTRL:

			mac_prop_info_set_default_link_flowctrl(prh,
			    LINK_FLOWCTRL_BI);
			break;

		case MAC_PROP_MTU:

			mac_prop_info_set_range_uint32(prh,
			    USER_OPTION_MTU_MIN, USER_OPTION_MTU_MAX);
			break;

		case MAC_PROP_PRIVATE:

			bnx_priv_propinfo(umdevice, pr_name, prh);
			break;
		default:
			break;
	}
}

static mac_callbacks_t bnx_callbacks = {
	(MC_GETCAPAB | MC_SETPROP | MC_GETPROP| MC_PROPINFO),
	bnx_m_stats,
	bnx_m_start,
	bnx_m_stop,
	bnx_m_promiscuous,
	bnx_m_multicast,
	bnx_m_unicast,
	bnx_m_tx,
	NULL,
	NULL,
	bnx_m_getcapab,
	NULL,
	NULL,
	bnx_m_setprop,
	bnx_m_getprop,
	bnx_m_propinfo
};



/*
 * Name:    bnx_gld_init
 *
 * Input:   ptr to device structure.
 *
 * Return:  DDI_SUCCESS or DDI_FAILURE
 *
 * Description:
 *          This routine populates mac info structure for this device
 *          instance and registers device with GLD.
 */
int
bnx_gld_init(um_device_t *const umdevice)
{
	mac_register_t *macp;
	int rc;

	umdevice->dev_start = B_FALSE;

	mutex_init(&umdevice->os_param.gld_mutex, NULL,
	    MUTEX_DRIVER, DDI_INTR_PRI(umdevice->intrPriority));

	rw_init(&umdevice->os_param.gld_snd_mutex, NULL, RW_DRIVER, NULL);

	macp = mac_alloc(MAC_VERSION);
	if (macp == NULL) {
		cmn_err(CE_WARN,
		    "%s: Failed to allocate GLD MAC memory.\n",
		    umdevice->dev_name);
		goto error;
	}

	macp->m_driver = umdevice;
	macp->m_dip = umdevice->os_param.dip;
	macp->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
	macp->m_callbacks = &bnx_callbacks;
	macp->m_min_sdu = 0;
	macp->m_max_sdu = umdevice->dev_var.mtu;
	macp->m_src_addr  = &(umdevice->lm_dev.params.mac_addr[0]);

	macp->m_margin = VLAN_TAG_SIZE;

	/*
	 * Call mac_register() after initializing all
	 * the required elements of mac_t struct.
	 */
	rc = mac_register(macp, &umdevice->os_param.macp);

	mac_free(macp);

	if (rc != 0) {
		cmn_err(CE_WARN,
		    "%s: Failed to register with GLD.\n",
		    umdevice->dev_name);
		goto error;
	}

	/* Always report the initial link state as unknown. */
	bnx_gld_link(umdevice, LINK_STATE_UNKNOWN);

	return (0);

error:
	rw_destroy(&umdevice->os_param.gld_snd_mutex);
	mutex_destroy(&umdevice->os_param.gld_mutex);

	return (-1);
}

void
bnx_gld_link(um_device_t * const umdevice, const link_state_t linkup)
{
	mac_link_update(umdevice->os_param.macp, linkup);
}

int
bnx_gld_fini(um_device_t * const umdevice)
{
	if (umdevice->dev_start != B_FALSE) {
		cmn_err(CE_WARN,
		    "%s: Detaching device from GLD that is still started!!!\n",
		    umdevice->dev_name);
		return (-1);
	}

	if (mac_unregister(umdevice->os_param.macp)) {
		cmn_err(CE_WARN,
		    "%s: Failed to unregister with the GLD.\n",
		    umdevice->dev_name);
		return (-1);
	}

	rw_destroy(&umdevice->os_param.gld_snd_mutex);
	mutex_destroy(&umdevice->os_param.gld_mutex);

	return (0);
}