/*
 * 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 2010 QLogic Corporation. All rights reserved.
 */

#include <sys/note.h>
#include <qlge.h>
#include <sys/strsubr.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip6.h>
#include <inet/ip.h>

/*
 * GLDv3 functions prototypes
 */
static int	ql_m_getstat(void *, uint_t, uint64_t *);
static int	ql_m_start(void *);
static void	ql_m_stop(void *);
static int	ql_m_setpromiscuous(void *, boolean_t);
static int	ql_m_multicst(void *, boolean_t, const uint8_t *);
static int	ql_m_unicst(void *, const uint8_t *);
static mblk_t	*ql_m_tx(void *, mblk_t *);
static void	ql_m_ioctl(void *, queue_t *, mblk_t *);
static boolean_t ql_m_getcapab(void *, mac_capab_t, void *);

static int ql_m_setprop(void *, const char *, mac_prop_id_t, uint_t,
    const void *);
static int ql_m_getprop(void *, const char *, mac_prop_id_t, uint_t, void *);
static void ql_m_propinfo(void *, const char *, mac_prop_id_t,
    mac_prop_info_handle_t);

#define	QL_M_CALLBACK_FLAGS (MC_IOCTL | MC_GETCAPAB | MC_SETPROP | \
    MC_GETPROP | MC_PROPINFO)
static mac_callbacks_t ql_m_callbacks = {
	QL_M_CALLBACK_FLAGS,
	ql_m_getstat,
	ql_m_start,
	ql_m_stop,
	ql_m_setpromiscuous,
	ql_m_multicst,
	NULL,
	NULL,
	NULL,
	ql_m_ioctl,
	ql_m_getcapab,
	NULL,
	NULL,
	ql_m_setprop,
	ql_m_getprop,
	ql_m_propinfo
};

char *qlge_priv_prop[] = {
	"_adv_pause_mode",
	"_fm_enable",
	NULL
};

/*
 * This function starts the driver
 */
static int
ql_m_start(void *arg)
{
	qlge_t *qlge = (qlge_t *)arg;

	/*
	 * reset chip, re-initialize everything but do not
	 * re-allocate memory
	 */
	mutex_enter(&qlge->gen_mutex);
	if (qlge->mac_flags == QL_MAC_SUSPENDED) {
		mutex_exit(&qlge->gen_mutex);
		return (ECANCELED);
	}
	mutex_enter(&qlge->hw_mutex);
	qlge->mac_flags = QL_MAC_INIT;
	/*
	 * Write default ethernet address to chip register Mac
	 * Address slot 0 and Enable Primary Mac Function.
	 */
	(void) ql_unicst_set(qlge,
	    (uint8_t *)qlge->unicst_addr[0].addr.ether_addr_octet, 0);
	qlge->stats.rpackets = 0;
	qlge->stats.rbytes = 0;
	qlge->stats.opackets = 0;
	qlge->stats.obytes = 0;
	mutex_exit(&qlge->hw_mutex);

	(void) ql_do_start(qlge);
	mutex_exit(&qlge->gen_mutex);

	mutex_enter(&qlge->mbx_mutex);
	(void) ql_get_firmware_version(qlge, NULL);
	mutex_exit(&qlge->mbx_mutex);

	return (0);
}

/*
 * This function stops the driver
 */
static void
ql_m_stop(void *arg)
{
	qlge_t *qlge = (qlge_t *)arg;

	mutex_enter(&qlge->gen_mutex);
	if (qlge->mac_flags == QL_MAC_SUSPENDED) {
		mutex_exit(&qlge->gen_mutex);
		return;
	}
	(void) ql_do_stop(qlge);
	mutex_exit(&qlge->gen_mutex);
	qlge->mac_flags = QL_MAC_STOPPED;
}

/*
 * Add or remove a multicast address
 */
