/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * mii - MII/PHY support for MAC drivers
 *
 * Utility module to provide a consistent interface to a MAC driver accross
 * different implementations of PHY devices
 */

#include <sys/types.h>
#include <sys/debug.h>
#include <sys/errno.h>
#include <sys/param.h>
#include <sys/sysmacros.h>
#include <sys/stropts.h>
#include <sys/stream.h>
#include <sys/kmem.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/devops.h>
#include <sys/modctl.h>
#include <sys/cmn_err.h>
#include <sys/miiregs.h>
#include "dnet_mii.h"


#ifdef DEBUG
#define MIIDEBUG
int miidebug = 0;
#define MIITRACE 1
#define MIIDUMP 2
#define MIIPROBE 4
#define MIICOMPAT 8
#endif

/* Local functions */
static struct phydata *mii_get_valid_phydata(mii_handle_t mac, int phy);
static void mii_portmon(mii_handle_t mac);

/* Vendor specific callback function prototypes */
static void dump_NS83840(mii_handle_t, int);
static void dump_ICS1890(struct mii_info *, int);
static int getspeed_NS83840(mii_handle_t, int, int *, int *);
static int getspeed_82553(mii_handle_t, int, int *, int *);
static int getspeed_ICS1890(mii_handle_t, int, int *, int *);
static int getspeed_generic(mii_handle_t, int, int *, int *);
static void postreset_ICS1890(mii_handle_t mac, int phy);
static void postreset_NS83840(mii_handle_t mac, int phy);

/*
 * MII Interface functions
 */

/*
 * Register an instance of an MII interface user
 */

int
mii_create(dev_info_t *dip,             /* Passed to read/write functions */
            mii_writefunc_t writefunc,  /* How to write to a MII register */
            mii_readfunc_t readfunc,    /* How to read from a MII regster */
            mii_handle_t *macp)
{
        mii_handle_t mac;

        /*  Allocate space for the mii structure */
        if ((mac = (mii_handle_t)
            kmem_zalloc(sizeof (struct mii_info), KM_NOSLEEP)) == NULL)
                return (MII_NOMEM);

        mac->mii_write = writefunc;
        mac->mii_read = readfunc;
        mac->mii_dip = dip;
        *macp = mac;
        return (MII_SUCCESS);
}

/*
 * Returns true if PHY at address phy is accessible. This should be
 * considered the only function that takes a PHY address that can be called
 * before mii_init_phy. There should be at least one bit set in the status
 * register, and at least one clear
 */
int
mii_probe_phy(mii_handle_t mac, int phy)
{
        ushort_t status;
        dev_info_t *dip;

        if (!mac || phy < 0 || phy > 31)
                return (MII_PARAM);

        dip = mac->mii_dip;

        /* Clear any latched bits by reading twice */
        mac->mii_read(dip, phy, MII_STATUS);
        status = mac->mii_read(dip, phy, MII_STATUS);

#ifdef MIIDEBUG
        mac->mii_read(dip, phy, MII_CONTROL);
        if (miidebug & MIIPROBE)
                cmn_err(CE_NOTE, "PHY Probe: Control=%x, Status=%x",
                    mac->mii_read(dip, phy, MII_CONTROL), status);
#endif
        /*
         * At least one bit in status should be clear (one of the error
         * bits), and there must be at least one bit set for the device
         * capabilities. Unconnected devices tend to show 0xffff, but 0x0000
         * has been seen.
         */

        if (status == 0xffff || status == 0x0000)
                return (MII_PHYNOTPRESENT);
        return (MII_SUCCESS);
}

/*
 * Initialise PHY, and store info about it in the handle for future
 * reference when the MAC calls us. PHY Vendor-specific code here isolates
 * the LAN driver from worrying about different PHY implementations
 */

