[linux-2.6-block.git] / drivers / net / mii.c

/*

	mii.c: MII interface library

	Maintained by Jeff Garzik <jgarzik@pobox.com>
	Copyright 2001,2002 Jeff Garzik

	Various code came from myson803.c and other files by
	Donald Becker.  Copyright:

		Written 1998-2002 by Donald Becker.

		This software may be used and distributed according
		to the terms of the GNU General Public License (GPL),
		incorporated herein by reference.  Drivers based on
		or derived from this code fall under the GPL and must
		retain the authorship, copyright and license notice.
		This file is not a complete program and may only be
		used when the entire operating system is licensed
		under the GPL.

		The author may be reached as becker@scyld.com, or C/O
		Scyld Computing Corporation
		410 Severn Ave., Suite 210
		Annapolis MD 21403


 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/ethtool.h>
#include <linux/mii.h>

static u32 mii_get_an(struct mii_if_info *mii, u16 addr)
{
	int advert;

	advert = mii->mdio_read(mii->dev, mii->phy_id, addr);

	return mii_lpa_to_ethtool_lpa_t(advert);
}

/**
 * mii_ethtool_gset - get settings that are specified in @ecmd
 * @mii: MII interface
 * @ecmd: requested ethtool_cmd
 *
 * The @ecmd parameter is expected to have been cleared before calling
 * mii_ethtool_gset().
 *
 * Returns 0 for success, negative on error.
 */
int mii_ethtool_gset(struct mii_if_info *mii, struct ethtool_cmd *ecmd)
{
	struct net_device *dev = mii->dev;
	u16 bmcr, bmsr, ctrl1000 = 0, stat1000 = 0;
	u32 nego;

	ecmd->supported =
	    (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
	     SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
	     SUPPORTED_Autoneg | SUPPORTED_TP | SUPPORTED_MII);
	if (mii->supports_gmii)
		ecmd->supported |= SUPPORTED_1000baseT_Half |
			SUPPORTED_1000baseT_Full;

	/* only supports twisted-pair */
	ecmd->port = PORT_MII;

	/* only supports internal transceiver */
	ecmd->transceiver = XCVR_INTERNAL;

	/* this isn't fully supported at higher layers */
	ecmd->phy_address = mii->phy_id;
	ecmd->mdio_support = ETH_MDIO_SUPPORTS_C22;

	ecmd->advertising = ADVERTISED_TP | ADVERTISED_MII;

	bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
	bmsr = mii->mdio_read(dev, mii->phy_id, MII_BMSR);
	if (mii->supports_gmii) {
 		ctrl1000 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
		stat1000 = mii->mdio_read(dev, mii->phy_id, MII_STAT1000);
	}
	if (bmcr & BMCR_ANENABLE) {
		ecmd->advertising |= ADVERTISED_Autoneg;
		ecmd->autoneg = AUTONEG_ENABLE;

		ecmd->advertising |= mii_get_an(mii, MII_ADVERTISE);
		if (mii->supports_gmii)
			ecmd->advertising |=
					mii_ctrl1000_to_ethtool_adv_t(ctrl1000);

		if (bmsr & BMSR_ANEGCOMPLETE) {
			ecmd->lp_advertising = mii_get_an(mii, MII_LPA);
			ecmd->lp_advertising |=
					mii_stat1000_to_ethtool_lpa_t(stat1000);
		} else {
			ecmd->lp_advertising = 0;
		}

		nego = ecmd->advertising & ecmd->lp_advertising;

		if (nego & (ADVERTISED_1000baseT_Full |
			    ADVERTISED_1000baseT_Half)) {
			ethtool_cmd_speed_set(ecmd, SPEED_1000);
			ecmd->duplex = !!(nego & ADVERTISED_1000baseT_Full);
		} else if (nego & (ADVERTISED_100baseT_Full |
				   ADVERTISED_100baseT_Half)) {
			ethtool_cmd_speed_set(ecmd, SPEED_100);
			ecmd->duplex = !!(nego & ADVERTISED_100baseT_Full);
		} else {
			ethtool_cmd_speed_set(ecmd, SPEED_10);
			ecmd->duplex = !!(nego & ADVERTISED_10baseT_Full);
		}
	} else {
		ecmd->autoneg = AUTONEG_DISABLE;

		ethtool_cmd_speed_set(ecmd,
				      ((bmcr & BMCR_SPEED1000 &&
					(bmcr & BMCR_SPEED100) == 0) ?
				       SPEED_1000 :
				       ((bmcr & BMCR_SPEED100) ?
					SPEED_100 : SPEED_10)));
		ecmd->duplex = (bmcr & BMCR_FULLDPLX) ? DUPLEX_FULL : DUPLEX_HALF;
	}

	mii->full_duplex = ecmd->duplex;

	/* ignore maxtxpkt, maxrxpkt for now */

	return 0;
}

/**
 * mii_ethtool_get_link_ksettings - get settings that are specified in @cmd
 * @mii: MII interface
 * @cmd: requested ethtool_link_ksettings
 *
 * The @cmd parameter is expected to have been cleared before calling
 * mii_ethtool_get_link_ksettings().
 *
 * Returns 0 for success, negative on error.
 */
int mii_ethtool_get_link_ksettings(struct mii_if_info *mii,
				   struct ethtool_link_ksettings *cmd)
{
	struct net_device *dev = mii->dev;
	u16 bmcr, bmsr, ctrl1000 = 0, stat1000 = 0;
	u32 nego, supported, advertising, lp_advertising;

	supported = (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
		     SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
		     SUPPORTED_Autoneg | SUPPORTED_TP | SUPPORTED_MII);
	if (mii->supports_gmii)
		supported |= SUPPORTED_1000baseT_Half |
			SUPPORTED_1000baseT_Full;

	/* only supports twisted-pair */
	cmd->base.port = PORT_MII;

	/* this isn't fully supported at higher layers */
	cmd->base.phy_address = mii->phy_id;
	cmd->base.mdio_support = ETH_MDIO_SUPPORTS_C22;

	advertising = ADVERTISED_TP | ADVERTISED_MII;

	bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
	bmsr = mii->mdio_read(dev, mii->phy_id, MII_BMSR);
	if (mii->supports_gmii) {
		ctrl1000 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
		stat1000 = mii->mdio_read(dev, mii->phy_id, MII_STAT1000);
	}
	if (bmcr & BMCR_ANENABLE) {
		advertising |= ADVERTISED_Autoneg;
		cmd->base.autoneg = AUTONEG_ENABLE;

		advertising |= mii_get_an(mii, MII_ADVERTISE);
		if (mii->supports_gmii)
			advertising |= mii_ctrl1000_to_ethtool_adv_t(ctrl1000);

		if (bmsr & BMSR_ANEGCOMPLETE) {
			lp_advertising = mii_get_an(mii, MII_LPA);
			lp_advertising |=
					mii_stat1000_to_ethtool_lpa_t(stat1000);
		} else {
			lp_advertising = 0;
		}

		nego = advertising & lp_advertising;

		if (nego & (ADVERTISED_1000baseT_Full |
			    ADVERTISED_1000baseT_Half)) {
			cmd->base.speed = SPEED_1000;
			cmd->base.duplex = !!(nego & ADVERTISED_1000baseT_Full);
		} else if (nego & (ADVERTISED_100baseT_Full |
				   ADVERTISED_100baseT_Half)) {
			cmd->base.speed = SPEED_100;
			cmd->base.duplex = !!(nego & ADVERTISED_100baseT_Full);
		} else {
			cmd->base.speed = SPEED_10;
			cmd->base.duplex = !!(nego & ADVERTISED_10baseT_Full);
		}
	} else {
		cmd->base.autoneg = AUTONEG_DISABLE;

		cmd->base.speed = ((bmcr & BMCR_SPEED1000 &&
				    (bmcr & BMCR_SPEED100) == 0) ?
				   SPEED_1000 :
				   ((bmcr & BMCR_SPEED100) ?
				    SPEED_100 : SPEED_10));
		cmd->base.duplex = (bmcr & BMCR_FULLDPLX) ?
			DUPLEX_FULL : DUPLEX_HALF;

		lp_advertising = 0;
	}

	mii->full_duplex = cmd->base.duplex;

	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
						supported);
	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
						advertising);
	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.lp_advertising,
						lp_advertising);

	/* ignore maxtxpkt, maxrxpkt for now */

	return 0;
}

/**
 * mii_ethtool_sset - set settings that are specified in @ecmd
 * @mii: MII interface
 * @ecmd: requested ethtool_cmd
 *
 * Returns 0 for success, negative on error.
 */
int mii_ethtool_sset(struct mii_if_info *mii, struct ethtool_cmd *ecmd)
{
	struct net_device *dev = mii->dev;
	u32 speed = ethtool_cmd_speed(ecmd);

	if (speed != SPEED_10 &&
	    speed != SPEED_100 &&
	    speed != SPEED_1000)
		return -EINVAL;
	if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
		return -EINVAL;
	if (ecmd->port != PORT_MII)
		return -EINVAL;
	if (ecmd->transceiver != XCVR_INTERNAL)
		return -EINVAL;
	if (ecmd->phy_address != mii->phy_id)
		return -EINVAL;
	if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
		return -EINVAL;
	if ((speed == SPEED_1000) && (!mii->supports_gmii))
		return -EINVAL;

	/* ignore supported, maxtxpkt, maxrxpkt */

	if (ecmd->autoneg == AUTONEG_ENABLE) {
		u32 bmcr, advert, tmp;
		u32 advert2 = 0, tmp2 = 0;

		if ((ecmd->advertising & (ADVERTISED_10baseT_Half |
					  ADVERTISED_10baseT_Full |
					  ADVERTISED_100baseT_Half |
					  ADVERTISED_100baseT_Full |
					  ADVERTISED_1000baseT_Half |
					  ADVERTISED_1000baseT_Full)) == 0)
			return -EINVAL;

		/* advertise only what has been requested */
		advert = mii->mdio_read(dev, mii->phy_id, MII_ADVERTISE);
		tmp = advert & ~(ADVERTISE_ALL | ADVERTISE_100BASE4);
		if (mii->supports_gmii) {
			advert2 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
			tmp2 = advert2 & ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);
		}
		tmp |= ethtool_adv_to_mii_adv_t(ecmd->advertising);

		if (mii->supports_gmii)
			tmp2 |=
			      ethtool_adv_to_mii_ctrl1000_t(ecmd->advertising);
		if (advert != tmp) {
			mii->mdio_write(dev, mii->phy_id, MII_ADVERTISE, tmp);
			mii->advertising = tmp;
		}
		if ((mii->supports_gmii) && (advert2 != tmp2))
			mii->mdio_write(dev, mii->phy_id, MII_CTRL1000, tmp2);

		/* turn on autonegotiation, and force a renegotiate */
		bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
		bmcr |= (BMCR_ANENABLE | BMCR_ANRESTART);
		mii->mdio_write(dev, mii->phy_id, MII_BMCR, bmcr);

		mii->force_media = 0;
	} else {
		u32 bmcr, tmp;

		/* turn off auto negotiation, set speed and duplexity */
		bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
		tmp = bmcr & ~(BMCR_ANENABLE | BMCR_SPEED100 |
			       BMCR_SPEED1000 | BMCR_FULLDPLX);
		if (speed == SPEED_1000)
			tmp |= BMCR_SPEED1000;
		else if (speed == SPEED_100)
			tmp |= BMCR_SPEED100;
		if (ecmd->duplex == DUPLEX_FULL) {
			tmp |= BMCR_FULLDPLX;
			mii->full_duplex = 1;
		} else
			mii->full_duplex = 0;
		if (bmcr != tmp)
			mii->mdio_write(dev, mii->phy_id, MII_BMCR, tmp);

		mii->force_media = 1;
	}
	return 0;
}

/**
 * mii_ethtool_set_link_ksettings - set settings that are specified in @cmd
 * @mii: MII interfaces
 * @cmd: requested ethtool_link_ksettings
 *
 * Returns 0 for success, negative on error.
 */
