/*
 * Copyright (c) 2008-2016 Solarflare Communications Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation are
 * those of the authors and should not be interpreted as representing official
 * policies, either expressed or implied, of the FreeBSD Project.
 */

#include <sys/types.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/stream.h>
#include <sys/strsun.h>
#include <sys/strsubr.h>
#include <sys/dlpi.h>
#include <sys/ksynch.h>
#include <sys/cpuvar.h>
#include <sys/cpu.h>
#include <sys/vlan.h>

#include <inet/tcp.h>

#include "sfxge.h"

void
sfxge_gld_link_update(sfxge_t *sp)
{
	sfxge_mac_t *smp = &(sp->s_mac);
	link_state_t link;

	switch (smp->sm_link_mode) {
	case EFX_LINK_UNKNOWN:
		link = LINK_STATE_UNKNOWN;
		break;
	case EFX_LINK_DOWN:
		link = LINK_STATE_DOWN;
		break;
	default:
		link = LINK_STATE_UP;
	}

	mac_link_update(sp->s_mh, link);
}

void
sfxge_gld_mtu_update(sfxge_t *sp)
{
#ifdef _USE_MTU_UPDATE
	(void) mac_maxsdu_update(sp->s_mh, sp->s_mtu);
#else
	_NOTE(ARGUNUSED(sp));
#endif
}

void
sfxge_gld_rx_post(sfxge_t *sp, unsigned int index, mblk_t *mp)
{
	_NOTE(ARGUNUSED(index))

	mac_rx(sp->s_mh, NULL, mp);
}


void
sfxge_gld_rx_push(sfxge_t *sp)
{
	_NOTE(ARGUNUSED(sp))
}


static uint64_t
sfxge_phy_dfl_cap_test64(sfxge_t *sp, uint32_t field)
{
	return (sfxge_phy_cap_test(sp, EFX_PHY_CAP_DEFAULT, field, NULL) ?
	    1ull : 0ull);
}


static uint64_t
sfxge_phy_cur_cap_test64(sfxge_t *sp, uint32_t field)
{
	return (sfxge_phy_cap_test(sp, EFX_PHY_CAP_CURRENT, field, NULL) ?
	    1ull : 0ull);
}

static uint64_t
sfxge_phy_lp_cap_test64(sfxge_t *sp, uint32_t field)
{
	return (sfxge_phy_lp_cap_test(sp, field) ? 1ull : 0ull);
}

