/*
 * 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.
 */

/*
 * All efx_mac_*() must be after efx_port_init()
 * LOCKING STRATEGY: Aquire sm_lock and test sm_state==SFXGE_MAC_STARTED
 * to serialise against sfxge_restart()
 */

#include <sys/types.h>
#include <sys/sysmacros.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>

#include "sfxge.h"
#include "efx.h"

#define SFXGE_MAC_POLL_PERIOD_MS 1000

static void sfxge_mac_link_update_locked(sfxge_t *sp, efx_link_mode_t mode);


/* MAC DMA attributes */
static ddi_device_acc_attr_t sfxge_mac_devacc = {

        DDI_DEVICE_ATTR_V0,     /* devacc_attr_version */
        DDI_NEVERSWAP_ACC,      /* devacc_attr_endian_flags */
        DDI_STRICTORDER_ACC     /* devacc_attr_dataorder */
};

static ddi_dma_attr_t sfxge_mac_dma_attr = {
        DMA_ATTR_V0,            /* dma_attr_version     */
        0,                      /* dma_attr_addr_lo     */
        0xffffffffffffffffull,  /* dma_attr_addr_hi     */
        0xffffffffffffffffull,  /* dma_attr_count_max   */
        0x1000,                 /* dma_attr_align       */
        0xffffffff,             /* dma_attr_burstsizes  */
        1,                      /* dma_attr_minxfer     */
        0xffffffffffffffffull,  /* dma_attr_maxxfer     */
        0xffffffffffffffffull,  /* dma_attr_seg         */
        1,                      /* dma_attr_sgllen      */
        1,                      /* dma_attr_granular    */
        0                       /* dma_attr_flags       */
};


static void
_sfxge_mac_stat_update(sfxge_mac_t *smp, int tries, int delay_usec)
{
        sfxge_t *sp = smp->sm_sp;
        efsys_mem_t *esmp = &(smp->sm_mem);
        int i;

        ASSERT(mutex_owned(&(smp->sm_lock)));
        ASSERT3U(smp->sm_state, !=, SFXGE_MAC_UNINITIALIZED);

        /* if no stats pending then they are already freshly updated */
        if (smp->sm_mac_stats_timer_reqd && !smp->sm_mac_stats_pend)
                return;

        for (i = 0; i < tries; i++) {
                /* Try to update the cached counters */
                if (efx_mac_stats_update(sp->s_enp, esmp, smp->sm_stat,
                    NULL) != EAGAIN)
                        goto done;

                drv_usecwait(delay_usec);
        }

        DTRACE_PROBE(mac_stat_timeout);
        dev_err(sp->s_dip, CE_NOTE, SFXGE_CMN_ERR "MAC stats timeout");
        return;

done:
        smp->sm_mac_stats_pend = B_FALSE;
        smp->sm_lbolt = ddi_get_lbolt();
}

static void
sfxge_mac_stat_update_quick(sfxge_mac_t *smp)
{
        /*
         * Update the statistics from the most recent DMA. This might race
         * with an inflight dma, so retry once. Otherwise get mac stat
         * values from the last mac_poll() or MC periodic stats.
         */
        _sfxge_mac_stat_update(smp, 2, 50);
}

static void
sfxge_mac_stat_update_wait(sfxge_mac_t *smp)
{
        /* Wait a max of 20 * 500us = 10ms */
        _sfxge_mac_stat_update(smp, 20, 500);
}