int mii_ethtool_set_link_ksettings(struct mii_if_info *mii,
				   const struct ethtool_link_ksettings *cmd)
{
	struct net_device *dev = mii->dev;
	u32 speed = cmd->base.speed;

	if (speed != SPEED_10 &&
	    speed != SPEED_100 &&
	    speed != SPEED_1000)
		return -EINVAL;
	if (cmd->base.duplex != DUPLEX_HALF && cmd->base.duplex != DUPLEX_FULL)
		return -EINVAL;
	if (cmd->base.port != PORT_MII)
		return -EINVAL;
	if (cmd->base.phy_address != mii->phy_id)
		return -EINVAL;
	if (cmd->base.autoneg != AUTONEG_DISABLE &&
	    cmd->base.autoneg != AUTONEG_ENABLE)
		return -EINVAL;
	if ((speed == SPEED_1000) && (!mii->supports_gmii))
		return -EINVAL;

	/* ignore supported, maxtxpkt, maxrxpkt */

	if (cmd->base.autoneg == AUTONEG_ENABLE) {
		u32 bmcr, advert, tmp;
		u32 advert2 = 0, tmp2 = 0;
		u32 advertising;

		ethtool_convert_link_mode_to_legacy_u32(
			&advertising, cmd->link_modes.advertising);

		if ((advertising & (ADVERTISED_10baseT_Half |
				    ADVERTISED_10baseT_Full |
				    ADVERTISED_100baseT_Half |
				    ADVERTISED_100baseT_Full |
				    ADVERTISED_1000baseT_Half |
				    ADVERTISED_1000baseT_Full)) == 0)
			return -EINVAL;

		/* advertise only what has been requested */
		advert = mii->mdio_read(dev, mii->phy_id, MII_ADVERTISE);
		tmp = advert & ~(ADVERTISE_ALL | ADVERTISE_100BASE4);
		if (mii->supports_gmii) {
			advert2 = mii->mdio_read(dev, mii->phy_id,
						 MII_CTRL1000);
			tmp2 = advert2 &
				~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);
		}
		tmp |= ethtool_adv_to_mii_adv_t(advertising);

		if (mii->supports_gmii)
			tmp2 |= ethtool_adv_to_mii_ctrl1000_t(advertising);
		if (advert != tmp) {
			mii->mdio_write(dev, mii->phy_id, MII_ADVERTISE, tmp);
			mii->advertising = tmp;
		}
		if ((mii->supports_gmii) && (advert2 != tmp2))
			mii->mdio_write(dev, mii->phy_id, MII_CTRL1000, tmp2);

		/* turn on autonegotiation, and force a renegotiate */
		bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
		bmcr |= (BMCR_ANENABLE | BMCR_ANRESTART);
		mii->mdio_write(dev, mii->phy_id, MII_BMCR, bmcr);

		mii->force_media = 0;
	} else {
		u32 bmcr, tmp;

		/* turn off auto negotiation, set speed and duplexity */
		bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
		tmp = bmcr & ~(BMCR_ANENABLE | BMCR_SPEED100 |
			       BMCR_SPEED1000 | BMCR_FULLDPLX);
		if (speed == SPEED_1000)
			tmp |= BMCR_SPEED1000;
		else if (speed == SPEED_100)
			tmp |= BMCR_SPEED100;
		if (cmd->base.duplex == DUPLEX_FULL) {
			tmp |= BMCR_FULLDPLX;
			mii->full_duplex = 1;
		} else {
			mii->full_duplex = 0;
		}
		if (bmcr != tmp)
			mii->mdio_write(dev, mii->phy_id, MII_BMCR, tmp);

		mii->force_media = 1;
	}
	return 0;
}

/**
 * mii_check_gmii_support - check if the MII supports Gb interfaces
 * @mii: the MII interface
 */
int mii_check_gmii_support(struct mii_if_info *mii)
{
	int reg;

	reg = mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
	if (reg & BMSR_ESTATEN) {
		reg = mii->mdio_read(mii->dev, mii->phy_id, MII_ESTATUS);
		if (reg & (ESTATUS_1000_TFULL | ESTATUS_1000_THALF))
			return 1;
	}

	return 0;
}

/**
 * mii_link_ok - is link status up/ok
 * @mii: the MII interface
 *
 * Returns 1 if the MII reports link status up/ok, 0 otherwise.
 */
int mii_link_ok (struct mii_if_info *mii)
{
	/* first, a dummy read, needed to latch some MII phys */
	mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
	if (mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR) & BMSR_LSTATUS)
		return 1;
	return 0;
}

/**
 * mii_nway_restart - restart NWay (autonegotiation) for this interface
 * @mii: the MII interface
 *
 * Returns 0 on success, negative on error.
 */
int mii_nway_restart (struct mii_if_info *mii)
{
	int bmcr;
	int r = -EINVAL;

	/* if autoneg is off, it's an error */
	bmcr = mii->mdio_read(mii->dev, mii->phy_id, MII_BMCR);

	if (bmcr & BMCR_ANENABLE) {
		bmcr |= BMCR_ANRESTART;
		mii->mdio_write(mii->dev, mii->phy_id, MII_BMCR, bmcr);
		r = 0;
	}

	return r;
}

/**
 * mii_check_link - check MII link status
 * @mii: MII interface
 *
 * If the link status changed (previous != current), call
 * netif_carrier_on() if current link status is Up or call
 * netif_carrier_off() if current link status is Down.
 */
void mii_check_link (struct mii_if_info *mii)
{
	int cur_link = mii_link_ok(mii);
	int prev_link = netif_carrier_ok(mii->dev);

	if (cur_link && !prev_link)
		netif_carrier_on(mii->dev);
	else if (prev_link && !cur_link)
		netif_carrier_off(mii->dev);
}

/**
 * mii_check_media - check the MII interface for a carrier/speed/duplex change
 * @mii: the MII interface
 * @ok_to_print: OK to print link up/down messages
 * @init_media: OK to save duplex mode in @mii
 *
 * Returns 1 if the duplex mode changed, 0 if not.
 * If the media type is forced, always returns 0.
 */
unsigned int mii_check_media (struct mii_if_info *mii,
			      unsigned int ok_to_print,
			      unsigned int init_media)
{
	unsigned int old_carrier, new_carrier;
	int advertise, lpa, media, duplex;
	int lpa2 = 0;

	/* check current and old link status */
	old_carrier = netif_carrier_ok(mii->dev) ? 1 : 0;
	new_carrier = (unsigned int) mii_link_ok(mii);

	/* if carrier state did not change, this is a "bounce",
	 * just exit as everything is already set correctly
	 */
	if ((!init_media) && (old_carrier == new_carrier))
		return 0; /* duplex did not change */

	/* no carrier, nothing much to do */
	if (!new_carrier) {
		netif_carrier_off(mii->dev);
		if (ok_to_print)
			netdev_info(mii->dev, "link down\n");
		return 0; /* duplex did not change */
	}

	/*
	 * we have carrier, see who's on the other end
	 */
	netif_carrier_on(mii->dev);

	if (mii->force_media) {
		if (ok_to_print)
			netdev_info(mii->dev, "link up\n");
		return 0; /* duplex did not change */
	}

	/* get MII advertise and LPA values */
	if ((!init_media) && (mii->advertising))
		advertise = mii->advertising;
	else {
		advertise = mii->mdio_read(mii->dev, mii->phy_id, MII_ADVERTISE);
		mii->advertising = advertise;
	}
	lpa = mii->mdio_read(mii->dev, mii->phy_id, MII_LPA);
	if (mii->supports_gmii)
		lpa2 = mii->mdio_read(mii->dev, mii->phy_id, MII_STAT1000);

	/* figure out media and duplex from advertise and LPA values */
	media = mii_nway_result(lpa & advertise);
	duplex = (media & ADVERTISE_FULL) ? 1 : 0;
	if (lpa2 & LPA_1000FULL)
		duplex = 1;

	if (ok_to_print)
		netdev_info(mii->dev, "link up, %uMbps, %s-duplex, lpa 0x%04X\n",
			    lpa2 & (LPA_1000FULL | LPA_1000HALF) ? 1000 :
			    media & (ADVERTISE_100FULL | ADVERTISE_100HALF) ?
			    100 : 10,
			    duplex ? "full" : "half",
			    lpa);

	if ((init_media) || (mii->full_duplex != duplex)) {
		mii->full_duplex = duplex;
		return 1; /* duplex changed */
	}

	return 0; /* duplex did not change */
}