static int
sfxge_gld_getstat(void *arg, unsigned int id, uint64_t *valp)
{
	sfxge_t *sp = arg;
	efx_nic_t *enp = sp->s_enp;
	int rc;

	if (sp->s_mac.sm_state != SFXGE_MAC_STARTED) {
		rc = ENODEV;
		goto fail1;
	}

	switch (id) {
	case MAC_STAT_IFSPEED: {
		unsigned int speed;

		sfxge_mac_link_speed_get(sp, &speed);

		*valp = (uint64_t)speed * 1000000ull;
		break;
	}
	case ETHER_STAT_LINK_DUPLEX: {
		sfxge_link_duplex_t duplex;

		sfxge_mac_link_duplex_get(sp, &duplex);

		switch (duplex) {
		case SFXGE_LINK_DUPLEX_UNKNOWN:
			*valp = LINK_DUPLEX_UNKNOWN;
			break;

		case SFXGE_LINK_DUPLEX_HALF:
			*valp = LINK_DUPLEX_HALF;
			break;

		case SFXGE_LINK_DUPLEX_FULL:
			*valp = LINK_DUPLEX_FULL;
			break;

		default:
			ASSERT(B_FALSE);
			break;
		}
		break;
	}

	case ETHER_STAT_CAP_40GFDX:
		*valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_40000FDX);
		break;
	case ETHER_STAT_CAP_10GFDX:
		*valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_10000FDX);
		break;
	case ETHER_STAT_CAP_1000FDX:
		*valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_1000FDX);
		break;
	case ETHER_STAT_CAP_1000HDX:
		*valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_1000HDX);
		break;
	case ETHER_STAT_CAP_100FDX:
		*valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_100FDX);
		break;
	case ETHER_STAT_CAP_100HDX:
		*valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_100HDX);
		break;
	case ETHER_STAT_CAP_10FDX:
		*valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_10FDX);
		break;
	case ETHER_STAT_CAP_10HDX:
		*valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_10HDX);
		break;
	case ETHER_STAT_CAP_ASMPAUSE:
		*valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_ASYM);
		break;
	case ETHER_STAT_CAP_PAUSE:
		*valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_PAUSE);
		break;
	case ETHER_STAT_CAP_AUTONEG:
		*valp = sfxge_phy_dfl_cap_test64(sp, EFX_PHY_CAP_AN);
		break;
	case ETHER_STAT_ADV_CAP_40GFDX:
		*valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_40000FDX);
		break;
	case ETHER_STAT_ADV_CAP_10GFDX:
		*valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_10000FDX);
		break;
	case ETHER_STAT_ADV_CAP_1000FDX:
		*valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_1000FDX);
		break;
	case ETHER_STAT_ADV_CAP_1000HDX:
		*valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_1000HDX);
		break;
	case ETHER_STAT_ADV_CAP_100FDX:
		*valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_100FDX);
		break;
	case ETHER_STAT_ADV_CAP_100HDX:
		*valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_100HDX);
		break;
	case ETHER_STAT_ADV_CAP_10FDX:
		*valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_10FDX);
		break;
	case ETHER_STAT_ADV_CAP_10HDX:
		*valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_10HDX);
		break;
	case ETHER_STAT_ADV_CAP_ASMPAUSE:
		*valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_ASYM);
		break;
	case ETHER_STAT_ADV_CAP_PAUSE:
		*valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_PAUSE);
		break;
	case ETHER_STAT_ADV_CAP_AUTONEG:
		*valp = sfxge_phy_cur_cap_test64(sp, EFX_PHY_CAP_AN);
		break;
	case ETHER_STAT_LP_CAP_40GFDX:
		*valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_40000FDX);
		break;
	case ETHER_STAT_LP_CAP_10GFDX:
		*valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_10000FDX);
		break;
	case ETHER_STAT_LP_CAP_1000FDX:
		*valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_1000FDX);
		break;
	case ETHER_STAT_LP_CAP_1000HDX:
		*valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_1000HDX);
		break;
	case ETHER_STAT_LP_CAP_100FDX:
		*valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_100FDX);
		break;
	case ETHER_STAT_LP_CAP_100HDX:
		*valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_100HDX);
		break;
	case ETHER_STAT_LP_CAP_10FDX:
		*valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_10FDX);
		break;
	case ETHER_STAT_LP_CAP_10HDX:
		*valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_10HDX);
		break;
	case ETHER_STAT_LP_CAP_ASMPAUSE:
		*valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_ASYM);
		break;
	case ETHER_STAT_LP_CAP_PAUSE:
		*valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_PAUSE);
		break;
	case ETHER_STAT_LP_CAP_AUTONEG:
		*valp = sfxge_phy_lp_cap_test64(sp, EFX_PHY_CAP_AN);
		break;

	case ETHER_STAT_XCVR_ADDR: {
		const efx_nic_cfg_t *encp = efx_nic_cfg_get(enp);
		*valp = encp->enc_port;
		break;
	}
	case ETHER_STAT_XCVR_ID: {
		uint32_t oui;

		if ((rc = efx_phy_oui_get(sp->s_enp, &oui)) != 0)
			goto fail2;
		*valp = oui;
		break;
	}
	case MAC_STAT_MULTIRCV:
		sfxge_mac_stat_get(sp, EFX_MAC_RX_MULTICST_PKTS, valp);
		break;

	case MAC_STAT_BRDCSTRCV:
		sfxge_mac_stat_get(sp, EFX_MAC_RX_BRDCST_PKTS, valp);
		break;

	case MAC_STAT_MULTIXMT:
		sfxge_mac_stat_get(sp, EFX_MAC_TX_MULTICST_PKTS, valp);
		break;

	case MAC_STAT_BRDCSTXMT:
		sfxge_mac_stat_get(sp, EFX_MAC_TX_BRDCST_PKTS, valp);
		break;

	case MAC_STAT_IERRORS:
		sfxge_mac_stat_get(sp, EFX_MAC_RX_ERRORS, valp);
		break;

	case MAC_STAT_OERRORS:
		sfxge_mac_stat_get(sp, EFX_MAC_TX_ERRORS, valp);
		break;

	case MAC_STAT_RBYTES:
		sfxge_mac_stat_get(sp, EFX_MAC_RX_OCTETS, valp);
		break;

	case MAC_STAT_IPACKETS:
		sfxge_mac_stat_get(sp, EFX_MAC_RX_PKTS, valp);
		break;

	case MAC_STAT_OBYTES:
		sfxge_mac_stat_get(sp, EFX_MAC_TX_OCTETS, valp);
		break;

	case MAC_STAT_OPACKETS:
		sfxge_mac_stat_get(sp, EFX_MAC_TX_PKTS, valp);
		break;

	case MAC_STAT_NORCVBUF:
		sfxge_mac_stat_get(sp, EFX_MAC_RX_DROP_EVENTS, valp);
		break;

	case ETHER_STAT_FCS_ERRORS:
		sfxge_mac_stat_get(sp, EFX_MAC_RX_FCS_ERRORS, valp);
		break;

	default:
		rc = ENOTSUP;
		goto fail3;
	}

	return (0);
fail3:
	DTRACE_PROBE(fail3);
fail2:
	DTRACE_PROBE(fail2);
fail1:
	DTRACE_PROBE1(fail1, int, rc);

	return (rc);
}

static int
sfxge_gld_start(void *arg)
{
	sfxge_t *sp = arg;
	int rc;

	if ((rc = sfxge_start(sp, B_FALSE)) != 0)
		goto fail1;

	return (0);

fail1:
	DTRACE_PROBE1(fail1, int, rc);

	return (rc);
}

static void
sfxge_gld_stop(void *arg)
{
	sfxge_t *sp = arg;

	sfxge_stop(sp);
}

static int
sfxge_gld_setpromisc(void *arg, boolean_t on)
{
	sfxge_t *sp = arg;

	return sfxge_mac_promisc_set(sp,
	    (on) ? SFXGE_PROMISC_ALL_PHYS : SFXGE_PROMISC_OFF);
}