int
mii_init_phy(mii_handle_t mac, int phy)
{
        ushort_t status;
        void *dip;
        struct phydata *phydata;

        if ((mac == (mii_handle_t)NULL) || phy < 0 || phy > 31)
                return (MII_PARAM);

        dip = mac->mii_dip;

        /* Create a phydata structure for this new phy */
        if (mac->phys[phy])
                return (MII_PHYPRESENT);

        mac->phys[phy] = phydata = (struct phydata *)
            kmem_zalloc(sizeof (struct phydata), KM_NOSLEEP);

        if (!phydata)
                return (MII_NOMEM);

        phydata->id = (ulong_t)mac->mii_read(dip, phy, MII_PHYIDH) << 16;
        phydata->id |= (ulong_t)mac->mii_read(dip, phy, MII_PHYIDL);
        phydata->state = phy_state_unknown;

        /* Override speed and duplex mode from conf-file if present */
        phydata->fix_duplex =
            ddi_getprop(DDI_DEV_T_NONE,
            mac->mii_dip, DDI_PROP_DONTPASS, "full-duplex", 0);

        phydata->fix_speed =
            ddi_getprop(DDI_DEV_T_NONE,
            mac->mii_dip, DDI_PROP_DONTPASS, "speed", 0);

        status = mac->mii_read(dip, phy, MII_STATUS);

        /*
         * when explicitly setting speed or duplex, we must
         * disable autonegotiation
         */
        if (!(status & MII_STATUS_CANAUTONEG) ||
            phydata->fix_speed || phydata->fix_duplex) {
                /*
                 * If local side cannot autonegotiate, we can't try to enable
                 * full duplex without the user's consent, because we cannot
                 * tell without AN if the partner can support it
                 */
                if ((status & (MII_STATUS_100_BASEX | MII_STATUS_100_BASEX_FD |
                    MII_STATUS_100_BASE_T4)) && phydata->fix_speed == 0) {
                        phydata->fix_speed = 100;
                } else if ((status & (MII_STATUS_10 | MII_STATUS_10_FD)) &&
                    phydata->fix_speed == 0) {
                        phydata->fix_speed = 10;
                } else if (phydata->fix_speed == 0) {
                        /* A very stupid PHY would not be supported */
                        kmem_free(mac->phys[phy], sizeof (struct phydata));
                        mac->phys[phy] = NULL;
                        return (MII_NOTSUPPORTED);
                }
                /* mii_sync will sort out the speed selection on the PHY */
        } else
                phydata->control = MII_CONTROL_ANE;

        switch (MII_PHY_MFG(phydata->id)) {
        case OUI_NATIONAL_SEMICONDUCTOR:
                switch (MII_PHY_MODEL(phydata->id)) {
                case NS_DP83840:
                        phydata->phy_postreset = postreset_NS83840;
                        phydata->phy_dump = dump_NS83840;
                        phydata->description =
                            "National Semiconductor DP-83840";
                        phydata->phy_getspeed = getspeed_NS83840;
                        break;
                default:
                        phydata->description = "Unknown NS";
                        break;
                }
                break;

        case OUI_INTEL:
                switch (MII_PHY_MODEL(phydata->id)) {
                case INTEL_82553_CSTEP:
                        phydata->description = "Intel 82553 C-step";
                        phydata->phy_getspeed = getspeed_82553;
                        break;
                case INTEL_82555:
                        phydata->description = "Intel 82555";
                        phydata->phy_getspeed = getspeed_82553;
                        break;
                case INTEL_82562_EH:
                        phydata->description = "Intel 82562 EH";
                        phydata->phy_getspeed = getspeed_82553;
                        break;
                case INTEL_82562_ET:
                        phydata->description = "Intel 82562 ET";
                        phydata->phy_getspeed = getspeed_82553;
                        break;
                case INTEL_82562_EM:
                        phydata->description = "Intel 82562 EM";
                        phydata->phy_getspeed = getspeed_82553;
                        break;
                default:
                        phydata->description = "Unknown INTEL";
                        break;
                }
                break;

        case OUI_ICS:
                switch (MII_PHY_MODEL(phydata->id)) {
                case ICS_1890:
                case ICS_1889:
                        phydata->phy_postreset = postreset_ICS1890;
                        phydata->description = "ICS 1890/1889 PHY";
                        phydata->phy_getspeed = getspeed_ICS1890;
                        phydata->phy_dump = dump_ICS1890;
                        break;
                default:
                        phydata->description = "ICS Unknown PHY";
                        break;
                }
                break;

        default: /* Non-standard PHYs, that encode weird IDs */
                phydata->description = "Unknown PHY";
                phydata->phy_dump = NULL;
                phydata->phy_getspeed = getspeed_generic;
                break;
        }

        /* Do all post-reset hacks and user settings */
        (void) mii_sync(mac, phy);

        if (ddi_getprop(DDI_DEV_T_NONE, mac->mii_dip, DDI_PROP_DONTPASS,
            "dump-phy", 0))
                (void) mii_dump_phy(mac, phy);

        return (MII_SUCCESS);
}