/**
 * generic_mii_ioctl - main MII ioctl interface
 * @mii_if: the MII interface
 * @mii_data: MII ioctl data structure
 * @cmd: MII ioctl command
 * @duplex_chg_out: pointer to @duplex_changed status if there was no
 *	ioctl error
 *
 * Returns 0 on success, negative on error.
 */
int generic_mii_ioctl(struct mii_if_info *mii_if,
		      struct mii_ioctl_data *mii_data, int cmd,
		      unsigned int *duplex_chg_out)
{
	int rc = 0;
	unsigned int duplex_changed = 0;

	if (duplex_chg_out)
		*duplex_chg_out = 0;

	mii_data->phy_id &= mii_if->phy_id_mask;
	mii_data->reg_num &= mii_if->reg_num_mask;

	switch(cmd) {
	case SIOCGMIIPHY:
		mii_data->phy_id = mii_if->phy_id;
		/* fall through */

	case SIOCGMIIREG:
		mii_data->val_out =
			mii_if->mdio_read(mii_if->dev, mii_data->phy_id,
					  mii_data->reg_num);
		break;

	case SIOCSMIIREG: {
		u16 val = mii_data->val_in;

		if (mii_data->phy_id == mii_if->phy_id) {
			switch(mii_data->reg_num) {
			case MII_BMCR: {
				unsigned int new_duplex = 0;
				if (val & (BMCR_RESET|BMCR_ANENABLE))
					mii_if->force_media = 0;
				else
					mii_if->force_media = 1;
				if (mii_if->force_media &&
				    (val & BMCR_FULLDPLX))
					new_duplex = 1;
				if (mii_if->full_duplex != new_duplex) {
					duplex_changed = 1;
					mii_if->full_duplex = new_duplex;
				}
				break;
			}
			case MII_ADVERTISE:
				mii_if->advertising = val;
				break;
			default:
				/* do nothing */
				break;
			}
		}

		mii_if->mdio_write(mii_if->dev, mii_data->phy_id,
				   mii_data->reg_num, val);
		break;
	}

	default:
		rc = -EOPNOTSUPP;
		break;
	}

	if ((rc == 0) && (duplex_chg_out) && (duplex_changed))
		*duplex_chg_out = 1;

	return rc;
}

MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>");
MODULE_DESCRIPTION ("MII hardware support library");
MODULE_LICENSE("GPL");

EXPORT_SYMBOL(mii_link_ok);
EXPORT_SYMBOL(mii_nway_restart);
EXPORT_SYMBOL(mii_ethtool_gset);
EXPORT_SYMBOL(mii_ethtool_get_link_ksettings);
EXPORT_SYMBOL(mii_ethtool_sset);
EXPORT_SYMBOL(mii_ethtool_set_link_ksettings);
EXPORT_SYMBOL(mii_check_link);
EXPORT_SYMBOL(mii_check_media);
EXPORT_SYMBOL(mii_check_gmii_support);
EXPORT_SYMBOL(generic_mii_ioctl);
Commit	Line	Data
1da177e4 LT	1	/*
	2
	3	mii.c: MII interface library
	4
	5	Maintained by Jeff Garzik <jgarzik@pobox.com>
	6	Copyright 2001,2002 Jeff Garzik
	7
	8	Various code came from myson803.c and other files by
	9	Donald Becker. Copyright:
	10
	11	Written 1998-2002 by Donald Becker.
	12
	13	This software may be used and distributed according
	14	to the terms of the GNU General Public License (GPL),
	15	incorporated herein by reference. Drivers based on
	16	or derived from this code fall under the GPL and must
	17	retain the authorship, copyright and license notice.
	18	This file is not a complete program and may only be
	19	used when the entire operating system is licensed
	20	under the GPL.
	21
	22	The author may be reached as becker@scyld.com, or C/O
	23	Scyld Computing Corporation
	24	410 Severn Ave., Suite 210
	25	Annapolis MD 21403
	26
	27
	28	*/
	29
	30	#include <linux/kernel.h>
	31	#include <linux/module.h>
	32	#include <linux/netdevice.h>
	33	#include <linux/ethtool.h>