static int
sfxge_gld_multicst(void *arg, boolean_t add, const uint8_t *addr)
{
	sfxge_t *sp = arg;
	int rc;

	if (add) {
		if ((rc = sfxge_mac_multicst_add(sp, addr)) != 0)
			goto fail1;
	} else {
		if ((rc = sfxge_mac_multicst_remove(sp, addr)) != 0)
			goto fail2;
	}

	return (0);

fail2:
	DTRACE_PROBE(fail2);
fail1:
	DTRACE_PROBE1(fail1, int, rc);
	return (rc);
}

static int
sfxge_gld_unicst(void *arg, const uint8_t *addr)
{
	sfxge_t *sp = arg;
	int rc;

	if ((rc = sfxge_mac_unicst_set(sp, (uint8_t *)addr)) != 0)
		goto fail1;

	return (0);

fail1:
	DTRACE_PROBE1(fail1, int, rc);

	return (rc);
}

static void
sfxge_gld_ioctl(void *arg, queue_t *wq, mblk_t *mp)
{
	sfxge_t *sp = arg;

	sfxge_ioctl(sp, wq, mp);
}


static mblk_t *
sfxge_gld_tx(void *arg, mblk_t *mp)
{
	sfxge_t *sp = arg;
	mblk_t *next;

	/* Walk the packet chain */
	do {
		/* Break the packet out of the chain */
		next = mp->b_next;
		mp->b_next = NULL;

		if (next != NULL)
			prefetch_read_many(next);

		/* Post the packet in the appropriate transmit queue */
		if (sfxge_tx_packet_add(sp, mp) == ENOSPC) {
			mp->b_next = next;
			return (mp);
		}

		mp = next;
	} while (mp != NULL);

	return (NULL);
}

/*
 * This must not be static, in order to be tunable by /etc/system.
 * (Static declarations may be optmized away by the compiler.)
 */
boolean_t	sfxge_lso = B_TRUE;

static boolean_t
sfxge_gld_getcapab(void *arg, mac_capab_t cap, void *cap_arg)
{
	int rc;

	_NOTE(ARGUNUSED(arg))

	switch (cap) {
	case MAC_CAPAB_LSO: {
		mac_capab_lso_t *lsop = cap_arg;

		/* Check whether LSO is disabled */
		if (!sfxge_lso) {
			rc = ENOTSUP;
			goto fail1;
		}

		DTRACE_PROBE(lso);

		lsop->lso_flags = LSO_TX_BASIC_TCP_IPV4;
		lsop->lso_basic_tcp_ipv4.lso_max = TCP_MAX_LSO_LENGTH;
		break;
	}
	case MAC_CAPAB_HCKSUM: {
		uint32_t *hcksump = cap_arg;

		DTRACE_PROBE(cksum);

		*hcksump = HCKSUM_INET_FULL_V4 | HCKSUM_IPHDRCKSUM;
		break;
	}
	default:
		rc = ENOTSUP;
		goto fail1;
	}

	return (B_TRUE);

fail1:
	DTRACE_PROBE1(fail1, int, rc);

	return (B_FALSE);
}

/*
 * GLDv3 driver-private property names must be preceded by an underscore - see
 * mc_getprop(9E).
 */
#define	SFXGE_PRIV_PROP_NAME(s) ("_" #s)

#define	SFXGE_XSTR(s) SFXGE_STR(s)
#define	SFXGE_STR(s) #s

static void
sfxge_gld_priv_prop_info(sfxge_t *sp, const char *name,
    mac_prop_info_handle_t handle)
{
	if (strcmp(name, SFXGE_PRIV_PROP_NAME(rx_coalesce_mode)) == 0) {
		mac_prop_info_set_default_uint32(handle,
		    SFXGE_RX_COALESCE_OFF);
		mac_prop_info_set_perm(handle, MAC_PROP_PERM_RW);
		return;
	}

	if (strcmp(name, SFXGE_PRIV_PROP_NAME(rx_scale_count)) == 0) {
		mac_prop_info_set_default_uint32(handle, ncpus);
		mac_prop_info_set_range_uint32(handle, 1,
		    (uint32_t)sp->s_intr.si_nalloc);
		mac_prop_info_set_perm(handle, MAC_PROP_PERM_RW);
		return;
	}

	if (strcmp(name, SFXGE_PRIV_PROP_NAME(intr_moderation)) == 0) {
		mac_prop_info_set_default_uint32(handle,
		    SFXGE_DEFAULT_MODERATION);
		mac_prop_info_set_range_uint32(handle,
		    0, efx_nic_cfg_get(sp->s_enp)->enc_evq_timer_max_us);
		mac_prop_info_set_perm(handle, MAC_PROP_PERM_RW);
		return;
	}

	if (strcmp(name, SFXGE_PRIV_PROP_NAME(mon_polling)) == 0) {
		mac_prop_info_set_default_uint8(handle, 0);
		mac_prop_info_set_perm(handle, MAC_PROP_PERM_RW);
		return;
	}

#if EFSYS_OPT_MCDI_LOGGING
	if (strcmp(name, SFXGE_PRIV_PROP_NAME(mcdi_logging)) == 0) {
		mac_prop_info_set_default_uint8(handle, 0);
		mac_prop_info_set_perm(handle, MAC_PROP_PERM_RW);
		return;
	}
#endif
	DTRACE_PROBE(unknown_priv_prop);
}