static int
ql_m_multicst(void *arg, boolean_t add, const uint8_t *ep)
{
	qlge_t *qlge = (qlge_t *)arg;
	int ret = DDI_SUCCESS;

	mutex_enter(&qlge->gen_mutex);
	if (qlge->mac_flags == QL_MAC_SUSPENDED) {
		mutex_exit(&qlge->gen_mutex);
		return (ECANCELED);
	}

	if (qlge->mac_flags == QL_MAC_DETACH) {
		mutex_exit(&qlge->gen_mutex);
		return (ECANCELED);
	}
	if (add) {
		QL_DUMP(DBG_GLD, "add to multicast list:\n",
		    (uint8_t *)ep, 8, ETHERADDRL);
		ret = ql_add_to_multicast_list(qlge, (uint8_t *)ep);
	} else {
		QL_DUMP(DBG_GLD, "remove from multicast list:\n",
		    (uint8_t *)ep, 8, ETHERADDRL);
		ret = ql_remove_from_multicast_list(qlge, (uint8_t *)ep);
	}
	mutex_exit(&qlge->gen_mutex);

	if (ret != DDI_SUCCESS) {
		ret = EIO;
		if (qlge->fm_enable) {
			ddi_fm_service_impact(qlge->dip, DDI_SERVICE_DEGRADED);
		}
	} else {
		ret = 0;
	}
	return (ret);
}

/*
 * Enable or disable promiscuous mode
 */
static int
ql_m_setpromiscuous(void* arg, boolean_t on)
{
	qlge_t *qlge = (qlge_t *)arg;
	int mode;

	mutex_enter(&qlge->gen_mutex);
	if (qlge->mac_flags == QL_MAC_SUSPENDED) {
		mutex_exit(&qlge->gen_mutex);
		return (ECANCELED);
	}

	/* enable reception of all packets on the medium, */
	if (on) {
		mode = 1;
		QL_PRINT(DBG_GLD, ("%s(%d) enable promiscuous mode\n",
		    __func__, qlge->instance));
	} else {
		mode = 0;
		QL_PRINT(DBG_GLD, ("%s(%d) disable promiscuous mode\n",
		    __func__, qlge->instance));
	}

	mutex_enter(&qlge->hw_mutex);
	ql_set_promiscuous(qlge, mode);
	mutex_exit(&qlge->hw_mutex);
	mutex_exit(&qlge->gen_mutex);
	return (DDI_SUCCESS);
}