/*
 * Cause a reset on a PHY
 */

int
mii_reset_phy(mii_handle_t mac, int phy, enum mii_wait_type wait)
{
        int i;
        struct phydata *phyd;
        ushort_t control;
        if (!(phyd = mii_get_valid_phydata(mac, phy)))
                return (MII_PARAM);

        /* Strobe the reset bit in the control register */
        mac->mii_write(mac->mii_dip, phy, MII_CONTROL,
            phyd->control | MII_CONTROL_RESET);

        phyd->state = phy_state_unknown;

        /*
         * This is likely to be very fast (ie, by the time we read the
         * control register once, the devices we have seen can have already
         * reset), but according to 802.3u 22.2.4.1.1, it could be up to .5 sec.
         */
        if (wait == mii_wait_interrupt || wait == mii_wait_user) {
                for (i = 100; i--; ) {
                        control = mac->mii_read(mac->mii_dip, phy, MII_CONTROL);
                        if (!(control & MII_CONTROL_RESET))
                                break;
                        drv_usecwait(10);
                }
                if (i)
                        goto reset_completed;
        }

        if (wait == mii_wait_user) {
                for (i = 50; i--; ) {
                        control = mac->mii_read(mac->mii_dip, phy, MII_CONTROL);
                        if (!(control & MII_CONTROL_RESET))
                                break;
                        delay(drv_usectohz(10000));
                }
                if (i)
                        goto reset_completed;
                return (MII_HARDFAIL);  /* It MUST reset within this time */

        }
        return (MII_TIMEOUT);

reset_completed:
        (void) mii_sync(mac, phy);
        return (MII_SUCCESS);
}

/*
 * This routine is called to synchronise the software and the PHY. It should
 * be called after the PHY is reset, and after initialising the PHY. This
 * routine is external because devices (DNET) can reset the PHY in ways beyond
 * the control of the mii interface. Should this happen, the driver is
 * required to call mii_sync().
 * If the PHY is resetting still when this is called, it will do nothing,
 * but, it will be retriggered when the portmon timer expires.
 */

int
mii_sync(mii_handle_t mac, int phy)
{
        struct phydata *phyd = mac->phys[phy];
        int len, i, numprop;
        struct regprop {
                int reg;
                int value;
        } *regprop;

#ifdef MIIDEBUG
        if (miidebug & MIITRACE)
                cmn_err(CE_NOTE, "mii_sync (phy addr %d)", phy);
#endif

        len = 0;
        /*
         * Conf file can specify a sequence of values to write to
         * the PHY registers if required
         */
        if (ddi_getlongprop(DDI_DEV_T_ANY, mac->mii_dip,
            DDI_PROP_DONTPASS, "phy-registers", (caddr_t)&regprop,
            &len) == DDI_PROP_SUCCESS) {
                numprop = len / sizeof (struct regprop);
                for (i = 0; i < numprop; i++) {
                        mac->mii_write(mac->mii_dip, phy,
                            regprop[i].reg, regprop[i].value);
#ifdef MIIDEBUG
                        if (miidebug & MIITRACE)
                                cmn_err(CE_NOTE, "PHY Write reg %d=%x",
                                    regprop[i].reg, regprop[i].value);
#endif
                }
                kmem_free(regprop, len);
        } else {
                mac->mii_write(mac->mii_dip, phy, MII_CONTROL, phyd->control);
                if (phyd->phy_postreset)
                        phyd->phy_postreset(mac, phy);
                if (phyd->fix_speed || phyd->fix_duplex) {
                        /* XXX function return value ignored */
                        (void) mii_fixspeed(mac, phy, phyd->fix_speed,
                            phyd->fix_duplex);
                }
        }
        return (MII_SUCCESS);
}