static int
sfxge_gld_priv_prop_get(sfxge_t *sp, const char *name,
    unsigned int size, void *valp)
{
	long val;
	int rc;

	if (strcmp(name, SFXGE_PRIV_PROP_NAME(rx_coalesce_mode)) == 0) {
		sfxge_rx_coalesce_mode_t mode;

		sfxge_rx_coalesce_mode_get(sp, &mode);

		val = (long)mode;
		goto done;
	}

	if (strcmp(name, SFXGE_PRIV_PROP_NAME(rx_scale_count)) == 0) {
		unsigned int count;

		if (sfxge_rx_scale_count_get(sp, &count) != 0)
			count = 0;

		val = (long)count;
		goto done;
	}

	if (strcmp(name, SFXGE_PRIV_PROP_NAME(intr_moderation)) == 0) {
		unsigned int us;

		sfxge_ev_moderation_get(sp, &us);

		val = (long)us;
		goto done;
	}

	if (strcmp(name, SFXGE_PRIV_PROP_NAME(mon_polling)) == 0) {
		val = (long)sp->s_mon.sm_polling;
		goto done;
	}

#if EFSYS_OPT_MCDI_LOGGING
	if (strcmp(name, SFXGE_PRIV_PROP_NAME(mcdi_logging)) == 0) {
		val = (long)sp->s_mcdi_logging;
		goto done;
	}
#endif

	rc = ENOTSUP;
	goto fail1;

done:
	(void) snprintf(valp, size, "%ld", val);

	return (0);

fail1:
	DTRACE_PROBE1(fail1, int, rc);

	return (rc);
}


static int
sfxge_gld_priv_prop_set(sfxge_t *sp, const char *name, unsigned int size,
    const void *valp)
{
	long val;
	int rc = 0;

	_NOTE(ARGUNUSED(size))

	(void) ddi_strtol(valp, (char **)NULL, 0, &val);

	if (strcmp(name, SFXGE_PRIV_PROP_NAME(rx_coalesce_mode)) == 0) {
		if ((rc = sfxge_rx_coalesce_mode_set(sp,
		    (sfxge_rx_coalesce_mode_t)val)) != 0)
			goto fail1;

		goto done;
	}

	if (strcmp(name, SFXGE_PRIV_PROP_NAME(rx_scale_count)) == 0) {
		if ((rc = sfxge_rx_scale_count_set(sp, (unsigned int)val)) != 0)
			goto fail1;

		goto done;
	}

	if (strcmp(name, SFXGE_PRIV_PROP_NAME(intr_moderation)) == 0) {
		if ((rc = sfxge_ev_moderation_set(sp, (unsigned int) val)) != 0)
			goto fail1;

		goto done;
	}

	if (strcmp(name, SFXGE_PRIV_PROP_NAME(mon_polling)) == 0) {
		sp->s_mon.sm_polling = (int)val;
		goto done;
	}

#if EFSYS_OPT_MCDI_LOGGING
	if (strcmp(name, SFXGE_PRIV_PROP_NAME(mcdi_logging)) == 0) {
		sp->s_mcdi_logging = (int)val;
		goto done;
	}
#endif


	rc = ENOTSUP;
	goto fail1;

done:
	return (0);

fail1:
	DTRACE_PROBE1(fail1, int, rc);

	return (rc);
}


#if EFSYS_OPT_MCDI_LOGGING
#define	SFXGE_N_NAMED_PROPS	4
#else
#define	SFXGE_N_NAMED_PROPS	3
#endif

static void
sfxge_gld_priv_prop_init(sfxge_t *sp)
{
	sfxge_mac_priv_prop_t *mac_priv_props;
	unsigned int nprops = 0;

	/*
	 * We have named_props (3 or 4) named properties and the structure must
	 * be finished by a NULL pointer.
	 */
	sp->s_mac_priv_props_alloc = SFXGE_N_NAMED_PROPS + 1;
	sp->s_mac_priv_props = kmem_zalloc(sizeof (sfxge_mac_priv_prop_t) *
	    sp->s_mac_priv_props_alloc,
	    KM_SLEEP);

	/*
	 * Driver-private property names start with an underscore - see
	 * mc_getprop(9E).
	 */

	mac_priv_props = sp->s_mac_priv_props;

	*mac_priv_props = kmem_zalloc(MAXLINKPROPNAME, KM_SLEEP);
	(void) snprintf(*mac_priv_props, MAXLINKPROPNAME - 1,
	    SFXGE_PRIV_PROP_NAME(rx_coalesce_mode));
	mac_priv_props++;
	nprops++;

	*mac_priv_props = kmem_zalloc(MAXLINKPROPNAME, KM_SLEEP);
	(void) snprintf(*mac_priv_props, MAXLINKPROPNAME - 1,
	    SFXGE_PRIV_PROP_NAME(rx_scale_count));
	mac_priv_props++;
	nprops++;

	*mac_priv_props = kmem_zalloc(MAXLINKPROPNAME, KM_SLEEP);
	(void) snprintf(*mac_priv_props, MAXLINKPROPNAME - 1,
	    SFXGE_PRIV_PROP_NAME(intr_moderation));
	mac_priv_props++;
	nprops++;

#if EFSYS_OPT_MCDI_LOGGING
	*mac_priv_props = kmem_zalloc(MAXLINKPROPNAME, KM_SLEEP);
	(void) snprintf(*mac_priv_props, MAXLINKPROPNAME - 1,
	    SFXGE_PRIV_PROP_NAME(mcdi_logging));
	mac_priv_props++;
	nprops++;
#endif

	ASSERT3U((nprops + 1), ==, sp->s_mac_priv_props_alloc);

	/* Terminated by a NULL pointer */
	*mac_priv_props = NULL;
}