static int
ql_m_getstat(void *arg, uint_t stat, uint64_t *valp)
{
	qlge_t *qlge = (qlge_t *)arg;
	struct ql_stats *cur_stats;
	uint64_t val = 0;
	int i;
	uint32_t val32;
	struct rx_ring *rx_ring;
	struct tx_ring *tx_ring;

	ASSERT(qlge != NULL);
	mutex_enter(&qlge->gen_mutex);
	if (qlge->mac_flags == QL_MAC_SUSPENDED) {
		mutex_exit(&qlge->gen_mutex);
		return (ECANCELED);
	}

	cur_stats = &qlge->stats;
	/* these stats are maintained in software */
	switch (stat) {

	case MAC_STAT_IFSPEED /* 1000 */ :
		if (CFG_IST(qlge, CFG_CHIP_8100) != 0) {
			qlge->speed = SPEED_10G;
		}
		val = qlge->speed * 1000000ull;
		break;

	case MAC_STAT_MULTIRCV:
		val = cur_stats->multircv;
		break;

	case MAC_STAT_BRDCSTRCV:
		val = cur_stats->brdcstrcv;
		break;

	case MAC_STAT_MULTIXMT:
		cur_stats->multixmt = 0;
		for (i = 0; i < qlge->tx_ring_count; i++) {
			tx_ring = &qlge->tx_ring[i];
			cur_stats->multixmt += tx_ring->multixmt;
		}
		val = cur_stats->multixmt;
		break;

	case MAC_STAT_BRDCSTXMT:
		cur_stats->brdcstxmt = 0;
		for (i = 0; i < qlge->tx_ring_count; i++) {
			tx_ring = &qlge->tx_ring[i];
			cur_stats->brdcstxmt += tx_ring->brdcstxmt;
		}
		val = cur_stats->brdcstxmt;
		break;

	case MAC_STAT_NORCVBUF:
		val = cur_stats->norcvbuf;
		break;

	case MAC_STAT_IERRORS:
		val = cur_stats->errrcv;
		break;

	case MAC_STAT_OBYTES:
		cur_stats->obytes = 0;
		for (i = 0; i < qlge->tx_ring_count; i++) {
			tx_ring = &qlge->tx_ring[i];
			cur_stats->obytes += tx_ring->obytes;
		}
		val = cur_stats->obytes;
		break;

	case MAC_STAT_OPACKETS:
		cur_stats->opackets = 0;
		for (i = 0; i < qlge->tx_ring_count; i++) {
			tx_ring = &qlge->tx_ring[i];
			cur_stats->opackets += tx_ring->opackets;
		}
		val = cur_stats->opackets;
		break;

	case ETHER_STAT_DEFER_XMTS:
		cur_stats->defer = 0;
		for (i = 0; i < qlge->tx_ring_count; i++) {
			tx_ring = &qlge->tx_ring[i];
			cur_stats->defer += (tx_ring->defer);
		}
		val = cur_stats->defer;
		break;

	case MAC_STAT_OERRORS:
		cur_stats->errxmt = 0;
		for (i = 0; i < qlge->tx_ring_count; i++) {
			tx_ring = &qlge->tx_ring[i];
			cur_stats->errxmt += tx_ring->errxmt;
		}
		val = cur_stats->errxmt;
		break;

	case MAC_STAT_RBYTES:
		cur_stats->rbytes = 0;
		for (i = 0; i < qlge->rx_ring_count; i++) {
			rx_ring = &qlge->rx_ring[i];
			cur_stats->rbytes += rx_ring->rx_bytes;
		}
		val = cur_stats->rbytes;
		break;

	case MAC_STAT_IPACKETS:
		cur_stats->rpackets = 0;
		for (i = 0; i < qlge->rx_ring_count; i++) {
			rx_ring = &qlge->rx_ring[i];
			cur_stats->rpackets += rx_ring->rx_packets;
		}
		val = cur_stats->rpackets;
		break;

	case ETHER_STAT_FCS_ERRORS:
		cur_stats->crc = 0;
		for (i = 0; i < qlge->rx_ring_count; i++) {
			rx_ring = &qlge->rx_ring[i];
			cur_stats->crc += rx_ring->fcs_err;
		}
		val = cur_stats->crc;
		break;

	case ETHER_STAT_TOOLONG_ERRORS:
		cur_stats->frame_too_long = 0;
		for (i = 0; i < qlge->rx_ring_count; i++) {
			rx_ring = &qlge->rx_ring[i];
			cur_stats->frame_too_long +=
			    rx_ring->frame_too_long;
		}
		val = cur_stats->frame_too_long;
		break;

	case ETHER_STAT_XCVR_INUSE:
		val = XCVR_1000X;
		break;
	case ETHER_STAT_JABBER_ERRORS:
		if (ql_sem_spinlock(qlge, qlge->xgmac_sem_mask) !=
		    DDI_SUCCESS) {
			break;
		}
		(void) ql_read_xgmac_reg(qlge, REG_XGMAC_MAC_RX_JABBER_PKTS,
		    &val32);
		val = val32;
		ql_sem_unlock(qlge, qlge->xgmac_sem_mask);
		QL_PRINT(DBG_STATS, ("%s(%d) MAC_STAT_JABBER_ERRORS "
		    "status %d\n", __func__, qlge->instance, val));
		break;
	case ETHER_STAT_LINK_DUPLEX:
		if (qlge->duplex == 1)
			val = LINK_DUPLEX_FULL;
		else
			val = LINK_DUPLEX_HALF;
		break;

	/* statics saved in hw */
	case ETHER_STAT_MACRCV_ERRORS:
		val = 0;
		if (ql_sem_spinlock(qlge, qlge->xgmac_sem_mask) !=
		    DDI_SUCCESS) {
			break;
		}
		(void) ql_read_xgmac_reg(qlge, REG_XGMAC_MAC_ALIGN_ERR,
		    &val32);
		val += val32;
		(void) ql_read_xgmac_reg(qlge, REG_XGMAC_MAC_FCS_ERR, &val32);
		val += val32;
		(void) ql_read_xgmac_reg(qlge, REG_XGMAC_MAC_RX_JABBER_PKTS,
		    &val32);
		val += val32;
		(void) ql_read_xgmac_reg(qlge, REG_XGMAC_MAC_RX_SYM_ERR,
		    &val32);
		val += val32;
		(void) ql_read_xgmac_reg(qlge, REG_XGMAC_MAC_RX_INT_ERR,
		    &val32);
		val += val32;
		ql_sem_unlock(qlge, qlge->xgmac_sem_mask);
		break;

	default:
		mutex_exit(&qlge->gen_mutex);
		return (ENOTSUP);
	}
	*valp = val;
	mutex_exit(&qlge->gen_mutex);

	return (0);

}