/*
 * Disable full-duplex negotiation on the PHY. This is useful if the
 * driver or link-partner is advertising full duplex, but does not support
 * it properly (as some previous solaris drivers didn't)
 */

int
mii_disable_fullduplex(mii_handle_t mac, int phy)
{
        void *dip = mac->mii_dip;
        ushort_t expansion,  miiadvert;
        /* dont advertise full duplex capabilites */
        const int fullduplex = MII_ABILITY_10BASE_T_FD
            | MII_ABILITY_100BASE_TX_FD;

        if (!(mac->mii_read(dip, phy, MII_STATUS) & MII_STATUS_CANAUTONEG)) {
                /*
                 * Local side cannot autonegotiate, so full duplex should
                 * never be negotiated. Consider it as a success
                 */
                return (MII_SUCCESS);
        }

        /* Change what we advertise if it includes full duplex */

        miiadvert = mac->mii_read(dip, phy, MII_AN_ADVERT);
        if (miiadvert & fullduplex)
                mac->mii_write(dip, phy, MII_AN_ADVERT,
                    miiadvert & ~fullduplex);

        /* See what other end is able to do.  */

        expansion = mac->mii_read(dip, phy, MII_AN_EXPANSION);

        /*
         * Renegotiate if the link partner supports autonegotiation
         * If it doesn't, we will never have auto-negotiated full duplex
         * anyway
         */

        if (expansion & MII_AN_EXP_LPCANAN)
                return (mii_rsan(mac, phy, mii_wait_none));
        else
                return (MII_SUCCESS);
}

/*
 * (re)enable autonegotiation on a PHY.
 */

int
mii_autoneg_enab(mii_handle_t mac, int phy)
{
        struct phydata *phyd;
        if (!(phyd = mii_get_valid_phydata(mac, phy)))
                return (MII_PARAM);
        phyd->control |= MII_CONTROL_ANE;
        mac->mii_write(mac->mii_dip, phy, MII_CONTROL, phyd->control);
        return (MII_SUCCESS);
}

/*
 * Check the link status of a PHY connection
 */
int
mii_linkup(mii_handle_t mac, int phy)
{
        ushort_t status;

        /*
         * Link status latches, so we need to read it twice, to make sure we
         * get its current status
         */
        mac->mii_read(mac->mii_dip, phy, MII_STATUS);
        status = mac->mii_read(mac->mii_dip, phy, MII_STATUS);

        if (status != 0xffff && (status & MII_STATUS_LINKUP))
                return (1);
        else
                return (0);
}

/*
 * Discover what speed the PHY is running at, irrespective of wheather it
 * autonegotiated this, or was fixed at that rate.
 */

int
mii_getspeed(mii_handle_t mac, int phy, int *speed, int *fulld)
{
        struct phydata *phyd;

        if (!(phyd = mii_get_valid_phydata(mac, phy)))
                return (MII_PARAM);
        if (!(phyd->control & MII_CONTROL_ANE)) {
                /*
                 * user has requested fixed speed operation, return what we
                 * wrote to the control registerfrom control register
                 */

                *speed = phyd->control & MII_CONTROL_100MB ? 100:10;
                *fulld = phyd->control & MII_CONTROL_FDUPLEX ? 1:0;
                return (MII_SUCCESS);
        }

        if (!phyd->phy_getspeed) /* No standard way to do this(!) */
                return (MII_NOTSUPPORTED);

        return (phyd->phy_getspeed(mac, phy, speed, fulld));
}