static void
sfxge_gld_priv_prop_fini(sfxge_t *sp)
{
	char **mac_priv_props;
	unsigned int id;

	mac_priv_props = sp->s_mac_priv_props;

	for (id = 0; id < SFXGE_N_NAMED_PROPS; id++) {
		kmem_free(*mac_priv_props, MAXLINKPROPNAME);
		mac_priv_props++;
	}

	kmem_free(sp->s_mac_priv_props, sizeof (sfxge_mac_priv_prop_t) *
	    sp->s_mac_priv_props_alloc);
	sp->s_mac_priv_props = NULL;
}


static int
sfxge_gld_getprop(void *arg, const char *name, mac_prop_id_t id,
    unsigned int size, void *valp)
{
	sfxge_t *sp = arg;
	uint32_t flag = EFX_PHY_CAP_CURRENT;
	uint8_t *v8 = ((uint8_t *)valp);
	int rc;

	/* check size */
	switch (id) {
	case MAC_PROP_DUPLEX:
		if (size < sizeof (link_duplex_t)) {
			rc = EINVAL;
			goto fail1;
		}
		break;
	case MAC_PROP_FLOWCTRL:
		if (size < sizeof (link_flowctrl_t)) {
			rc = EINVAL;
			goto fail1;
		}
		break;
	case MAC_PROP_SPEED:
	case MAC_PROP_STATUS:
		if (size < sizeof (uint64_t)) {
			rc = EINVAL;
			goto fail1;
		}
		break;
	case MAC_PROP_MTU:
		if (size < sizeof (uint32_t)) {
			rc = EINVAL;
			goto fail1;
		}
		break;
	case MAC_PROP_EN_AUTONEG:
	case MAC_PROP_AUTONEG:
	case MAC_PROP_EN_40GFDX_CAP:
	case MAC_PROP_ADV_40GFDX_CAP:
	case MAC_PROP_EN_10GFDX_CAP:
	case MAC_PROP_ADV_10GFDX_CAP:
	case MAC_PROP_EN_1000FDX_CAP:
	case MAC_PROP_ADV_1000FDX_CAP:
	case MAC_PROP_EN_1000HDX_CAP:
	case MAC_PROP_ADV_1000HDX_CAP:
	case MAC_PROP_EN_100FDX_CAP:
	case MAC_PROP_ADV_100FDX_CAP:
	case MAC_PROP_EN_100HDX_CAP:
	case MAC_PROP_ADV_100HDX_CAP:
	case MAC_PROP_EN_10FDX_CAP:
	case MAC_PROP_ADV_10FDX_CAP:
	case MAC_PROP_EN_10HDX_CAP:
	case MAC_PROP_ADV_10HDX_CAP:
		if (size < sizeof (uint8_t)) {
			rc = EINVAL;
			goto fail1;
		}
		break;
	case MAC_PROP_PRIVATE:
		/* sfxge_gld_priv_prop_get should do any size checking */
		break;
	default:
		rc = ENOTSUP;
		goto fail1;
	}

	switch (id) {
	case MAC_PROP_DUPLEX: {
		sfxge_link_duplex_t duplex;

		sfxge_mac_link_duplex_get(sp, &duplex);

		switch (duplex) {
		case SFXGE_LINK_DUPLEX_UNKNOWN:
			*((link_duplex_t *)valp) = LINK_DUPLEX_UNKNOWN;
			break;

		case SFXGE_LINK_DUPLEX_HALF:
			*((link_duplex_t *)valp) = LINK_DUPLEX_HALF;
			break;

		case SFXGE_LINK_DUPLEX_FULL:
			*((link_duplex_t *)valp) = LINK_DUPLEX_FULL;
			break;

		default:
			ASSERT(B_FALSE);
			break;
		}

		break;
	}
	case MAC_PROP_SPEED: {
		unsigned int speed;

		sfxge_mac_link_speed_get(sp, &speed);

		*((uint64_t *)valp) = (uint64_t)speed * 1000000ull;

		break;
	}
	case MAC_PROP_STATUS: {
		boolean_t up;

		sfxge_mac_link_check(sp, &up);

		*((link_state_t *)valp) = (up) ?
		    LINK_STATE_UP : LINK_STATE_DOWN;

		break;
	}
	case MAC_PROP_EN_AUTONEG:
	case MAC_PROP_AUTONEG:
		*v8 = sfxge_phy_cap_test(sp, flag, EFX_PHY_CAP_AN, NULL);
		break;
	case MAC_PROP_EN_40GFDX_CAP:
	case MAC_PROP_ADV_40GFDX_CAP:
		*v8 = sfxge_phy_cap_test(sp, flag, EFX_PHY_CAP_40000FDX, NULL);
		break;
	case MAC_PROP_EN_10GFDX_CAP:
	case MAC_PROP_ADV_10GFDX_CAP:
		*v8 = sfxge_phy_cap_test(sp, flag, EFX_PHY_CAP_10000FDX, NULL);
		break;
	case MAC_PROP_EN_1000FDX_CAP:
	case MAC_PROP_ADV_1000FDX_CAP:
		*v8 = sfxge_phy_cap_test(sp, flag, EFX_PHY_CAP_1000FDX, NULL);
		break;
	case MAC_PROP_EN_1000HDX_CAP:
	case MAC_PROP_ADV_1000HDX_CAP:
		*v8 = sfxge_phy_cap_test(sp, flag, EFX_PHY_CAP_1000HDX, NULL);
		break;
	case MAC_PROP_EN_100FDX_CAP:
	case MAC_PROP_ADV_100FDX_CAP:
		*v8 = sfxge_phy_cap_test(sp, flag, EFX_PHY_CAP_100FDX, NULL);
		break;
	case MAC_PROP_EN_100HDX_CAP:
	case MAC_PROP_ADV_100HDX_CAP:
		*v8 = sfxge_phy_cap_test(sp, flag, EFX_PHY_CAP_100HDX, NULL);
		break;
	case MAC_PROP_EN_10FDX_CAP:
	case MAC_PROP_ADV_10FDX_CAP:
		*v8 = sfxge_phy_cap_test(sp, flag, EFX_PHY_CAP_10FDX, NULL);
		break;
	case MAC_PROP_EN_10HDX_CAP:
	case MAC_PROP_ADV_10HDX_CAP:
		*v8 = sfxge_phy_cap_test(sp, flag, EFX_PHY_CAP_10HDX, NULL);
		break;
	case MAC_PROP_MTU:
		*((uint32_t *)valp) = (uint32_t)(sp->s_mtu);
		break;

	case MAC_PROP_FLOWCTRL: {
		unsigned int fcntl;

		sfxge_mac_fcntl_get(sp, &fcntl);

		switch (fcntl) {
		case 0:
			*((link_flowctrl_t *)valp) = LINK_FLOWCTRL_NONE;
			break;

		case EFX_FCNTL_GENERATE:
			*((link_flowctrl_t *)valp) = LINK_FLOWCTRL_RX;
			break;

		case EFX_FCNTL_RESPOND:
			*((link_flowctrl_t *)valp) = LINK_FLOWCTRL_TX;
			break;

		case (EFX_FCNTL_GENERATE | EFX_FCNTL_RESPOND):
			*((link_flowctrl_t *)valp) = LINK_FLOWCTRL_BI;
			break;

		default:
			ASSERT(B_FALSE);
			break;
		}
		break;
	}
	case MAC_PROP_PRIVATE:
		if ((rc = sfxge_gld_priv_prop_get(sp, name, size, valp)) != 0)
			goto fail2;
		break;
	default:
		rc = ENOTSUP;
		goto fail3;
	}

	return (0);

fail3:
	DTRACE_PROBE(fail3);

fail2:
	DTRACE_PROBE(fail2);

fail1:
	DTRACE_PROBE1(fail1, int, rc);

	return (rc);
}