/*
 * Set the physical network address
 */
int
ql_unicst_set(qlge_t *qlge, const uint8_t *macaddr, int slot)
{
	int ret;

	ret = ql_sem_spinlock(qlge, SEM_MAC_ADDR_MASK);
	if (ret != DDI_SUCCESS)
		goto exit;
	ret = ql_set_mac_addr_reg(qlge, (uint8_t *)macaddr,
	    MAC_ADDR_TYPE_CAM_MAC,
	    (uint16_t)(qlge->func_number * MAX_CQ + slot));
	ql_sem_unlock(qlge, SEM_MAC_ADDR_MASK);

exit:
	if (ret != DDI_SUCCESS) {
		ret = EIO;
		if (qlge->fm_enable) {
			ddi_fm_service_impact(qlge->dip, DDI_SERVICE_DEGRADED);
		}
	} else {
		ret = 0;
	}
	return (ret);
}

/*
 * Set default MAC address
 * Each function has a total of 128 mac address, function0: 0~127,
 * function1 128~254 etc or func_number *128 + n (0~127), but
 * we only support one MAC address, so its address is
 * func_number*128+0
 */
static int
ql_m_unicst(void *arg, const uint8_t *mac)
{
	qlge_t *qlge = (qlge_t *)arg;
	int status;

	ASSERT(qlge->mac_flags != QL_MAC_DETACH);
	mutex_enter(&qlge->gen_mutex);
	if (qlge->mac_flags == QL_MAC_SUSPENDED) {
		mutex_exit(&qlge->gen_mutex);
		return (ECANCELED);
	}

	mutex_enter(&qlge->hw_mutex);
	bcopy(mac, qlge->unicst_addr[0].addr.ether_addr_octet, ETHERADDRL);
	/* Set Mac Address to slot 0 and Enable Primary Mac Function */
	status = ql_unicst_set(qlge, mac, 0);
	mutex_exit(&qlge->hw_mutex);
	mutex_exit(&qlge->gen_mutex);

	return (status);
}

/*
 * ql_m_tx is used only for sending data packets into ethernet wire.
 */