static int
sfxge_mac_kstat_update(kstat_t *ksp, int rw)
{
        sfxge_mac_t *smp = ksp->ks_private;
        kstat_named_t *knp;
        int rc;
        unsigned int val;
        sfxge_rx_coalesce_mode_t rxmode;

        if (rw != KSTAT_READ) {
                rc = EACCES;
                goto fail1;
        }

        ASSERT(mutex_owned(&(smp->sm_lock)));

        if (smp->sm_state != SFXGE_MAC_STARTED)
                goto done;

        sfxge_mac_stat_update_quick(smp);

        knp = smp->sm_stat;
        knp += EFX_MAC_NSTATS;

        knp->value.ui64 = (smp->sm_link_up) ? 1 : 0;
        knp++;

        knp->value.ui64 = smp->sm_link_speed;
        knp++;

        knp->value.ui64 = smp->sm_link_duplex;
        knp++;

        knp->value.ui64 = (smp->sm_fcntl & EFX_FCNTL_GENERATE) ? 1 : 0;
        knp++;

        knp->value.ui64 = (smp->sm_fcntl & EFX_FCNTL_RESPOND) ? 1 : 0;
        knp++;

        sfxge_ev_moderation_get(smp->sm_sp, &val);
        knp->value.ui64 = val;
        knp++;

        sfxge_rx_coalesce_mode_get(smp->sm_sp, &rxmode);
        knp->value.ui64 = (uint64_t)rxmode;
        knp++;

        if (sfxge_rx_scale_count_get(smp->sm_sp, &val) != 0)
                val = 0;
        knp->value.ui64 = val;
        knp++;

done:
        return (0);

fail1:
        DTRACE_PROBE1(fail1, int, rc);

        return (rc);
}

static int
sfxge_mac_kstat_init(sfxge_t *sp)
{
        sfxge_mac_t *smp = &(sp->s_mac);
        dev_info_t *dip = sp->s_dip;
        char name[MAXNAMELEN];
        kstat_t *ksp;
        kstat_named_t *knp;
        unsigned int id;
        int rc;

        /* Create the set */
        (void) snprintf(name, MAXNAMELEN - 1, "%s_mac", ddi_driver_name(dip));

        if ((ksp = kstat_create((char *)ddi_driver_name(dip),
            ddi_get_instance(dip), name, "mac", KSTAT_TYPE_NAMED,
            EFX_MAC_NSTATS + 8, 0)) == NULL) {
                rc = ENOMEM;
                goto fail1;
        }

        smp->sm_ksp = ksp;

        ksp->ks_update = sfxge_mac_kstat_update;
        ksp->ks_private = smp;
        ksp->ks_lock = &(smp->sm_lock);

        /* Initialise the named stats */
        smp->sm_stat = knp = ksp->ks_data;
        for (id = 0; id < EFX_MAC_NSTATS; id++) {
                kstat_named_init(knp, (char *)efx_mac_stat_name(sp->s_enp, id),
                    KSTAT_DATA_UINT64);
                knp++;
        }

        kstat_named_init(knp++, "link_up", KSTAT_DATA_UINT64);
        kstat_named_init(knp++, "link_speed", KSTAT_DATA_UINT64);
        kstat_named_init(knp++, "link_duplex", KSTAT_DATA_UINT64);
        kstat_named_init(knp++, "fcntl_generate", KSTAT_DATA_UINT64);
        kstat_named_init(knp++, "fcntl_respond", KSTAT_DATA_UINT64);
        kstat_named_init(knp++, "intr_moderation", KSTAT_DATA_UINT64);
        kstat_named_init(knp++, "rx_coalesce_mode", KSTAT_DATA_UINT64);
        kstat_named_init(knp++, "rx_scale_count", KSTAT_DATA_UINT64);

        kstat_install(ksp);

        return (0);

fail1:
        DTRACE_PROBE1(fail1, int, rc);

        return (rc);
}

static void
sfxge_mac_kstat_fini(sfxge_t *sp)
{
        sfxge_mac_t *smp = &(sp->s_mac);

        /* Destroy the set */
        kstat_delete(smp->sm_ksp);
        smp->sm_ksp = NULL;
        smp->sm_stat = NULL;
}

void
sfxge_mac_stat_get(sfxge_t *sp, unsigned int id, uint64_t *valp)
{
        sfxge_mac_t *smp = &(sp->s_mac);

        /* Make sure the cached counter values are recent */
        mutex_enter(&(smp->sm_lock));

        if (smp->sm_state != SFXGE_MAC_STARTED)
                goto done;

        sfxge_mac_stat_update_quick(smp);

        *valp = smp->sm_stat[id].value.ui64;

done:
        mutex_exit(&(smp->sm_lock));
}