static int
sfxge_gld_setprop(void *arg, const char *name, mac_prop_id_t id,
    unsigned int size, const void *valp)
{
	sfxge_t *sp = arg;
	int v8 =  *(uint8_t *)valp;
	int rc;

	/* get size checks out fo the way */
	switch (id) {
	/*
	 * On Sol11 (no updates) dladm seems to be using MAC_PROP_AUTONEG to set
	 * the autoneg parameter. This does not match the scheme suggested in
	 * mac(9E) but as they both map to the same think in the driver and in
	 * dladm it doesn't matter.
	 */
	case MAC_PROP_AUTONEG:
	case MAC_PROP_EN_AUTONEG:
	case MAC_PROP_EN_40GFDX_CAP:
	case MAC_PROP_EN_10GFDX_CAP:
	case MAC_PROP_EN_1000FDX_CAP:
	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 (size < sizeof (uint8_t)) {
			rc = EINVAL;
			goto fail1;
		}
		break;
	case MAC_PROP_MTU:
		if (size < sizeof (uint32_t)) {
			rc = EINVAL;
			goto fail1;
		}
		break;
	case MAC_PROP_FLOWCTRL:
		if (size < sizeof (link_flowctrl_t)) {
			rc = EINVAL;
			goto fail1;
		}
		break;
	case MAC_PROP_PRIVATE:
		/* sfxge_gld_priv_prop_set should do any size checking */
		break;
	default:
		rc = ENOTSUP;
		goto fail1;
	}

	switch (id) {
	/*
	 * It is unclear which of MAC_PROP_AUTONEG and MAC_PROP_EN_AUTONEG is
	 * used.  Try both.
	 */
	case MAC_PROP_AUTONEG:
	case MAC_PROP_EN_AUTONEG:
		if ((rc = sfxge_phy_cap_set(sp, EFX_PHY_CAP_AN, v8)) != 0)
			goto fail2;
		break;
	case MAC_PROP_EN_40GFDX_CAP:
		if ((rc = sfxge_phy_cap_set(sp, EFX_PHY_CAP_40000FDX, v8)) != 0)
			goto fail2;
		break;
	case MAC_PROP_EN_10GFDX_CAP: {
		if ((rc = sfxge_phy_cap_set(sp, EFX_PHY_CAP_10000FDX, v8)) != 0)
			goto fail2;
		break;
	}
	case MAC_PROP_EN_1000FDX_CAP: {
		if ((rc = sfxge_phy_cap_set(sp, EFX_PHY_CAP_1000FDX, v8)) != 0)
			goto fail2;
		break;
	}
	case MAC_PROP_EN_1000HDX_CAP: {
		if ((rc = sfxge_phy_cap_set(sp, EFX_PHY_CAP_1000HDX, v8)) != 0)
			goto fail2;
		break;
	}
	case MAC_PROP_EN_100FDX_CAP: {
		if ((rc = sfxge_phy_cap_set(sp, EFX_PHY_CAP_100FDX, v8)) != 0)
			goto fail2;
		break;
	}
	case MAC_PROP_EN_100HDX_CAP: {
		if ((rc = sfxge_phy_cap_set(sp, EFX_PHY_CAP_100HDX, v8)) != 0)
			goto fail2;
		break;
	}
	case MAC_PROP_EN_10FDX_CAP: {
		if ((rc = sfxge_phy_cap_set(sp, EFX_PHY_CAP_10FDX, v8)) != 0)
			goto fail2;
		break;
	}
	case MAC_PROP_EN_10HDX_CAP: {
		if ((rc = sfxge_phy_cap_set(sp, EFX_PHY_CAP_10HDX, v8)) != 0)
			goto fail2;
		break;
	}
	case MAC_PROP_MTU: {
		size_t mtu = (size_t)(*((uint32_t *)valp));

		if (mtu > EFX_MAC_SDU_MAX) {
			rc = EINVAL;
			goto fail2;
		}

		sp->s_mtu = mtu;

		DTRACE_PROBE(restart_mtu);
		(void) sfxge_restart_dispatch(sp, DDI_SLEEP, SFXGE_HW_OK,
		    "MTU changing", (uint32_t)mtu);

		break;
	}
	case MAC_PROP_FLOWCTRL: {
		unsigned int fcntl = 0;

		switch (*((link_flowctrl_t *)valp)) {
		case LINK_FLOWCTRL_NONE:
			fcntl = 0;
			break;

		case LINK_FLOWCTRL_RX:
			fcntl = EFX_FCNTL_GENERATE;
			break;

		case LINK_FLOWCTRL_TX:
			fcntl = EFX_FCNTL_RESPOND;
			break;

		case LINK_FLOWCTRL_BI:
			fcntl = EFX_FCNTL_GENERATE | EFX_FCNTL_RESPOND;
			break;

		default:
			rc = EINVAL;
			goto fail2;
		}

		if ((rc = sfxge_mac_fcntl_set(sp, fcntl)) != 0)
			goto fail3;

		break;
	}
	case MAC_PROP_PRIVATE:
		if ((rc = sfxge_gld_priv_prop_set(sp, name, size, valp)) != 0)
			goto fail4;

		break;
	default:
		rc = ENOTSUP;
		goto fail5;
	}

	return (0);

fail5:
	DTRACE_PROBE(fail5);

fail4:
	DTRACE_PROBE(fail4);

fail3:
	DTRACE_PROBE(fail3);

fail2:
	DTRACE_PROBE(fail2);

fail1:
	DTRACE_PROBE1(fail1, int, rc);

	return (rc);
}