9c4df53b	34	#include <linux/mii.h>
5974700c BH	35
	36	static u32 mii_get_an(struct mii_if_info *mii, u16 addr)
	37	{
5974700c BH	38	int advert;
	39
	40	advert = mii->mdio_read(mii->dev, mii->phy_id, addr);
28011cf1	41
37f07023	42	return mii_lpa_to_ethtool_lpa_t(advert);
5974700c	43	}
1da177e4	44
32684ec6 RD	45	/**
	46	* mii_ethtool_gset - get settings that are specified in @ecmd
	47	* @mii: MII interface
	48	* @ecmd: requested ethtool_cmd
	49	*
8ae6daca DD	50	* The @ecmd parameter is expected to have been cleared before calling
	51	* mii_ethtool_gset().
	52	*
32684ec6 RD	53	* Returns 0 for success, negative on error.
32684ec6 RD	54	*/
1da177e4 LT	55	int mii_ethtool_gset(struct mii_if_info mii, struct ethtool_cmd ecmd)
	56	{
	57	struct net_device *dev = mii->dev;
5974700c BH	58	u16 bmcr, bmsr, ctrl1000 = 0, stat1000 = 0;
5974700c BH	59	u32 nego;
1da177e4 LT	60
	61	ecmd->supported =
	62	(SUPPORTED_10baseT_Half \| SUPPORTED_10baseT_Full \|
	63	SUPPORTED_100baseT_Half \| SUPPORTED_100baseT_Full \|
	64	SUPPORTED_Autoneg \| SUPPORTED_TP \| SUPPORTED_MII);
	65	if (mii->supports_gmii)
	66	ecmd->supported \|= SUPPORTED_1000baseT_Half \|
	67	SUPPORTED_1000baseT_Full;
	68
	69	/* only supports twisted-pair */
	70	ecmd->port = PORT_MII;
	71
	72	/* only supports internal transceiver */
	73	ecmd->transceiver = XCVR_INTERNAL;
	74
	75	/* this isn't fully supported at higher layers */
	76	ecmd->phy_address = mii->phy_id;
9c4df53b	77	ecmd->mdio_support = ETH_MDIO_SUPPORTS_C22;
1da177e4 LT	78
1da177e4 LT	79	ecmd->advertising = ADVERTISED_TP \| ADVERTISED_MII;
1da177e4 LT	80
1da177e4 LT	81	bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
5974700c	82	bmsr = mii->mdio_read(dev, mii->phy_id, MII_BMSR);
1da177e4	83	if (mii->supports_gmii) {
5974700c BH	84	ctrl1000 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
5974700c BH	85	stat1000 = mii->mdio_read(dev, mii->phy_id, MII_STAT1000);
1da177e4 LT	86	}
	87	if (bmcr & BMCR_ANENABLE) {
	88	ecmd->advertising \|= ADVERTISED_Autoneg;
	89	ecmd->autoneg = AUTONEG_ENABLE;
6aa20a22	90
5974700c	91	ecmd->advertising \|= mii_get_an(mii, MII_ADVERTISE);
28011cf1	92	if (mii->supports_gmii)
37f07023 MC	93	ecmd->advertising \|=
37f07023 MC	94	mii_ctrl1000_to_ethtool_adv_t(ctrl1000);
5974700c BH	95
	96	if (bmsr & BMSR_ANEGCOMPLETE) {
	97	ecmd->lp_advertising = mii_get_an(mii, MII_LPA);
28011cf1	98	ecmd->lp_advertising \|=
37f07023	99	mii_stat1000_to_ethtool_lpa_t(stat1000);
5974700c BH	100	} else {
	101	ecmd->lp_advertising = 0;
	102	}
	103
	104	nego = ecmd->advertising & ecmd->lp_advertising;
	105
	106	if (nego & (ADVERTISED_1000baseT_Full \|
	107	ADVERTISED_1000baseT_Half)) {
70739497	108	ethtool_cmd_speed_set(ecmd, SPEED_1000);
5974700c BH	109	ecmd->duplex = !!(nego & ADVERTISED_1000baseT_Full);
	110	} else if (nego & (ADVERTISED_100baseT_Full \|
	111	ADVERTISED_100baseT_Half)) {
70739497	112	ethtool_cmd_speed_set(ecmd, SPEED_100);
5974700c	113	ecmd->duplex = !!(nego & ADVERTISED_100baseT_Full);
1da177e4	114	} else {
70739497	115	ethtool_cmd_speed_set(ecmd, SPEED_10);
5974700c	116	ecmd->duplex = !!(nego & ADVERTISED_10baseT_Full);
1da177e4 LT	117	}
	118	} else {
	119	ecmd->autoneg = AUTONEG_DISABLE;
	120
70739497 DD	121	ethtool_cmd_speed_set(ecmd,
	122	((bmcr & BMCR_SPEED1000 &&
	123	(bmcr & BMCR_SPEED100) == 0) ?
	124	SPEED_1000 :
	125	((bmcr & BMCR_SPEED100) ?
	126	SPEED_100 : SPEED_10)));
1da177e4 LT	127	ecmd->duplex = (bmcr & BMCR_FULLDPLX) ? DUPLEX_FULL : DUPLEX_HALF;
	128	}
	129
5974700c BH	130	mii->full_duplex = ecmd->duplex;
5974700c BH	131
1da177e4 LT	132	/* ignore maxtxpkt, maxrxpkt for now */
	133
	134	return 0;
	135	}
	136
bc8ee596 PR	137	/**
	138	* mii_ethtool_get_link_ksettings - get settings that are specified in @cmd
	139	* @mii: MII interface
	140	* @cmd: requested ethtool_link_ksettings
	141	*
	142	* The @cmd parameter is expected to have been cleared before calling
	143	* mii_ethtool_get_link_ksettings().
	144	*
	145	* Returns 0 for success, negative on error.
	146	*/
	147	int mii_ethtool_get_link_ksettings(struct mii_if_info *mii,
	148	struct ethtool_link_ksettings *cmd)
	149	{
	150	struct net_device *dev = mii->dev;
	151	u16 bmcr, bmsr, ctrl1000 = 0, stat1000 = 0;
	152	u32 nego, supported, advertising, lp_advertising;
	153
	154	supported = (SUPPORTED_10baseT_Half \| SUPPORTED_10baseT_Full \|
	155	SUPPORTED_100baseT_Half \| SUPPORTED_100baseT_Full \|
	156	SUPPORTED_Autoneg \| SUPPORTED_TP \| SUPPORTED_MII);
	157	if (mii->supports_gmii)
	158	supported \|= SUPPORTED_1000baseT_Half \|
	159	SUPPORTED_1000baseT_Full;
	160
	161	/* only supports twisted-pair */
	162	cmd->base.port = PORT_MII;
	163
	164	/* this isn't fully supported at higher layers */
	165	cmd->base.phy_address = mii->phy_id;
	166	cmd->base.mdio_support = ETH_MDIO_SUPPORTS_C22;
	167
	168	advertising = ADVERTISED_TP \| ADVERTISED_MII;
	169
	170	bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
	171	bmsr = mii->mdio_read(dev, mii->phy_id, MII_BMSR);
	172	if (mii->supports_gmii) {
	173	ctrl1000 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
	174	stat1000 = mii->mdio_read(dev, mii->phy_id, MII_STAT1000);
	175	}
	176	if (bmcr & BMCR_ANENABLE) {
	177	advertising \|= ADVERTISED_Autoneg;
	178	cmd->base.autoneg = AUTONEG_ENABLE;
	179
	180	advertising \|= mii_get_an(mii, MII_ADVERTISE);
	181	if (mii->supports_gmii)
	182	advertising \|= mii_ctrl1000_to_ethtool_adv_t(ctrl1000);
	183
	184	if (bmsr & BMSR_ANEGCOMPLETE) {
	185	lp_advertising = mii_get_an(mii, MII_LPA);
	186	lp_advertising \|=
	187	mii_stat1000_to_ethtool_lpa_t(stat1000);
	188	} else {
	189	lp_advertising = 0;
	190	}
	191
	192	nego = advertising & lp_advertising;
	193
	194	if (nego & (ADVERTISED_1000baseT_Full \|
	195	ADVERTISED_1000baseT_Half)) {
	196	cmd->base.speed = SPEED_1000;
	197	cmd->base.duplex = !!(nego & ADVERTISED_1000baseT_Full);
	198	} else if (nego & (ADVERTISED_100baseT_Full \|
	199	ADVERTISED_100baseT_Half)) {
	200	cmd->base.speed = SPEED_100;
201	cmd->base.duplex = !!(nego & ADVERTISED_100baseT_Full);
202	} else {
203	cmd->base.speed = SPEED_10;
204	cmd->base.duplex = !!(nego & ADVERTISED_10baseT_Full);
205	}
206	} else {
207	cmd->base.autoneg = AUTONEG_DISABLE;
208
209	cmd->base.speed = ((bmcr & BMCR_SPEED1000 &&
210	(bmcr & BMCR_SPEED100) == 0) ?
211	SPEED_1000 :
212	((bmcr & BMCR_SPEED100) ?
213	SPEED_100 : SPEED_10));
214	cmd->base.duplex = (bmcr & BMCR_FULLDPLX) ?
215	DUPLEX_FULL : DUPLEX_HALF;
dc0b2c9c AB	216
dc0b2c9c AB	217	lp_advertising = 0;
bc8ee596 PR	218	}
	219
	220	mii->full_duplex = cmd->base.duplex;
	221
	222	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
	223	supported);
	224	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
	225	advertising);
	226	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.lp_advertising,
	227	lp_advertising);
	228
	229	/* ignore maxtxpkt, maxrxpkt for now */
	230
	231	return 0;
	232	}
	233