static void
sfxge_mac_poll(void *arg)
{
        sfxge_t *sp = arg;
        efx_nic_t *enp = sp->s_enp;
        sfxge_mac_t *smp = &(sp->s_mac);
        efsys_mem_t *esmp = &(smp->sm_mem);
        efx_link_mode_t mode;
        clock_t timeout;

        mutex_enter(&(smp->sm_lock));
        while (smp->sm_state == SFXGE_MAC_STARTED) {

                /* clears smp->sm_mac_stats_pend if appropriate */
                if (smp->sm_mac_stats_pend)
                        sfxge_mac_stat_update_wait(smp);

                /* This may sleep waiting for MCDI completion */
                mode = EFX_LINK_UNKNOWN;
                if (efx_port_poll(enp, &mode) == 0)
                        sfxge_mac_link_update_locked(sp, mode);

                if ((smp->sm_link_poll_reqd == B_FALSE) &&
                    (smp->sm_mac_stats_timer_reqd == B_FALSE))
                        goto done;

                /* Zero the memory */
                bzero(esmp->esm_base, EFX_MAC_STATS_SIZE);

                /* Trigger upload the MAC statistics counters */
                if (smp->sm_link_up &&
                    efx_mac_stats_upload(sp->s_enp, esmp) == 0)
                        smp->sm_mac_stats_pend = B_TRUE;

                /* Wait for timeout or end of polling */
                timeout = ddi_get_lbolt() + drv_usectohz(1000 *
                    SFXGE_MAC_POLL_PERIOD_MS);
                while (smp->sm_state == SFXGE_MAC_STARTED) {
                        if (cv_timedwait(&(smp->sm_link_poll_kv),
                            &(smp->sm_lock), timeout) < 0) {
                                /* Timeout - poll if polling still enabled */
                                break;
                        }
                }
        }
done:
        mutex_exit(&(smp->sm_lock));

}

static void
sfxge_mac_poll_start(sfxge_t *sp)
{
        sfxge_mac_t *smp = &(sp->s_mac);

        ASSERT(mutex_owned(&(smp->sm_lock)));
        ASSERT3U(smp->sm_state, ==, SFXGE_MAC_STARTED);

        /* Schedule a poll */
        (void) ddi_taskq_dispatch(smp->sm_tqp, sfxge_mac_poll, sp, DDI_SLEEP);
}

static void
sfxge_mac_poll_stop(sfxge_t *sp)
{
        sfxge_mac_t *smp = &(sp->s_mac);

        ASSERT(mutex_owned(&(smp->sm_lock)));
        ASSERT3U(smp->sm_state, ==, SFXGE_MAC_INITIALIZED);

        cv_broadcast(&(smp->sm_link_poll_kv));

        /* Wait for link polling to cease */
        mutex_exit(&(smp->sm_lock));
        ddi_taskq_wait(smp->sm_tqp);
        mutex_enter(&(smp->sm_lock));

        /* Collect the final statistics. */
        sfxge_mac_stat_update_wait(smp);
}