static mblk_t *
ql_m_tx(void *arg, mblk_t *mp)
{
	qlge_t *qlge = (qlge_t *)arg;
	struct tx_ring *tx_ring;
	mblk_t *next;
	int rval;
	uint32_t tx_count = 0;
	caddr_t bp;
	uint8_t selected_ring = 0;

	if ((qlge->port_link_state == LS_DOWN) ||
	    (qlge->mac_flags != QL_MAC_STARTED)) {

		cmn_err(CE_WARN, "!%s(%d): exit due to link down",
		    __func__, qlge->instance);
		freemsgchain(mp);
		mp = NULL;
		goto tx_exit;
	}

	/*
	 * Calculate which tx ring to send this packet
	 */
	bp = (caddr_t)mp->b_rptr;
	selected_ring = ql_tx_hashing(qlge, bp);
	tx_ring = &qlge->tx_ring[selected_ring];
	mutex_enter(&tx_ring->tx_lock);
	if (tx_ring->mac_flags != QL_MAC_STARTED) {
		mutex_exit(&tx_ring->tx_lock);
		goto tx_exit;
	}

	/* we must try to send all */
	while (mp != NULL) {
		/*
		 * if number of available slots is less than a threshold,
		 * then quit
		 */
		if (tx_ring->tx_free_count <= TX_STOP_THRESHOLD) {
			tx_ring->queue_stopped = 1;
			rval = DDI_FAILURE;
			/*
			 * If we return the buffer back we are expected to
			 * call mac_tx_ring_update() when
			 * resources are available
			 */
			tx_ring->defer++;
			break;
		}
		next = mp->b_next;
		mp->b_next = NULL;

		rval = ql_send_common(tx_ring, mp);

		if (rval != DDI_SUCCESS) {
			mp->b_next = next;
			break;
		}
		tx_count++;
		mp = next;
	}
	/*
	 * After all msg blocks are mapped or copied to tx buffer,
	 * trigger the hardware to send the msg!
	 */
	if (tx_count > 0) {
		ql_write_doorbell_reg(tx_ring->qlge, tx_ring->prod_idx_db_reg,
		    tx_ring->prod_idx);
	}
	mutex_exit(&tx_ring->tx_lock);
tx_exit:
	return (mp);
}