/*
 * Fix the speed and duplex mode of a PHY
 */

int
mii_fixspeed(mii_handle_t mac, int phy, int speed, int fullduplex)
{
        struct phydata *phyd;

#ifdef MIIDEBUG
        cmn_err(CE_CONT, "!%s: setting speed to %d, %s duplex",
            ddi_get_name(mac->mii_dip), speed,
            fullduplex ? "full" : "half");
#endif

        if (!(phyd = mii_get_valid_phydata(mac, phy)))
                return (MII_PARAM);
        phyd->control &= ~MII_CONTROL_ANE;

        if (speed == 100)
                phyd->control |= MII_CONTROL_100MB;
        else if (speed == 10)
                phyd->control &= ~MII_CONTROL_100MB;
        else
                cmn_err(CE_NOTE, "%s: mii does not support %d Mb/s speed",
                    ddi_get_name(mac->mii_dip), speed);

        if (fullduplex)
                phyd->control |= MII_CONTROL_FDUPLEX;
        else
                phyd->control &= ~MII_CONTROL_FDUPLEX;

        mac->mii_write(mac->mii_dip, phy, MII_CONTROL, phyd->control);
        phyd->fix_speed = speed;
        phyd->fix_duplex = fullduplex;
        return (MII_SUCCESS);
}
/*
 * Electrically isolate/unisolate the PHY
 */

int
mii_isolate(mii_handle_t mac, int phy)
{
        struct phydata *phyd;

        if (!(phyd = mii_get_valid_phydata(mac, phy)))
                return (MII_PARAM);

        phyd->control |= MII_CONTROL_ISOLATE;
        mac->mii_write(mac->mii_dip, phy, MII_CONTROL, phyd->control);

        /* Wait for device to settle */
        drv_usecwait(50);
        return (MII_SUCCESS);
}

int
mii_unisolate(mii_handle_t mac, int phy)
{
        struct phydata *phyd;

        if (!(phyd = mii_get_valid_phydata(mac, phy)))
                return (MII_PARAM);

        phyd->control &= ~MII_CONTROL_ISOLATE;
        mac->mii_write(mac->mii_dip, phy, MII_CONTROL, phyd->control);
        return (MII_SUCCESS);
}

/*
 * Restart autonegotiation on a PHY
 */

int
mii_rsan(mii_handle_t mac, int phy, enum mii_wait_type wait)
{
        int i;
        void *dip;
        struct phydata *phyd;

        if (wait == mii_wait_interrupt ||
            !(phyd = mii_get_valid_phydata(mac, phy)))
                return (MII_PARAM);

        if (phyd->fix_speed)
                return (MII_STATE);

        dip = mac->mii_dip;

        phyd->control |= MII_CONTROL_ANE;
        mac->mii_write(dip, phy, MII_CONTROL, phyd->control|MII_CONTROL_RSAN);

        /*
         * This can take ages (a second or so). It makes more sense to use
         * the port monitor rather than waiting for completion of this on the
         * PHY. It is pointless doing a busy wait here
         */

        if (wait == mii_wait_user) {
                for (i = 200; i--; ) {
                        delay(drv_usectohz(10000));
                        if (mac->mii_read(dip, phy, MII_STATUS) &
                            MII_STATUS_ANDONE)
                                return (MII_SUCCESS);
                }
                cmn_err(CE_NOTE,
                    "!%s:Timed out waiting for autonegotiation",
                    ddi_get_name(mac->mii_dip));
                return (MII_TIMEOUT);
        }
        return (MII_TIMEOUT);
}

/*
 * Debuging function to dump contents of PHY registers
 */