int
sfxge_mac_init(sfxge_t *sp)
{
        sfxge_mac_t *smp = &(sp->s_mac);
        efsys_mem_t *esmp = &(smp->sm_mem);
        dev_info_t *dip = sp->s_dip;
        sfxge_dma_buffer_attr_t dma_attr;
        const efx_nic_cfg_t *encp;
        unsigned char *bytes;
        unsigned int n;
        int err, rc;

        SFXGE_OBJ_CHECK(smp, sfxge_mac_t);

        ASSERT3U(smp->sm_state, ==, SFXGE_MAC_UNINITIALIZED);

        smp->sm_sp = sp;
        encp = efx_nic_cfg_get(sp->s_enp);
        smp->sm_link_poll_reqd = (~encp->enc_features &
            EFX_FEATURE_LINK_EVENTS);
        smp->sm_mac_stats_timer_reqd = (~encp->enc_features &
            EFX_FEATURE_PERIODIC_MAC_STATS);

        mutex_init(&(smp->sm_lock), NULL, MUTEX_DRIVER,
            DDI_INTR_PRI(sp->s_intr.si_intr_pri));
        cv_init(&(smp->sm_link_poll_kv), NULL, CV_DRIVER, NULL);

        /* Create link poll taskq */
        smp->sm_tqp = ddi_taskq_create(dip, "mac_tq", 1, TASKQ_DEFAULTPRI, 0);
        if (smp->sm_tqp == NULL) {
                rc = ENOMEM;
                goto fail1;
        }

        if ((rc = sfxge_phy_init(sp)) != 0)
                goto fail2;

        dma_attr.sdba_dip        = dip;
        dma_attr.sdba_dattrp     = &sfxge_mac_dma_attr;
        dma_attr.sdba_callback   = DDI_DMA_SLEEP;
        dma_attr.sdba_length     = EFX_MAC_STATS_SIZE;
        dma_attr.sdba_memflags   = DDI_DMA_CONSISTENT;
        dma_attr.sdba_devaccp    = &sfxge_mac_devacc;
        dma_attr.sdba_bindflags  = DDI_DMA_READ | DDI_DMA_CONSISTENT;
        dma_attr.sdba_maxcookies = 1;
        dma_attr.sdba_zeroinit   = B_TRUE;

        if ((rc = sfxge_dma_buffer_create(esmp, &dma_attr)) != 0)
                goto fail3;

        /* Set the initial flow control values */
        smp->sm_fcntl = EFX_FCNTL_RESPOND | EFX_FCNTL_GENERATE;

        /*
         * Determine the 'burnt-in' MAC address:
         *
         * A: if the "mac-address" property is set on our device node use that.
         * B: otherwise, use the value from NVRAM.
         */

        /* A: property  */
        err = ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
            "mac-address", &bytes, &n);
        switch (err) {
        case DDI_PROP_SUCCESS:
                if (n == ETHERADDRL) {
                        bcopy(bytes, smp->sm_bia, ETHERADDRL);
                        goto done;
                }

                ddi_prop_free(bytes);
                break;

        default:
                break;
        }

        /* B: NVRAM */
        bcopy(encp->enc_mac_addr, smp->sm_bia, ETHERADDRL);

done:
        /* Initialize the statistics */
        if ((rc = sfxge_mac_kstat_init(sp)) != 0)
                goto fail4;

        if ((rc = sfxge_phy_kstat_init(sp)) != 0)
                goto fail5;

        smp->sm_state = SFXGE_MAC_INITIALIZED;

        return (0);

fail5:
        DTRACE_PROBE(fail5);

        sfxge_mac_kstat_fini(sp);
fail4:
        DTRACE_PROBE(fail4);

        /* Tear down DMA setup */
        sfxge_dma_buffer_destroy(esmp);
fail3:
        DTRACE_PROBE(fail3);

        sfxge_phy_fini(sp);
fail2:
        DTRACE_PROBE(fail2);

        /* Destroy the link poll taskq */
        ddi_taskq_destroy(smp->sm_tqp);
        smp->sm_tqp = NULL;

fail1:
        DTRACE_PROBE1(fail1, int, rc);

        cv_destroy(&(smp->sm_link_poll_kv));

        mutex_destroy(&(smp->sm_lock));

        smp->sm_sp = NULL;

        return (rc);
}

static int
sfxge_mac_filter_apply(sfxge_t *sp)
{
        efx_nic_t *enp = sp->s_enp;
        sfxge_mac_t *smp = &(sp->s_mac);
        int rc;

        ASSERT(mutex_owned(&(smp->sm_lock)));

        if (smp->sm_state == SFXGE_MAC_STARTED) {
                boolean_t all_unicst;
                boolean_t mulcst;
                boolean_t all_mulcst;
                boolean_t brdcst;

                all_unicst = (smp->sm_promisc == SFXGE_PROMISC_ALL_PHYS);
                mulcst = (smp->sm_mcast_count > 0);
                all_mulcst = (smp->sm_promisc >= SFXGE_PROMISC_ALL_MULTI);
                brdcst = B_TRUE;

                if ((rc = efx_mac_filter_set(enp, all_unicst, mulcst,
                    all_mulcst, brdcst)) != 0) {
                        goto fail1;
                }
                if ((rc = efx_mac_multicast_list_set(enp,
                    smp->sm_mcast_addr, smp->sm_mcast_count)) != 0)
                        goto fail2;
        }

        return (0);

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

        return (rc);
}