static void
ql_m_ioctl(void *arg, queue_t *wq, mblk_t *mp)
{
	qlge_t *qlge = (qlge_t *)arg;
	struct iocblk *iocp;
	boolean_t need_privilege = B_TRUE;
	int err, cmd;
	enum ioc_reply status;

	/*
	 * Validate the command before bothering with the mutex...
	 */
	iocp = (struct iocblk *)(void *)mp->b_rptr;
	iocp->ioc_error = 0;
	cmd = iocp->ioc_cmd;

	mutex_enter(&qlge->gen_mutex);
	if (qlge->mac_flags == QL_MAC_SUSPENDED) {
		mutex_exit(&qlge->gen_mutex);
		miocnak(wq, mp, 0, EINVAL);
		return;
	}
	switch (cmd) {
		default:
			QL_PRINT(DBG_GLD, ("unknown ioctl cmd \n"));
			miocnak(wq, mp, 0, EINVAL);
			mutex_exit(&qlge->gen_mutex);
			return;
		case QLA_PCI_STATUS:
		case QLA_WRITE_REG:
		case QLA_READ_PCI_REG:
		case QLA_WRITE_PCI_REG:
		case QLA_GET_DBGLEAVEL:
		case QLA_SET_DBGLEAVEL:
		case QLA_READ_CONTRL_REGISTERS:
		case QLA_MANUAL_READ_FLASH:
		case QLA_MANUAL_WRITE_FLASH:
		case QLA_GET_BINARY_CORE_DUMP:
		case QLA_SUPPORTED_DUMP_TYPES:
		case QLA_TRIGGER_SYS_ERROR_EVENT:
		case QLA_READ_FLASH:
		case QLA_WRITE_FLASH:
		case QLA_READ_VPD:
		case QLA_GET_PROP:
		case QLA_SHOW_REGION:
		case QLA_LIST_ADAPTER_INFO:
		case QLA_READ_FW_IMAGE:
		case QLA_WRITE_FW_IMAGE_HEADERS:
		case QLA_CONTINUE_COPY_IN:
		case QLA_CONTINUE_COPY_OUT:
		case QLA_SOFT_RESET:
			break;
		case LB_GET_INFO_SIZE:
		case LB_GET_INFO:
		case LB_GET_MODE:
			need_privilege = B_FALSE;
		/* FALLTHRU */
		case LB_SET_MODE:
			break;
	}

	if (need_privilege) {
		/*
		 * Check for specific net_config privilege
		 */
		err = secpolicy_net_config(iocp->ioc_cr, B_FALSE);
		if (err != 0) {
			miocnak(wq, mp, 0, err);
			mutex_exit(&qlge->gen_mutex);
			return;
		}
	}
	/*
	 * Implement ioctl
	 */
	switch (cmd) {
		case QLA_PCI_STATUS:
		case QLA_WRITE_REG:
		case QLA_READ_PCI_REG:
		case QLA_WRITE_PCI_REG:
		case QLA_GET_DBGLEAVEL:
		case QLA_SET_DBGLEAVEL:
		case QLA_READ_CONTRL_REGISTERS:
		case QLA_MANUAL_READ_FLASH:
		case QLA_MANUAL_WRITE_FLASH:
		case QLA_GET_BINARY_CORE_DUMP:
		case QLA_SUPPORTED_DUMP_TYPES:
		case QLA_TRIGGER_SYS_ERROR_EVENT:
		case QLA_READ_FLASH:
		case QLA_WRITE_FLASH:
		case QLA_READ_VPD:
		case QLA_GET_PROP:
		case QLA_SHOW_REGION:
		case QLA_LIST_ADAPTER_INFO:
		case QLA_READ_FW_IMAGE:
		case QLA_WRITE_FW_IMAGE_HEADERS:
		case QLA_CONTINUE_COPY_IN:
		case QLA_CONTINUE_COPY_OUT:
		case QLA_SOFT_RESET:
			status = ql_chip_ioctl(qlge, wq, mp);
			break;
		case LB_GET_INFO_SIZE:
		case LB_GET_INFO:
		case LB_GET_MODE:
		case LB_SET_MODE:
			status = ql_loop_ioctl(qlge, wq, mp, iocp);
			break;
		default:
			status = IOC_INVAL;
			break;
	}

	/*
	 * Decide how to reply
	 */
	switch (status) {
	default:
	case IOC_INVAL:
		/*
		 * Error, reply with a NAK and EINVAL or the specified error
		 */
		miocnak(wq, mp, 0, iocp->ioc_error == 0 ?
		    EINVAL : iocp->ioc_error);
		break;

	case IOC_DONE:
		/*
		 * OK, reply already sent
		 */
		break;

	case IOC_ACK:
		/*
		 * OK, reply with an ACK
		 */
		miocack(wq, mp, 0, 0);
		break;

	case IOC_REPLY:
		/*
		 * OK, send prepared reply as ACK or NAK
		 */
		mp->b_datap->db_type = (uint8_t)(iocp->ioc_error == 0 ?
		    M_IOCACK : M_IOCNAK);
		qreply(wq, mp);
		break;
	}
	mutex_exit(&qlge->gen_mutex);
}
/* ARGSUSED */
static int
qlge_set_priv_prop(qlge_t *qlge, const char *pr_name, uint_t pr_valsize,
    const void *pr_val)
{
	int err = 0;
	long result;

	if (strcmp(pr_name, "_adv_pause_mode") == 0) {
		(void) ddi_strtol(pr_val, (char **)NULL, 0, &result);
		if (result > PAUSE_MODE_PER_PRIORITY ||
		    result < PAUSE_MODE_DISABLED) {
			err = EINVAL;
		} else if (qlge->pause != (uint32_t)result) {
			qlge->pause = (uint32_t)result;
			if (qlge->flags & INTERRUPTS_ENABLED) {
				mutex_enter(&qlge->mbx_mutex);
				if (ql_set_pause_mode(qlge) == DDI_FAILURE)
					err = EINVAL;
				mutex_exit(&qlge->mbx_mutex);
			}
		}
		return (err);
	} else if (strcmp(pr_name, "_fm_enable") == 0) {
		(void) ddi_strtol(pr_val, (char **)NULL, 0, &result);
		if ((result != 0) && (result != 1)) {
			err = EINVAL;
		} else if (qlge->fm_enable != (boolean_t)result) {
			qlge->fm_enable = (boolean_t)result;
		}
		return (err);
	}
	return (ENOTSUP);
}

/*
 * callback functions for set/get of properties
 */