static void
sfxge_gld_propinfo(void *arg, const char *name, mac_prop_id_t id,
    mac_prop_info_handle_t handle)
{
	sfxge_t *sp = arg;
	efx_phy_cap_type_t phy_cap = EFX_PHY_CAP_INVALID;
	switch (id) {
		case MAC_PROP_DUPLEX:
			mac_prop_info_set_perm(handle, MAC_PROP_PERM_READ);
			return;
		case MAC_PROP_FLOWCTRL:
			mac_prop_info_set_perm(handle, MAC_PROP_PERM_RW);
			mac_prop_info_set_default_link_flowctrl(handle,
			    LINK_FLOWCTRL_BI);
			return;
		case MAC_PROP_SPEED:
			mac_prop_info_set_perm(handle, MAC_PROP_PERM_READ);
			return;
		case MAC_PROP_STATUS:
			mac_prop_info_set_perm(handle, MAC_PROP_PERM_READ);
			return;
		case MAC_PROP_MTU: {
			uint32_t mtu_default;
			mac_prop_info_set_perm(handle, MAC_PROP_PERM_RW);
			mtu_default = ddi_prop_get_int(DDI_DEV_T_ANY,
			    sp->s_dip, DDI_PROP_DONTPASS, "mtu", ETHERMTU);
			mac_prop_info_set_default_uint32(handle, mtu_default);
			return;
			}
		case MAC_PROP_PRIVATE:
			sfxge_gld_priv_prop_info(sp, name, handle);
			return;
		case MAC_PROP_EN_AUTONEG:
		case MAC_PROP_AUTONEG:
			phy_cap = EFX_PHY_CAP_AN;
			break;
		case MAC_PROP_EN_10GFDX_CAP:
		case MAC_PROP_ADV_10GFDX_CAP:
			phy_cap = EFX_PHY_CAP_10000FDX;
			break;
		case MAC_PROP_EN_1000FDX_CAP:
		case MAC_PROP_ADV_1000FDX_CAP:
			phy_cap = EFX_PHY_CAP_1000FDX;
			break;
		case MAC_PROP_EN_1000HDX_CAP:
		case MAC_PROP_ADV_1000HDX_CAP:
			phy_cap = EFX_PHY_CAP_1000HDX;
			break;
		case MAC_PROP_EN_100FDX_CAP:
		case MAC_PROP_ADV_100FDX_CAP:
			phy_cap = EFX_PHY_CAP_100FDX;
			break;
		case MAC_PROP_EN_100HDX_CAP:
		case MAC_PROP_ADV_100HDX_CAP:
			phy_cap = EFX_PHY_CAP_100HDX;
			break;
		case MAC_PROP_EN_10FDX_CAP:
		case MAC_PROP_ADV_10FDX_CAP:
			phy_cap = EFX_PHY_CAP_10FDX;
			break;
		case MAC_PROP_EN_10HDX_CAP:
		case MAC_PROP_ADV_10HDX_CAP:
			phy_cap = EFX_PHY_CAP_10HDX;
			break;
		default:
			DTRACE_PROBE(unknown_prop);
			return;
	}
	if (phy_cap != EFX_PHY_CAP_INVALID) {
		boolean_t rw;
		uint8_t cap_default;
		cap_default = sfxge_phy_cap_test(sp, EFX_PHY_CAP_DEFAULT,
		    phy_cap, &rw);
		if (rw == B_TRUE)
			mac_prop_info_set_perm(handle, MAC_PROP_PERM_RW);
		else
			mac_prop_info_set_perm(handle, MAC_PROP_PERM_READ);
		mac_prop_info_set_default_uint8(handle, cap_default);
	}
}