int
sfxge_mac_start(sfxge_t *sp, boolean_t restart)
{
        sfxge_mac_t *smp = &(sp->s_mac);
        efsys_mem_t *esmp = &(smp->sm_mem);
        efx_nic_t *enp = sp->s_enp;
        size_t pdu;
        int rc;

        mutex_enter(&(smp->sm_lock));

        ASSERT3U(smp->sm_state, ==, SFXGE_MAC_INITIALIZED);

        if ((rc = efx_port_init(enp)) != 0)
                goto fail1;

        /*
         * Set up the advertised capabilities that may have been asked for
         * before the call to efx_port_init().
         */
        if ((rc = sfxge_phy_cap_apply(sp, !restart)) != 0)
                goto fail2;

        /* Set the SDU */
        pdu = EFX_MAC_PDU(sp->s_mtu);
        if ((rc = efx_mac_pdu_set(enp, pdu)) != 0)
                goto fail3;

        if ((rc = efx_mac_fcntl_set(enp, smp->sm_fcntl, B_TRUE)) != 0)
                goto fail4;

        /* Set the unicast address */
        if ((rc = efx_mac_addr_set(enp, (smp->sm_laa_valid) ?
            smp->sm_laa : smp->sm_bia)) != 0)
                goto fail5;

        if ((rc = sfxge_mac_filter_apply(sp)) != 0)
                goto fail6;

        if (!smp->sm_mac_stats_timer_reqd) {
                if ((rc = efx_mac_stats_periodic(enp, esmp,
                    SFXGE_MAC_POLL_PERIOD_MS, B_FALSE)) != 0)
                        goto fail7;
        }

        if ((rc = efx_mac_drain(enp, B_FALSE)) != 0)
                goto fail8;

        smp->sm_state = SFXGE_MAC_STARTED;

        /*
         * Start link state polling. For hardware that reports link change
         * events we still poll once to update the initial link state.
         */
        sfxge_mac_poll_start(sp);

        mutex_exit(&(smp->sm_lock));
        return (0);

fail8:
        DTRACE_PROBE(fail8);
        (void) efx_mac_stats_periodic(enp, esmp, 0, B_FALSE);
fail7:
        DTRACE_PROBE(fail7);
fail6:
        DTRACE_PROBE(fail6);
fail5:
        DTRACE_PROBE(fail5);
fail4:
        DTRACE_PROBE(fail4);
fail3:
        DTRACE_PROBE(fail3);
fail2:
        DTRACE_PROBE(fail2);
        efx_port_fini(enp);
fail1:
        DTRACE_PROBE1(fail1, int, rc);

        mutex_exit(&(smp->sm_lock));

        return (rc);
}


static void
sfxge_mac_link_update_locked(sfxge_t *sp, efx_link_mode_t mode)
{
        sfxge_mac_t *smp = &(sp->s_mac);
        const char *change, *duplex;
        char info[sizeof (": now 10000Mbps FULL duplex")];

        ASSERT(mutex_owned(&(smp->sm_lock)));
        if (smp->sm_state != SFXGE_MAC_STARTED)
                return;

        if (smp->sm_link_mode == mode)
                return;

        smp->sm_link_mode = mode;
        smp->sm_link_up = B_TRUE;

        switch (smp->sm_link_mode) {
        case EFX_LINK_UNKNOWN:
        case EFX_LINK_DOWN:
                smp->sm_link_speed = 0;
                smp->sm_link_duplex = SFXGE_LINK_DUPLEX_UNKNOWN;
                smp->sm_link_up = B_FALSE;
                break;

        case EFX_LINK_10HDX:
        case EFX_LINK_10FDX:
                smp->sm_link_speed = 10;
                smp->sm_link_duplex = (smp->sm_link_mode == EFX_LINK_10HDX) ?
                    SFXGE_LINK_DUPLEX_HALF : SFXGE_LINK_DUPLEX_FULL;
                break;

        case EFX_LINK_100HDX:
        case EFX_LINK_100FDX:
                smp->sm_link_speed = 100;
                smp->sm_link_duplex = (smp->sm_link_mode == EFX_LINK_100HDX) ?
                    SFXGE_LINK_DUPLEX_HALF : SFXGE_LINK_DUPLEX_FULL;
                break;

        case EFX_LINK_1000HDX:
        case EFX_LINK_1000FDX:
                smp->sm_link_speed = 1000;
                smp->sm_link_duplex = (smp->sm_link_mode == EFX_LINK_1000HDX) ?
                    SFXGE_LINK_DUPLEX_HALF : SFXGE_LINK_DUPLEX_FULL;
                break;

        case EFX_LINK_10000FDX:
                smp->sm_link_speed = 10000;
                smp->sm_link_duplex = SFXGE_LINK_DUPLEX_FULL;
                break;

        case EFX_LINK_40000FDX:
                smp->sm_link_speed = 40000;
                smp->sm_link_duplex = SFXGE_LINK_DUPLEX_FULL;
                break;

        default:
                ASSERT(B_FALSE);
                break;
        }

        duplex = (smp->sm_link_duplex == SFXGE_LINK_DUPLEX_FULL) ?
            "full" : "half";
        change = (smp->sm_link_up) ? "UP" : "DOWN";
        (void) snprintf(info, sizeof (info), ": now %dMbps %s duplex",
            smp->sm_link_speed, duplex);

        dev_err(sp->s_dip, CE_NOTE, SFXGE_CMN_ERR "Link %s%s",
            change, smp->sm_link_up ? info : "");

        /* Push link state update to the OS */
        sfxge_gld_link_update(sp);
}