/* ARGSUSED */
static int
ql_m_setprop(void *barg, const char *pr_name, mac_prop_id_t pr_num,
    uint_t pr_valsize, const void *pr_val)
{
	qlge_t *qlge = barg;
	int err = 0;
	uint32_t cur_mtu, new_mtu;

	mutex_enter(&qlge->gen_mutex);
	if (qlge->mac_flags == QL_MAC_SUSPENDED) {
		mutex_exit(&qlge->gen_mutex);
		return (ECANCELED);
	}

	switch (pr_num) {
	case MAC_PROP_MTU:
		cur_mtu = qlge->mtu;
		bcopy(pr_val, &new_mtu, sizeof (new_mtu));

		QL_PRINT(DBG_GLD, ("%s(%d) new mtu %d \n",
		    __func__, qlge->instance, new_mtu));
		if (new_mtu == cur_mtu) {
			err = 0;
			break;
		}
		if ((new_mtu != ETHERMTU) && (new_mtu != JUMBO_MTU)) {
			err = EINVAL;
			break;
		}
		/*
		 * do not change on the fly, allow only before
		 * driver is started or stopped
		 */
		if ((qlge->mac_flags == QL_MAC_STARTED) ||
		    (qlge->mac_flags == QL_MAC_DETACH)) {
			err = EBUSY;
			cmn_err(CE_WARN, "%s(%d) new mtu %d ignored, "
			    "driver busy, mac_flags %d", __func__,
			    qlge->instance, new_mtu, qlge->mac_flags);
			break;
		}
		qlge->mtu = new_mtu;
		err = mac_maxsdu_update(qlge->mh, qlge->mtu);
		if (err == 0) {
			/* EMPTY */
			QL_PRINT(DBG_GLD, ("%s(%d) new mtu %d set success\n",
			    __func__, qlge->instance,
			    new_mtu));
		}
		break;
	case MAC_PROP_PRIVATE:
		mutex_exit(&qlge->gen_mutex);
		err = qlge_set_priv_prop(qlge, pr_name, pr_valsize,
		    pr_val);
		mutex_enter(&qlge->gen_mutex);
		break;
	default:
		err = ENOTSUP;
		break;
	}
	mutex_exit(&qlge->gen_mutex);
	return (err);
}

static int
qlge_get_priv_prop(qlge_t *qlge, const char *pr_name, uint_t pr_valsize,
    void *pr_val)
{
	int err = ENOTSUP;
	uint32_t value;

	if (strcmp(pr_name, "_adv_pause_mode") == 0) {
		value = qlge->pause;
		err = 0;
	} else if (strcmp(pr_name, "_fm_enable") == 0) {
		value = qlge->fm_enable;
		err = 0;
	}

	if (err == 0) {
		(void) snprintf(pr_val, pr_valsize, "%d", value);
	}
	return (err);
}

/* ARGSUSED */
static int
ql_m_getprop(void *barg, const char *pr_name, mac_prop_id_t pr_num,
    uint_t pr_valsize, void *pr_val)
{
	qlge_t *qlge = barg;
	uint64_t speed;
	link_state_t link_state;
	link_duplex_t link_duplex;
	int err = 0;

	mutex_enter(&qlge->gen_mutex);
	if (qlge->mac_flags == QL_MAC_SUSPENDED) {
		err = ECANCELED;
		goto out;
	}

	switch (pr_num) {
	case MAC_PROP_DUPLEX:
		ASSERT(pr_valsize >= sizeof (link_duplex_t));
		if (qlge->duplex)
			link_duplex = LINK_DUPLEX_FULL;
		else
			link_duplex = LINK_DUPLEX_HALF;

		bcopy(&link_duplex, pr_val,
		    sizeof (link_duplex_t));
		break;
	case MAC_PROP_SPEED:
		ASSERT(pr_valsize >= sizeof (speed));
		speed = qlge->speed * 1000000ull;
		bcopy(&speed, pr_val, sizeof (speed));
		break;
	case MAC_PROP_STATUS:
		ASSERT(pr_valsize >= sizeof (link_state_t));
		if (qlge->port_link_state == LS_DOWN)
			link_state = LINK_STATE_DOWN;
		else
			link_state = LINK_STATE_UP;
		bcopy(&link_state, pr_val,
		    sizeof (link_state_t));
		break;

	case MAC_PROP_PRIVATE:
		err = qlge_get_priv_prop(qlge, pr_name, pr_valsize, pr_val);
		break;

	default:
		err = ENOTSUP;
	}
out:
	mutex_exit(&qlge->gen_mutex);
	return (err);
}