32684ec6 RD	234	/**
	235	* mii_ethtool_sset - set settings that are specified in @ecmd
	236	* @mii: MII interface
	237	* @ecmd: requested ethtool_cmd
	238	*
	239	* Returns 0 for success, negative on error.
	240	*/
1da177e4 LT	241	int mii_ethtool_sset(struct mii_if_info mii, struct ethtool_cmd ecmd)
	242	{
	243	struct net_device *dev = mii->dev;
25db0338	244	u32 speed = ethtool_cmd_speed(ecmd);
1da177e4	245
25db0338 DD	246	if (speed != SPEED_10 &&
	247	speed != SPEED_100 &&
	248	speed != SPEED_1000)
1da177e4 LT	249	return -EINVAL;
	250	if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
	251	return -EINVAL;
	252	if (ecmd->port != PORT_MII)
	253	return -EINVAL;
	254	if (ecmd->transceiver != XCVR_INTERNAL)
	255	return -EINVAL;
	256	if (ecmd->phy_address != mii->phy_id)
	257	return -EINVAL;
	258	if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
	259	return -EINVAL;
25db0338	260	if ((speed == SPEED_1000) && (!mii->supports_gmii))
1da177e4	261	return -EINVAL;
6aa20a22	262
1da177e4	263	/* ignore supported, maxtxpkt, maxrxpkt */
6aa20a22	264
1da177e4 LT	265	if (ecmd->autoneg == AUTONEG_ENABLE) {
	266	u32 bmcr, advert, tmp;
	267	u32 advert2 = 0, tmp2 = 0;
	268
	269	if ((ecmd->advertising & (ADVERTISED_10baseT_Half \|
	270	ADVERTISED_10baseT_Full \|
	271	ADVERTISED_100baseT_Half \|
	272	ADVERTISED_100baseT_Full \|
	273	ADVERTISED_1000baseT_Half \|
	274	ADVERTISED_1000baseT_Full)) == 0)
	275	return -EINVAL;
	276
	277	/* advertise only what has been requested */
	278	advert = mii->mdio_read(dev, mii->phy_id, MII_ADVERTISE);
	279	tmp = advert & ~(ADVERTISE_ALL \| ADVERTISE_100BASE4);
	280	if (mii->supports_gmii) {
	281	advert2 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
	282	tmp2 = advert2 & ~(ADVERTISE_1000HALF \| ADVERTISE_1000FULL);
	283	}
37f07023	284	tmp \|= ethtool_adv_to_mii_adv_t(ecmd->advertising);
28011cf1 MC	285
28011cf1 MC	286	if (mii->supports_gmii)
37f07023 MC	287	tmp2 \|=
37f07023 MC	288	ethtool_adv_to_mii_ctrl1000_t(ecmd->advertising);
1da177e4 LT	289	if (advert != tmp) {
	290	mii->mdio_write(dev, mii->phy_id, MII_ADVERTISE, tmp);
	291	mii->advertising = tmp;
	292	}
	293	if ((mii->supports_gmii) && (advert2 != tmp2))
	294	mii->mdio_write(dev, mii->phy_id, MII_CTRL1000, tmp2);
6aa20a22	295
1da177e4 LT	296	/* turn on autonegotiation, and force a renegotiate */
	297	bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
	298	bmcr \|= (BMCR_ANENABLE \| BMCR_ANRESTART);
	299	mii->mdio_write(dev, mii->phy_id, MII_BMCR, bmcr);
	300
	301	mii->force_media = 0;
	302	} else {
	303	u32 bmcr, tmp;
	304
	305	/* turn off auto negotiation, set speed and duplexity */
	306	bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
6aa20a22	307	tmp = bmcr & ~(BMCR_ANENABLE \| BMCR_SPEED100 \|
1da177e4	308	BMCR_SPEED1000 \| BMCR_FULLDPLX);
25db0338	309	if (speed == SPEED_1000)
1da177e4	310	tmp \|= BMCR_SPEED1000;
25db0338	311	else if (speed == SPEED_100)
1da177e4 LT	312	tmp \|= BMCR_SPEED100;
	313	if (ecmd->duplex == DUPLEX_FULL) {
	314	tmp \|= BMCR_FULLDPLX;
	315	mii->full_duplex = 1;
	316	} else
	317	mii->full_duplex = 0;
	318	if (bmcr != tmp)
	319	mii->mdio_write(dev, mii->phy_id, MII_BMCR, tmp);
	320
	321	mii->force_media = 1;
	322	}
	323	return 0;
	324	}
	325