void
sfxge_mac_link_update(sfxge_t *sp, efx_link_mode_t mode)
{
        sfxge_mac_t *smp = &(sp->s_mac);

        mutex_enter(&(smp->sm_lock));
        sfxge_mac_link_update_locked(sp, mode);
        mutex_exit(&(smp->sm_lock));
}

void
sfxge_mac_link_check(sfxge_t *sp, boolean_t *upp)
{
        sfxge_mac_t *smp = &(sp->s_mac);

        mutex_enter(&(smp->sm_lock));
        *upp = smp->sm_link_up;
        mutex_exit(&(smp->sm_lock));
}

void
sfxge_mac_link_speed_get(sfxge_t *sp, unsigned int *speedp)
{
        sfxge_mac_t *smp = &(sp->s_mac);

        mutex_enter(&(smp->sm_lock));
        *speedp = smp->sm_link_speed;
        mutex_exit(&(smp->sm_lock));
}

void
sfxge_mac_link_duplex_get(sfxge_t *sp, sfxge_link_duplex_t *duplexp)
{
        sfxge_mac_t *smp = &(sp->s_mac);

        mutex_enter(&(smp->sm_lock));
        *duplexp = smp->sm_link_duplex;
        mutex_exit(&(smp->sm_lock));
}

void
sfxge_mac_fcntl_get(sfxge_t *sp, unsigned int *fcntlp)
{
        sfxge_mac_t *smp = &(sp->s_mac);

        mutex_enter(&(smp->sm_lock));
        *fcntlp = smp->sm_fcntl;
        mutex_exit(&(smp->sm_lock));
}

int
sfxge_mac_fcntl_set(sfxge_t *sp, unsigned int fcntl)
{
        sfxge_mac_t *smp = &(sp->s_mac);
        int rc;

        mutex_enter(&(smp->sm_lock));

        if (smp->sm_fcntl == fcntl)
                goto done;

        smp->sm_fcntl = fcntl;

        if (smp->sm_state != SFXGE_MAC_STARTED)
                goto done;

        if ((rc = efx_mac_fcntl_set(sp->s_enp, smp->sm_fcntl, B_TRUE)) != 0)
                goto fail1;

done:
        mutex_exit(&(smp->sm_lock));

        return (0);

fail1:
        DTRACE_PROBE1(fail1, int, rc);

        mutex_exit(&(smp->sm_lock));

        return (rc);
}

int
sfxge_mac_unicst_get(sfxge_t *sp, sfxge_unicst_type_t type, uint8_t *addr)
{
        sfxge_mac_t *smp = &(sp->s_mac);
        int rc;

        if (type >= SFXGE_UNICST_NTYPES) {
                rc = EINVAL;
                goto fail1;
        }

        mutex_enter(&(smp->sm_lock));

        if (smp->sm_state != SFXGE_MAC_INITIALIZED &&
            smp->sm_state != SFXGE_MAC_STARTED) {
                rc = EFAULT;
                goto fail2;
        }

        switch (type) {
        case SFXGE_UNICST_BIA:
                bcopy(smp->sm_bia, addr, ETHERADDRL);
                break;

        case SFXGE_UNICST_LAA:
                if (!(smp->sm_laa_valid)) {
                        rc = ENOENT;
                        goto fail3;
                }

                bcopy(smp->sm_laa, addr, ETHERADDRL);
                break;

        default:
                ASSERT(B_FALSE);
                break;
        }

        mutex_exit(&(smp->sm_lock));

        return (0);


fail3:
        DTRACE_PROBE(fail3);
fail2:
        DTRACE_PROBE(fail2);

        mutex_exit(&(smp->sm_lock));

fail1:
        DTRACE_PROBE1(fail1, int, rc);

        return (rc);
}