int
mii_dump_phy(mii_handle_t mac, int phy)
{
        struct phydata *phydat;

        char *miiregs[] = {
                "Control             ",
                "Status              ",
                "PHY Id(H)           ",
                "PHY Id(L)           ",
                "Advertisement       ",
                "Link Partner Ability",
                "Expansion           ",
                "Next Page Transmit  ",
                0
        };
        int i;

        if (!(phydat = mii_get_valid_phydata(mac, phy)))
                return (MII_PARAM);

        cmn_err(CE_NOTE, "%s: PHY %d, type %s", ddi_get_name(mac->mii_dip), phy,
            phydat->description ? phydat->description: "Unknown");

        for (i = 0; miiregs[i]; i++)
                cmn_err(CE_NOTE, "%s:\t%x",
                    miiregs[i], mac->mii_read(mac->mii_dip, phy, i));

        if (phydat->phy_dump)
                phydat->phy_dump((struct mii_info *)mac, phy);

        return (MII_SUCCESS);
}

/*
 * Start a periodic check to monitor the MII devices attached, and callback
 * to the MAC driver when the state on a device changes
 */

int
mii_start_portmon(mii_handle_t mac, mii_linkfunc_t notify, kmutex_t *lock)
{
        if (mac->mii_linknotify || mac->portmon_timer)
                return (MII_STATE);
        mac->mii_linknotify = notify;
        /*
         * NOTE: Portmon is normally called through a timeout. In the case
         * of starting off, we assume that the lock is already held
         */
        mac->lock = NULL; /* portmon wont try to aquire any lock this time */
        mii_portmon(mac);
        mac->lock = lock;
        return (MII_SUCCESS);
}

int
mii_stop_portmon(mii_handle_t mac)
{
        if (!mac->mii_linknotify || !mac->portmon_timer)
                return (MII_STATE);

        mac->mii_linknotify = NULL;
        mac->lock = NULL;
        (void) untimeout(mac->portmon_timer);
        mac->portmon_timer = 0;
        return (MII_SUCCESS);
}

static void
mii_portmon(mii_handle_t mac)
{
        int i;
        enum mii_phy_state state;
        struct phydata *phydata;

        /*
         * There is a potential deadlock between this test and the
         * mutex_enter
         */
        if (!mac->mii_linknotify) /* Exiting */
                return;

        if (mac->lock)
                mutex_enter(mac->lock);

        /*
         * For each initialised phy, see if the link state has changed, and
         * callback to the mac driver if it has
         */
        for (i = 0; i < 32; i++) {
                if ((phydata = mac->phys[i]) != 0) {
                        state = mii_linkup(mac, i) ?
                            phy_state_linkup : phy_state_linkdown;
                        if (state != phydata->state) {
#ifdef MIIDEBUG
                                if (miidebug)
                                        cmn_err(CE_NOTE, "%s: PHY %d link %s",
                                            ddi_get_name(mac->mii_dip), i,
                                            state == phy_state_linkup ?
                                            "up" : "down");
#endif
                                phydata->state = state;
                                mac->mii_linknotify(mac->mii_dip, i, state);
                        }
                }
        }
        /* Check the ports every 5 seconds */
        mac->portmon_timer = timeout((void (*)(void*))mii_portmon, (void *)mac,
            (clock_t)(5 * drv_usectohz(1000000)));
        if (mac->lock)
                mutex_exit(mac->lock);
}

/*
 * Close a handle to the MII interface from a registered user
 */

void
mii_destroy(mii_handle_t mac)
{
        /* Free per-PHY information */
        int i;

        (void) mii_stop_portmon(mac);

        for (i = 0; i < 32; i++)
                if (mac->phys[i])
                        kmem_free(mac->phys[i], sizeof (struct phydata));

        kmem_free(mac, sizeof (*mac));
}

/*
 * Get a PHY data structure from an MII handle, and validate the common
 * parameters to the MII functions. Used to verify parameters in most MII
 * functions
 */
static struct phydata *
mii_get_valid_phydata(mii_handle_t mac, int phy)
{
        if (!mac || phy > 31 || phy < 0 || !mac->phys[phy]) {
                ASSERT(!"MII: Bad invocation");
                return (NULL);
        }
        return (mac->phys[phy]);
}
/*
 * Device-specific routines - National Semiconductor
 */