bc8ee596 PR	326	/**
	327	* mii_ethtool_set_link_ksettings - set settings that are specified in @cmd
	328	* @mii: MII interfaces
	329	* @cmd: requested ethtool_link_ksettings
	330	*
	331	* Returns 0 for success, negative on error.
	332	*/
	333	int mii_ethtool_set_link_ksettings(struct mii_if_info *mii,
	334	const struct ethtool_link_ksettings *cmd)
	335	{
	336	struct net_device *dev = mii->dev;
	337	u32 speed = cmd->base.speed;
	338
	339	if (speed != SPEED_10 &&
	340	speed != SPEED_100 &&
	341	speed != SPEED_1000)
	342	return -EINVAL;
	343	if (cmd->base.duplex != DUPLEX_HALF && cmd->base.duplex != DUPLEX_FULL)
	344	return -EINVAL;
	345	if (cmd->base.port != PORT_MII)
	346	return -EINVAL;
	347	if (cmd->base.phy_address != mii->phy_id)
	348	return -EINVAL;
	349	if (cmd->base.autoneg != AUTONEG_DISABLE &&
	350	cmd->base.autoneg != AUTONEG_ENABLE)
	351	return -EINVAL;
	352	if ((speed == SPEED_1000) && (!mii->supports_gmii))
	353	return -EINVAL;
	354
	355	/* ignore supported, maxtxpkt, maxrxpkt */
	356
	357	if (cmd->base.autoneg == AUTONEG_ENABLE) {
	358	u32 bmcr, advert, tmp;
	359	u32 advert2 = 0, tmp2 = 0;
	360	u32 advertising;
	361
	362	ethtool_convert_link_mode_to_legacy_u32(
	363	&advertising, cmd->link_modes.advertising);
	364
	365	if ((advertising & (ADVERTISED_10baseT_Half \|
	366	ADVERTISED_10baseT_Full \|
	367	ADVERTISED_100baseT_Half \|
	368	ADVERTISED_100baseT_Full \|
	369	ADVERTISED_1000baseT_Half \|
	370	ADVERTISED_1000baseT_Full)) == 0)
	371	return -EINVAL;
	372
	373	/* advertise only what has been requested */
	374	advert = mii->mdio_read(dev, mii->phy_id, MII_ADVERTISE);
	375	tmp = advert & ~(ADVERTISE_ALL \| ADVERTISE_100BASE4);
	376	if (mii->supports_gmii) {
	377	advert2 = mii->mdio_read(dev, mii->phy_id,
	378	MII_CTRL1000);
	379	tmp2 = advert2 &
	380	~(ADVERTISE_1000HALF \| ADVERTISE_1000FULL);
	381	}
	382	tmp \|= ethtool_adv_to_mii_adv_t(advertising);
	383
	384	if (mii->supports_gmii)
	385	tmp2 \|= ethtool_adv_to_mii_ctrl1000_t(advertising);
	386	if (advert != tmp) {
	387	mii->mdio_write(dev, mii->phy_id, MII_ADVERTISE, tmp);
	388	mii->advertising = tmp;
	389	}
390	if ((mii->supports_gmii) && (advert2 != tmp2))
391	mii->mdio_write(dev, mii->phy_id, MII_CTRL1000, tmp2);
392
393	/* turn on autonegotiation, and force a renegotiate */
394	bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
395	bmcr \|= (BMCR_ANENABLE \| BMCR_ANRESTART);
396	mii->mdio_write(dev, mii->phy_id, MII_BMCR, bmcr);
397
398	mii->force_media = 0;
399	} else {
400	u32 bmcr, tmp;
401
402	/* turn off auto negotiation, set speed and duplexity */
403	bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
404	tmp = bmcr & ~(BMCR_ANENABLE \| BMCR_SPEED100 \|
405	BMCR_SPEED1000 \| BMCR_FULLDPLX);
406	if (speed == SPEED_1000)
407	tmp \|= BMCR_SPEED1000;
408	else if (speed == SPEED_100)
409	tmp \|= BMCR_SPEED100;
410	if (cmd->base.duplex == DUPLEX_FULL) {
411	tmp \|= BMCR_FULLDPLX;
412	mii->full_duplex = 1;
413	} else {
414	mii->full_duplex = 0;
415	}
416	if (bmcr != tmp)
417	mii->mdio_write(dev, mii->phy_id, MII_BMCR, tmp);
418
419	mii->force_media = 1;
420	}
421	return 0;
422	}
423
32684ec6 RD	424	/**
	425	* mii_check_gmii_support - check if the MII supports Gb interfaces
	426	* @mii: the MII interface
	427	*/
43ec6e95 DF	428	int mii_check_gmii_support(struct mii_if_info *mii)
	429	{
	430	int reg;
	431
	432	reg = mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
	433	if (reg & BMSR_ESTATEN) {
	434	reg = mii->mdio_read(mii->dev, mii->phy_id, MII_ESTATUS);
	435	if (reg & (ESTATUS_1000_TFULL \| ESTATUS_1000_THALF))
	436	return 1;
	437	}
	438
	439	return 0;
	440	}
	441
32684ec6 RD	442	/**
	443	* mii_link_ok - is link status up/ok
	444	* @mii: the MII interface
	445	*
	446	* Returns 1 if the MII reports link status up/ok, 0 otherwise.
	447	*/
1da177e4 LT	448	int mii_link_ok (struct mii_if_info *mii)
	449	{
	450	/* first, a dummy read, needed to latch some MII phys */
	451	mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
	452	if (mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR) & BMSR_LSTATUS)
	453	return 1;
	454	return 0;
	455	}
	456
32684ec6 RD	457	/**
	458	* mii_nway_restart - restart NWay (autonegotiation) for this interface
	459	* @mii: the MII interface
	460	*
	461	* Returns 0 on success, negative on error.
	462	*/
1da177e4 LT	463	int mii_nway_restart (struct mii_if_info *mii)
	464	{
	465	int bmcr;
	466	int r = -EINVAL;
	467
	468	/* if autoneg is off, it's an error */
	469	bmcr = mii->mdio_read(mii->dev, mii->phy_id, MII_BMCR);
	470
	471	if (bmcr & BMCR_ANENABLE) {
	472	bmcr \|= BMCR_ANRESTART;
	473	mii->mdio_write(mii->dev, mii->phy_id, MII_BMCR, bmcr);
	474	r = 0;
	475	}
	476
	477	return r;
	478	}
	479
32684ec6 RD	480	/**
	481	* mii_check_link - check MII link status
	482	* @mii: MII interface
	483	*
	484	* If the link status changed (previous != current), call
	485	* netif_carrier_on() if current link status is Up or call
	486	* netif_carrier_off() if current link status is Down.
	487	*/
1da177e4 LT	488	void mii_check_link (struct mii_if_info *mii)
	489	{
	490	int cur_link = mii_link_ok(mii);
	491	int prev_link = netif_carrier_ok(mii->dev);
	492
	493	if (cur_link && !prev_link)
	494	netif_carrier_on(mii->dev);
	495	else if (prev_link && !cur_link)
	496	netif_carrier_off(mii->dev);
	497	}
	498
32684ec6	499	/**
5bdc7380	500	* mii_check_media - check the MII interface for a carrier/speed/duplex change
32684ec6 RD	501	* @mii: the MII interface
	502	* @ok_to_print: OK to print link up/down messages
	503	* @init_media: OK to save duplex mode in @mii
	504	*
	505	* Returns 1 if the duplex mode changed, 0 if not.
	506	* If the media type is forced, always returns 0.
	507	*/