int
sfxge_mac_unicst_set(sfxge_t *sp, uint8_t *addr)
{
        sfxge_mac_t *smp = &(sp->s_mac);
        efx_nic_t *enp = sp->s_enp;
        boolean_t old_mac_valid;
        uint8_t old_mac[ETHERADDRL];
        int rc;

        mutex_enter(&(smp->sm_lock));

        old_mac_valid = smp->sm_laa_valid;
        if (old_mac_valid)
                bcopy(smp->sm_laa, old_mac, ETHERADDRL);

        bcopy(addr, smp->sm_laa, ETHERADDRL);
        smp->sm_laa_valid = B_TRUE;

        if (smp->sm_state != SFXGE_MAC_STARTED)
                goto done;

        if (efx_nic_cfg_get(enp)->enc_allow_set_mac_with_installed_filters) {
                if ((rc = efx_mac_addr_set(enp, smp->sm_laa)) != 0) {
                        dev_err(sp->s_dip, CE_NOTE, SFXGE_CMN_ERR
                            "unable to set unicast MAC filter");
                        goto fail1;
                }
        } else {
                /* Older EF10 firmware requires a device start */
                mutex_exit(&smp->sm_lock);
                sfxge_stop(sp);
                if ((rc = sfxge_start(sp, B_TRUE)) != 0) {
                        dev_err(sp->s_dip, CE_NOTE, SFXGE_CMN_ERR
                            "unable to restart with a new MAC");
                        mutex_enter(&(smp->sm_lock));
                        goto fail1;
                }
                mutex_enter(&smp->sm_lock);
        }

        if ((rc = efx_mac_addr_set(enp, smp->sm_laa)) != 0)
                goto fail1;

done:
        mutex_exit(&(smp->sm_lock));

        return (0);

fail1:
        if (old_mac_valid)
                bcopy(old_mac, smp->sm_laa, ETHERADDRL);
        else
                smp->sm_laa_valid = B_FALSE;

        DTRACE_PROBE1(fail1, int, rc);

        mutex_exit(&(smp->sm_lock));

        return (rc);
}

int
sfxge_mac_promisc_set(sfxge_t *sp, sfxge_promisc_type_t promisc)
{
        sfxge_mac_t *smp = &(sp->s_mac);
        int rc;

        mutex_enter(&(smp->sm_lock));

        if (smp->sm_promisc == promisc)
                goto done;

        smp->sm_promisc = promisc;

        if ((rc = sfxge_mac_filter_apply(sp)) != 0)
                goto fail1;

done:
        mutex_exit(&(smp->sm_lock));
        return (0);

fail1:
        DTRACE_PROBE1(fail1, int, rc);
        mutex_exit(&(smp->sm_lock));

        return (rc);
}

int
sfxge_mac_multicst_add(sfxge_t *sp, const uint8_t *addr)
{
        sfxge_mac_t *smp = &(sp->s_mac);
        int i;
        int rc;

        mutex_enter(&(smp->sm_lock));

        if ((addr[0] & 0x1) == 0) {
                rc = EINVAL;
                goto fail1;
        }

        /* Check if the address is already in the list */
        i = 0;
        while (i < smp->sm_mcast_count) {
                if (bcmp(smp->sm_mcast_addr + (i * ETHERADDRL),
                    addr, ETHERADDRL) == 0)
                        goto done;
                else
                        i++;
        }

        if (smp->sm_mcast_count >= EFX_MAC_MULTICAST_LIST_MAX) {
                rc = ENOENT;
                goto fail1;
        }

        /* Add to the list */
        bcopy(addr, smp->sm_mcast_addr + (smp->sm_mcast_count++ * ETHERADDRL),
            ETHERADDRL);

        if ((rc = sfxge_mac_filter_apply(sp)) != 0)
                goto fail2;

done:
        mutex_exit(&(smp->sm_lock));
        return (0);

fail2:
        DTRACE_PROBE(fail2);
        smp->sm_mcast_count--;
fail1:
        DTRACE_PROBE1(fail1, int, rc);
        mutex_exit(&(smp->sm_lock));

        return (rc);
}