#define BIT(bit, value) ((value) & (1<<(bit)))
static void
dump_NS83840(mii_handle_t mac, int phy)
{
        ushort_t reg;
        void *dip;

        dip = mac->mii_dip;
        cmn_err(CE_NOTE, "Disconnect count: %x",
            mac->mii_read(dip, phy, 0x12));
        cmn_err(CE_NOTE, "False Carrier detect count: %x",
            mac->mii_read(dip, phy, 0x13));
        cmn_err(CE_NOTE, "Receive error count: %x",
            mac->mii_read(dip, phy, 0x15));
        cmn_err(CE_NOTE, "Silicon revision: %x",
            mac->mii_read(dip, phy, 0x16));
        cmn_err(CE_NOTE, "PCS Configuration : %x",
            mac->mii_read(dip, phy, 0x17));

        cmn_err(CE_NOTE, "Loopback, Bypass and Receiver error mask: %x",
            mac->mii_read(dip, phy, 0x18));
        cmn_err(CE_NOTE, "Wired phy address: %x",
            mac->mii_read(dip, phy, 0x19)&0xf);

        reg = mac->mii_read(dip, phy, 0x1b);
        cmn_err(CE_NOTE, "10 Base T in %s mode",
            BIT(9, reg) ? "serial":"nibble");

        cmn_err(CE_NOTE, "%slink pulses, %sheartbeat, %s,%s squelch,jabber %s",
            BIT(reg, 5) ? "" : "no ",
            BIT(reg, 4) ? "" : "no ",
            BIT(reg, 3) ? "UTP" : "STP",
            BIT(reg, 2) ? "low" : "normal",
            BIT(reg, 0) ? "enabled" : "disabled");
}

static int
getspeed_NS83840(mii_handle_t mac, int phy, int *speed, int *fulld)
{
        int exten =  mac->mii_read(mac->mii_dip, phy, MII_AN_EXPANSION);
        if (exten & MII_AN_EXP_LPCANAN) {
                /*
                 * Link partner can auto-neg, take speed from LP Ability
                 * register
                 */
                int lpable, anadv, mask;

                lpable = mac->mii_read(mac->mii_dip, phy, MII_AN_LPABLE);
                anadv = mac->mii_read(mac->mii_dip, phy, MII_AN_ADVERT);
                mask = anadv & lpable;

                if (mask & MII_ABILITY_100BASE_TX_FD) {
                        *speed = 100;
                        *fulld = 1;
                } else if (mask & MII_ABILITY_100BASE_T4) {
                        *speed = 100;
                        *fulld = 0;
                } else if (mask & MII_ABILITY_100BASE_TX) {
                        *speed = 100;
                        *fulld = 0;
                } else if (mask & MII_ABILITY_10BASE_T_FD) {
                        *speed = 10;
                        *fulld = 1;
                } else if (mask & MII_ABILITY_10BASE_T) {
                        *speed = 10;
                        *fulld = 0;
                }
        } else {
                int addr = mac->mii_read(mac->mii_dip, phy, MII_83840_ADDR);
                *speed = (addr & NS83840_ADDR_SPEED10) ? 10:100;
                /* No fullduplex without autonegotiation on link partner */
                *fulld = 0;
        }
        return (0);
}

/*
 * Device-specific routines - INTEL
 */

static int
getspeed_82553(mii_handle_t mac, int phy, int *speed, int *fulld)
{
        int ex0 = mac->mii_read(mac->mii_dip, phy, MII_82553_EX0);
        *fulld = (ex0 & I82553_EX0_FDUPLEX) ? 1:0;
        *speed = (ex0 & I82553_EX0_100MB) ? 100:10;
        return (0);
}

/*
 * Device-specific routines - ICS
 */

static int
getspeed_ICS1890(mii_handle_t mac, int phy, int *speed, int *fulld)
{
        ushort_t quickpoll = mac->mii_read(mac->mii_dip, phy, ICS_QUICKPOLL);
        *speed = (quickpoll & ICS_QUICKPOLL_100MB) ? 100 : 10;
        *fulld = (quickpoll & ICS_QUICKPOLL_FDUPLEX) ? 1 : 0;
        return (0);
}