1da177e4 LT	508	unsigned int mii_check_media (struct mii_if_info *mii,
	509	unsigned int ok_to_print,
	510	unsigned int init_media)
	511	{
	512	unsigned int old_carrier, new_carrier;
	513	int advertise, lpa, media, duplex;
	514	int lpa2 = 0;
	515
1da177e4 LT	516	/* check current and old link status */
	517	old_carrier = netif_carrier_ok(mii->dev) ? 1 : 0;
	518	new_carrier = (unsigned int) mii_link_ok(mii);
	519
	520	/* if carrier state did not change, this is a "bounce",
	521	* just exit as everything is already set correctly
	522	*/
	523	if ((!init_media) && (old_carrier == new_carrier))
	524	return 0; /* duplex did not change */
	525
	526	/* no carrier, nothing much to do */
	527	if (!new_carrier) {
	528	netif_carrier_off(mii->dev);
	529	if (ok_to_print)
967faf3b	530	netdev_info(mii->dev, "link down\n");
1da177e4 LT	531	return 0; /* duplex did not change */
	532	}
	533
	534	/*
	535	* we have carrier, see who's on the other end
	536	*/
	537	netif_carrier_on(mii->dev);
	538
5bdc7380 BH	539	if (mii->force_media) {
	540	if (ok_to_print)
	541	netdev_info(mii->dev, "link up\n");
	542	return 0; /* duplex did not change */
	543	}
	544
1da177e4 LT	545	/* get MII advertise and LPA values */
	546	if ((!init_media) && (mii->advertising))
	547	advertise = mii->advertising;
	548	else {
	549	advertise = mii->mdio_read(mii->dev, mii->phy_id, MII_ADVERTISE);
	550	mii->advertising = advertise;
	551	}
	552	lpa = mii->mdio_read(mii->dev, mii->phy_id, MII_LPA);
	553	if (mii->supports_gmii)
	554	lpa2 = mii->mdio_read(mii->dev, mii->phy_id, MII_STAT1000);
	555
	556	/* figure out media and duplex from advertise and LPA values */
	557	media = mii_nway_result(lpa & advertise);
	558	duplex = (media & ADVERTISE_FULL) ? 1 : 0;
	559	if (lpa2 & LPA_1000FULL)
	560	duplex = 1;
	561
	562	if (ok_to_print)
967faf3b JP	563	netdev_info(mii->dev, "link up, %uMbps, %s-duplex, lpa 0x%04X\n",
	564	lpa2 & (LPA_1000FULL \| LPA_1000HALF) ? 1000 :
	565	media & (ADVERTISE_100FULL \| ADVERTISE_100HALF) ?
	566	100 : 10,
	567	duplex ? "full" : "half",
	568	lpa);
1da177e4 LT	569
	570	if ((init_media) \|\| (mii->full_duplex != duplex)) {
	571	mii->full_duplex = duplex;
	572	return 1; /* duplex changed */
	573	}
	574
	575	return 0; /* duplex did not change */
	576	}
	577
32684ec6 RD	578	/**
	579	* generic_mii_ioctl - main MII ioctl interface
	580	* @mii_if: the MII interface
	581	* @mii_data: MII ioctl data structure
	582	* @cmd: MII ioctl command
	583	* @duplex_chg_out: pointer to @duplex_changed status if there was no
	584	* ioctl error
	585	*
	586	* Returns 0 on success, negative on error.
	587	*/
1da177e4 LT	588	int generic_mii_ioctl(struct mii_if_info *mii_if,
	589	struct mii_ioctl_data *mii_data, int cmd,
	590	unsigned int *duplex_chg_out)
	591	{
	592	int rc = 0;
	593	unsigned int duplex_changed = 0;
	594
	595	if (duplex_chg_out)
	596	*duplex_chg_out = 0;
	597
	598	mii_data->phy_id &= mii_if->phy_id_mask;
	599	mii_data->reg_num &= mii_if->reg_num_mask;
	600
	601	switch(cmd) {
	602	case SIOCGMIIPHY:
	603	mii_data->phy_id = mii_if->phy_id;
	604	/* fall through */
	605
	606	case SIOCGMIIREG:
	607	mii_data->val_out =
	608	mii_if->mdio_read(mii_if->dev, mii_data->phy_id,
	609	mii_data->reg_num);
	610	break;
	611
	612	case SIOCSMIIREG: {
	613	u16 val = mii_data->val_in;
	614
1da177e4 LT	615	if (mii_data->phy_id == mii_if->phy_id) {
	616	switch(mii_data->reg_num) {
	617	case MII_BMCR: {
	618	unsigned int new_duplex = 0;
	619	if (val & (BMCR_RESET\|BMCR_ANENABLE))
	620	mii_if->force_media = 0;
	621	else
	622	mii_if->force_media = 1;
	623	if (mii_if->force_media &&
	624	(val & BMCR_FULLDPLX))
	625	new_duplex = 1;
	626	if (mii_if->full_duplex != new_duplex) {
	627	duplex_changed = 1;
	628	mii_if->full_duplex = new_duplex;
	629	}
	630	break;
	631	}
	632	case MII_ADVERTISE:
	633	mii_if->advertising = val;
	634	break;
	635	default:
	636	/* do nothing */
	637	break;
	638	}
	639	}
	640
	641	mii_if->mdio_write(mii_if->dev, mii_data->phy_id,
	642	mii_data->reg_num, val);
	643	break;
	644	}
	645
	646	default:
	647	rc = -EOPNOTSUPP;
	648	break;
	649	}
	650
	651	if ((rc == 0) && (duplex_chg_out) && (duplex_changed))
	652	*duplex_chg_out = 1;
	653
	654	return rc;
	655	}
	656
	657	MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>");
	658	MODULE_DESCRIPTION ("MII hardware support library");
	659	MODULE_LICENSE("GPL");
	660
	661	EXPORT_SYMBOL(mii_link_ok);
	662	EXPORT_SYMBOL(mii_nway_restart);
	663	EXPORT_SYMBOL(mii_ethtool_gset);
bc8ee596	664	EXPORT_SYMBOL(mii_ethtool_get_link_ksettings);
1da177e4	665	EXPORT_SYMBOL(mii_ethtool_sset);
bc8ee596	666	EXPORT_SYMBOL(mii_ethtool_set_link_ksettings);
1da177e4 LT	667	EXPORT_SYMBOL(mii_check_link);
1da177e4 LT	668	EXPORT_SYMBOL(mii_check_media);
43ec6e95	669	EXPORT_SYMBOL(mii_check_gmii_support);
1da177e4 LT	670	EXPORT_SYMBOL(generic_mii_ioctl);
1da177e4 LT	671