int
sfxge_gld_register(sfxge_t *sp)
{
	mac_callbacks_t *mcp;
	mac_register_t *mrp;
	mac_handle_t mh;
	uint8_t addr[ETHERADDRL];
	int rc;

	if ((mrp = mac_alloc(MAC_VERSION)) == NULL) {
		rc = ENOTSUP;
		goto fail1;
	}

	mrp->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
	mrp->m_driver = sp;
	mrp->m_dip = sp->s_dip;

	/* Set up the callbacks */
	mcp = &(sp->s_mc);
	bzero(mcp, sizeof (mac_callbacks_t));

	mcp->mc_getstat = sfxge_gld_getstat;
	mcp->mc_start = sfxge_gld_start;
	mcp->mc_stop = sfxge_gld_stop;
	mcp->mc_setpromisc = sfxge_gld_setpromisc;
	mcp->mc_multicst = sfxge_gld_multicst;
	mcp->mc_unicst = sfxge_gld_unicst;
	mcp->mc_tx = sfxge_gld_tx;

	mcp->mc_callbacks |= MC_IOCTL;
	mcp->mc_ioctl = sfxge_gld_ioctl;

	mcp->mc_callbacks |= MC_GETCAPAB;
	mcp->mc_getcapab = sfxge_gld_getcapab;

	mcp->mc_callbacks |= MC_SETPROP;
	mcp->mc_setprop = sfxge_gld_setprop;

	mcp->mc_callbacks |= MC_GETPROP;
	mcp->mc_getprop = sfxge_gld_getprop;

	mcp->mc_callbacks |= MC_PROPINFO;
	mcp->mc_propinfo = sfxge_gld_propinfo;

	mrp->m_callbacks = mcp;

	mrp->m_src_addr = addr;

	if ((rc = sfxge_mac_unicst_get(sp, SFXGE_UNICST_BIA,
	    mrp->m_src_addr)) != 0)
		goto fail2;

	mrp->m_min_sdu = 0;
	mrp->m_max_sdu = sp->s_mtu;

	mrp->m_margin = VLAN_TAGSZ;

	/* Set up the private properties */
	/* NOTE: m_priv_props added in s10u9 */
	mrp->m_priv_props = sp->s_mac_priv_props;
	sfxge_gld_priv_prop_init(sp);

	/* NOTE: m_flags added in s11.0 */
	/* NOTE: m_multicast_sdu added in s11.0 */

	/* Register the interface */
	if ((rc = mac_register(mrp, &mh)) != 0)
		goto fail3;

	/* Free the stack registration object */
	kmem_free(mrp, sizeof (mac_register_t));

	sp->s_mh = mh;

	return (0);
fail3:
	DTRACE_PROBE(fail3);
fail2:
	DTRACE_PROBE(fail2);

	/* Free the stack registration object */
	mac_free(mrp);

	/* Tear down the private properties */
	sfxge_gld_priv_prop_fini(sp);

	/* Clear the callbacks */
	bzero(&(sp->s_mc), sizeof (mac_callbacks_t));

fail1:
	DTRACE_PROBE1(fail1, int, rc);

	return (rc);
}

int
sfxge_gld_unregister(sfxge_t *sp)
{
	mac_handle_t mh = sp->s_mh;
	int rc;

	if ((rc = mac_unregister(mh)) != 0)
		goto fail1;

	sp->s_mh = NULL;

	/* Tear down the private properties */
	sfxge_gld_priv_prop_fini(sp);

	/* Clear the callbacks */
	bzero(&(sp->s_mc), sizeof (mac_callbacks_t));

	return (0);

fail1:
	DTRACE_PROBE1(fail1, int, rc);

	return (rc);
}