/* ARGSUSED */
static void
ql_m_propinfo(void *barg, const char *pr_name, mac_prop_id_t pr_num,
    mac_prop_info_handle_t prh)
{
	_NOTE(ARGUNUSED(barg));

	switch (pr_num) {
	case MAC_PROP_DUPLEX:
	case MAC_PROP_SPEED:
	case MAC_PROP_STATUS:
		mac_prop_info_set_perm(prh, MAC_PROP_PERM_READ);
		break;

	case MAC_PROP_PRIVATE: {
		char val_str[64];
		int default_val;

		if (strcmp(pr_name, "_adv_pause_mode") == 0)
			default_val = 2;
		else if (strcmp(pr_name, "_fm_enable") == 0)
			default_val = 1;
		else
			return;

		(void) snprintf(val_str, sizeof (val_str), "%d", default_val);
		mac_prop_info_set_default_str(prh, val_str);
		break;
	}
	}
}

/* ARGSUSED */
static boolean_t
ql_m_getcapab(void *arg, mac_capab_t cap, void *cap_data)
{
	int ret = B_FALSE;
	uint32_t cksum = 0;
	qlge_t *qlge = (qlge_t *)arg;

	switch (cap) {
	case MAC_CAPAB_HCKSUM:
		if ((qlge->cfg_flags & CFG_CKSUM_FULL_IPv4) != 0) {
			cksum |= HCKSUM_INET_FULL_V4;
		}
		if ((qlge->cfg_flags & CFG_CKSUM_FULL_IPv6) != 0) {
			cksum |= HCKSUM_INET_FULL_V6;
		}
		if ((qlge->cfg_flags & CFG_CKSUM_HEADER_IPv4) != 0) {
			cksum |= HCKSUM_IPHDRCKSUM;
		}
		if ((qlge->cfg_flags & CFG_CKSUM_PARTIAL) != 0) {
			cksum |= HCKSUM_INET_PARTIAL;
		}
		qlge->chksum_cap = cksum;
		*(uint32_t *)cap_data = cksum;
		ret = B_TRUE;
		break;

	case MAC_CAPAB_LSO: {
		mac_capab_lso_t *cap_lso = (mac_capab_lso_t *)cap_data;
		uint32_t page_size;
		uint32_t lso_max;

		if ((qlge->cfg_flags & CFG_LSO)&&
		    (qlge->cfg_flags & CFG_SUPPORT_SCATTER_GATHER)) {
			cap_lso->lso_flags = LSO_TX_BASIC_TCP_IPV4;
			page_size = ddi_ptob(qlge->dip, (ulong_t)1);
			lso_max = page_size * (QL_MAX_TX_DMA_HANDLES-1);
			cap_lso->lso_basic_tcp_ipv4.lso_max =
			    min(lso_max, QL_LSO_MAX);
			ret = B_TRUE;
		}
		break;
	}

	default:
		return (B_FALSE);
	}
	return (ret);
}

void
ql_gld3_init(qlge_t *qlge, mac_register_t *macp)
{
	macp->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
	macp->m_driver = qlge;
	macp->m_dip = qlge->dip;
	/* This is the mac address from flash to be used by the port */
	macp->m_src_addr = qlge->dev_addr.ether_addr_octet;
	macp->m_min_sdu = 0;
	macp->m_max_sdu = qlge->mtu;
	macp->m_margin = VLAN_TAGSZ;
	macp->m_priv_props = qlge_priv_prop;
	macp->m_v12n = 0;
	ql_m_callbacks.mc_unicst = ql_m_unicst;
	ql_m_callbacks.mc_tx = ql_m_tx;
	macp->m_callbacks = &ql_m_callbacks;
}