static void
dump_ICS1890(mii_handle_t mac, int phy)
{
        ushort_t quickpoll = mac->mii_read(mac->mii_dip, phy, ICS_QUICKPOLL);
        cmn_err(CE_NOTE, "QuickPoll:%x (Speed:%d FullDuplex:%c) ",
            quickpoll,
            quickpoll & ICS_QUICKPOLL_100MB ? 100:10,
            quickpoll & ICS_QUICKPOLL_FDUPLEX ? 'Y' : 'N');
}

static void
postreset_NS83840(mii_handle_t mac, int phy)
{
        ushort_t reg;
        struct phydata *phyd = mac->phys[phy];
        /*
         * As per INTEL "PRO/100B Adapter Software Technical
         * Reference Manual", set bit 10 of MII register 23.
         * National Semiconductor documentation shows this as
         * "reserved, write to as zero". We also set the
         * "f_connect" bit, also as requested by the PRO/100B
         * doc
         */

        reg = mac->mii_read(mac->mii_dip, phy, 23) | (1<<10) | (1<<5);
        mac->mii_write(mac->mii_dip, phy, 23, reg);

        /*
         * Some of thses PHYs seem to reset with the wrong value in the
         * AN advertisment register. It should containt 1e1, indicating that
         * the device can do 802.3 10BASE-T, 10BASE-T Full duplex, 100BASE-TX,
         * and 100 BASE-TX full duplex. Instead it seems to advertise only
         * 100BASE-TX Full duplex. The result of this is that the device will
         * NOT autonegotiate at all against a 10MB only or 100MB/Half duplex
         * autonegotiating hub
         * NEEDSWORK:
         * There is possibly a time-dependancy here.
         * If the autonegotiation has completed BEFORE we get to here
         * (after the reset) then this could possibly have not effect
         */
        if (!phyd->fix_speed) {
#ifdef MIIDEBUG
                if (miidebug & MIICOMPAT)
                        cmn_err(CE_NOTE, "Reset value of AN_ADV reg:%x",
                            mac->mii_read(mac->mii_dip, phy, MII_AN_ADVERT));
#endif
                mac->mii_write(mac->mii_dip, phy, MII_AN_ADVERT, 0x1e1);
        }
}

void
postreset_ICS1890(mii_handle_t mac, int phy)
{
        /* This device comes up isolated if no link is found */
        (void) mii_unisolate(mac, phy);
}

/*
 * generic getspeed routine
 */
static int
getspeed_generic(mii_handle_t mac, int phy, int *speed, int *fulld)
{
        int exten =  mac->mii_read(mac->mii_dip, phy, MII_AN_EXPANSION);
        if (exten & MII_AN_EXP_LPCANAN) {
                /*
                 * Link partner can auto-neg, take speed from LP Ability
                 * register
                 */
                int lpable, anadv, mask;

                lpable = mac->mii_read(mac->mii_dip, phy, MII_AN_LPABLE);
                anadv = mac->mii_read(mac->mii_dip, phy, MII_AN_ADVERT);
                mask = anadv & lpable;

                if (mask & MII_ABILITY_100BASE_TX_FD) {
                        *speed = 100;
                        *fulld = 1;
                } else if (mask & MII_ABILITY_100BASE_T4) {
                        *speed = 100;
                        *fulld = 0;
                } else if (mask & MII_ABILITY_100BASE_TX) {
                        *speed = 100;
                        *fulld = 0;
                } else if (mask & MII_ABILITY_10BASE_T_FD) {
                        *speed = 10;
                        *fulld = 1;
                } else if (mask & MII_ABILITY_10BASE_T) {
                        *speed = 10;
                        *fulld = 0;
                }
        } else {
                /*
                 * Link partner cannot auto-neg, it would be nice if we
                 * could figure out what the device selected.  (NWay?)
                 */
                *speed = 0;
                *fulld = 0;
        }
        return (MII_SUCCESS);
}