int
sfxge_mac_multicst_remove(sfxge_t *sp, const uint8_t *addr)
{
        sfxge_mac_t *smp = &(sp->s_mac);
        int i;
        int rc;

        mutex_enter(&(smp->sm_lock));

        i = 0;
        while (i < smp->sm_mcast_count) {
                if (bcmp(smp->sm_mcast_addr + (i * ETHERADDRL),
                    addr, ETHERADDRL) == 0) {
                        (void) memmove(smp->sm_mcast_addr + (i * ETHERADDRL),
                            smp->sm_mcast_addr + ((i + 1) * ETHERADDRL),
                            (smp->sm_mcast_count - (i + 1)) * ETHERADDRL);
                        smp->sm_mcast_count--;
                } else
                        i++;
        }

        if ((rc = sfxge_mac_filter_apply(sp)) != 0)
                goto fail1;

        mutex_exit(&(smp->sm_lock));
        return (0);

fail1:
        DTRACE_PROBE1(fail1, int, rc);
        mutex_exit(&(smp->sm_lock));

        return (rc);
}

void
sfxge_mac_stop(sfxge_t *sp)
{
        sfxge_mac_t *smp = &(sp->s_mac);
        efx_nic_t *enp = sp->s_enp;
        efsys_mem_t *esmp = &(smp->sm_mem);

        mutex_enter(&(smp->sm_lock));

        ASSERT3U(smp->sm_state, ==, SFXGE_MAC_STARTED);
        ASSERT3P(smp->sm_sp, ==, sp);
        smp->sm_state = SFXGE_MAC_INITIALIZED;

        /* If stopping in response to an MC reboot this may fail */
        if (!smp->sm_mac_stats_timer_reqd)
                (void) efx_mac_stats_periodic(enp, esmp, 0, B_FALSE);

        sfxge_mac_poll_stop(sp);

        smp->sm_lbolt = 0;

        smp->sm_link_up = B_FALSE;
        smp->sm_link_speed = 0;
        smp->sm_link_duplex = SFXGE_LINK_DUPLEX_UNKNOWN;

        /* This may call MCDI */
        (void) efx_mac_drain(enp, B_TRUE);

        smp->sm_link_mode = EFX_LINK_UNKNOWN;

        efx_port_fini(enp);

        mutex_exit(&(smp->sm_lock));
}

void
sfxge_mac_fini(sfxge_t *sp)
{
        sfxge_mac_t *smp = &(sp->s_mac);
        efsys_mem_t *esmp = &(smp->sm_mem);

        ASSERT3U(smp->sm_state, ==, SFXGE_MAC_INITIALIZED);
        ASSERT3P(smp->sm_sp, ==, sp);

        /* Tear down the statistics */
        sfxge_phy_kstat_fini(sp);
        sfxge_mac_kstat_fini(sp);

        smp->sm_state = SFXGE_MAC_UNINITIALIZED;
        smp->sm_link_mode = EFX_LINK_UNKNOWN;
        smp->sm_promisc = SFXGE_PROMISC_OFF;

        bzero(smp->sm_mcast_addr, sizeof (smp->sm_mcast_addr));
        smp->sm_mcast_count = 0;

        bzero(smp->sm_laa, ETHERADDRL);
        smp->sm_laa_valid = B_FALSE;

        bzero(smp->sm_bia, ETHERADDRL);

        smp->sm_fcntl = 0;

        /* Finish with PHY DMA memory */
        sfxge_phy_fini(sp);

        /* Teardown the DMA */
        sfxge_dma_buffer_destroy(esmp);

        /* Destroy the link poll taskq */
        ddi_taskq_destroy(smp->sm_tqp);
        smp->sm_tqp = NULL;

        mutex_destroy(&(smp->sm_lock));

        smp->sm_sp = NULL;
}