[mirror_ubuntu-artful-kernel.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().
 */
void 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 */
}

/**
 * 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().
bc8ee596	144	*/
82c01a84	145	void mii_ethtool_get_link_ksettings(struct mii_if_info *mii,
82c01a84	146	struct ethtool_link_ksettings *cmd)
bc8ee596 PR	147	{
	148	struct net_device *dev = mii->dev;
	149	u16 bmcr, bmsr, ctrl1000 = 0, stat1000 = 0;
	150	u32 nego, supported, advertising, lp_advertising;
	151
	152	supported = (SUPPORTED_10baseT_Half \| SUPPORTED_10baseT_Full \|
	153	SUPPORTED_100baseT_Half \| SUPPORTED_100baseT_Full \|
	154	SUPPORTED_Autoneg \| SUPPORTED_TP \| SUPPORTED_MII);
	155	if (mii->supports_gmii)
	156	supported \|= SUPPORTED_1000baseT_Half \|
	157	SUPPORTED_1000baseT_Full;
	158
	159	/* only supports twisted-pair */
	160	cmd->base.port = PORT_MII;
	161
	162	/* this isn't fully supported at higher layers */
	163	cmd->base.phy_address = mii->phy_id;
	164	cmd->base.mdio_support = ETH_MDIO_SUPPORTS_C22;
	165
	166	advertising = ADVERTISED_TP \| ADVERTISED_MII;
	167
	168	bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
	169	bmsr = mii->mdio_read(dev, mii->phy_id, MII_BMSR);
	170	if (mii->supports_gmii) {
	171	ctrl1000 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
	172	stat1000 = mii->mdio_read(dev, mii->phy_id, MII_STAT1000);
	173	}
	174	if (bmcr & BMCR_ANENABLE) {
	175	advertising \|= ADVERTISED_Autoneg;
	176	cmd->base.autoneg = AUTONEG_ENABLE;
	177
	178	advertising \|= mii_get_an(mii, MII_ADVERTISE);
	179	if (mii->supports_gmii)
	180	advertising \|= mii_ctrl1000_to_ethtool_adv_t(ctrl1000);
	181
	182	if (bmsr & BMSR_ANEGCOMPLETE) {
	183	lp_advertising = mii_get_an(mii, MII_LPA);
	184	lp_advertising \|=
	185	mii_stat1000_to_ethtool_lpa_t(stat1000);
	186	} else {
	187	lp_advertising = 0;
	188	}
	189
	190	nego = advertising & lp_advertising;
	191
	192	if (nego & (ADVERTISED_1000baseT_Full \|
	193	ADVERTISED_1000baseT_Half)) {
	194	cmd->base.speed = SPEED_1000;
	195	cmd->base.duplex = !!(nego & ADVERTISED_1000baseT_Full);
	196	} else if (nego & (ADVERTISED_100baseT_Full \|
	197	ADVERTISED_100baseT_Half)) {
	198	cmd->base.speed = SPEED_100;
	199	cmd->base.duplex = !!(nego & ADVERTISED_100baseT_Full);
	200	} else {
	201	cmd->base.speed = SPEED_10;
	202	cmd->base.duplex = !!(nego & ADVERTISED_10baseT_Full);
	203	}
	204	} else {
	205	cmd->base.autoneg = AUTONEG_DISABLE;
	206
	207	cmd->base.speed = ((bmcr & BMCR_SPEED1000 &&
	208	(bmcr & BMCR_SPEED100) == 0) ?
	209	SPEED_1000 :
	210	((bmcr & BMCR_SPEED100) ?
211	SPEED_100 : SPEED_10));
212	cmd->base.duplex = (bmcr & BMCR_FULLDPLX) ?
213	DUPLEX_FULL : DUPLEX_HALF;
dc0b2c9c AB	214
dc0b2c9c AB	215	lp_advertising = 0;
bc8ee596 PR	216	}
	217
	218	mii->full_duplex = cmd->base.duplex;
	219
	220	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
	221	supported);
	222	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
	223	advertising);
	224	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.lp_advertising,
	225	lp_advertising);
	226
	227	/* ignore maxtxpkt, maxrxpkt for now */
bc8ee596 PR	228	}
bc8ee596 PR	229
32684ec6 RD	230	/**
	231	* mii_ethtool_sset - set settings that are specified in @ecmd
	232	* @mii: MII interface
	233	* @ecmd: requested ethtool_cmd
	234	*
	235	* Returns 0 for success, negative on error.
	236	*/
1da177e4 LT	237	int mii_ethtool_sset(struct mii_if_info mii, struct ethtool_cmd ecmd)
	238	{
	239	struct net_device *dev = mii->dev;
25db0338	240	u32 speed = ethtool_cmd_speed(ecmd);
1da177e4	241
25db0338 DD	242	if (speed != SPEED_10 &&
	243	speed != SPEED_100 &&
	244	speed != SPEED_1000)
1da177e4 LT	245	return -EINVAL;
	246	if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
	247	return -EINVAL;
	248	if (ecmd->port != PORT_MII)
	249	return -EINVAL;
	250	if (ecmd->transceiver != XCVR_INTERNAL)
	251	return -EINVAL;
	252	if (ecmd->phy_address != mii->phy_id)
	253	return -EINVAL;
	254	if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
	255	return -EINVAL;
25db0338	256	if ((speed == SPEED_1000) && (!mii->supports_gmii))
1da177e4	257	return -EINVAL;
6aa20a22	258
1da177e4	259	/* ignore supported, maxtxpkt, maxrxpkt */
6aa20a22	260
1da177e4 LT	261	if (ecmd->autoneg == AUTONEG_ENABLE) {
	262	u32 bmcr, advert, tmp;
	263	u32 advert2 = 0, tmp2 = 0;
	264
	265	if ((ecmd->advertising & (ADVERTISED_10baseT_Half \|
	266	ADVERTISED_10baseT_Full \|
	267	ADVERTISED_100baseT_Half \|
	268	ADVERTISED_100baseT_Full \|
	269	ADVERTISED_1000baseT_Half \|
	270	ADVERTISED_1000baseT_Full)) == 0)
	271	return -EINVAL;
	272
	273	/* advertise only what has been requested */
	274	advert = mii->mdio_read(dev, mii->phy_id, MII_ADVERTISE);
	275	tmp = advert & ~(ADVERTISE_ALL \| ADVERTISE_100BASE4);
	276	if (mii->supports_gmii) {
	277	advert2 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
	278	tmp2 = advert2 & ~(ADVERTISE_1000HALF \| ADVERTISE_1000FULL);
	279	}
37f07023	280	tmp \|= ethtool_adv_to_mii_adv_t(ecmd->advertising);
28011cf1 MC	281
28011cf1 MC	282	if (mii->supports_gmii)
37f07023 MC	283	tmp2 \|=
37f07023 MC	284	ethtool_adv_to_mii_ctrl1000_t(ecmd->advertising);
1da177e4 LT	285	if (advert != tmp) {
	286	mii->mdio_write(dev, mii->phy_id, MII_ADVERTISE, tmp);
	287	mii->advertising = tmp;
	288	}
	289	if ((mii->supports_gmii) && (advert2 != tmp2))
	290	mii->mdio_write(dev, mii->phy_id, MII_CTRL1000, tmp2);
6aa20a22	291
1da177e4 LT	292	/* turn on autonegotiation, and force a renegotiate */
	293	bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
	294	bmcr \|= (BMCR_ANENABLE \| BMCR_ANRESTART);
	295	mii->mdio_write(dev, mii->phy_id, MII_BMCR, bmcr);
	296
	297	mii->force_media = 0;
	298	} else {
	299	u32 bmcr, tmp;
	300
	301	/* turn off auto negotiation, set speed and duplexity */
	302	bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
6aa20a22	303	tmp = bmcr & ~(BMCR_ANENABLE \| BMCR_SPEED100 \|
1da177e4	304	BMCR_SPEED1000 \| BMCR_FULLDPLX);
25db0338	305	if (speed == SPEED_1000)
1da177e4	306	tmp \|= BMCR_SPEED1000;
25db0338	307	else if (speed == SPEED_100)
1da177e4 LT	308	tmp \|= BMCR_SPEED100;
	309	if (ecmd->duplex == DUPLEX_FULL) {
	310	tmp \|= BMCR_FULLDPLX;
	311	mii->full_duplex = 1;
	312	} else
	313	mii->full_duplex = 0;
	314	if (bmcr != tmp)
	315	mii->mdio_write(dev, mii->phy_id, MII_BMCR, tmp);
	316
	317	mii->force_media = 1;
	318	}
	319	return 0;
	320	}
	321
bc8ee596 PR	322	/**
	323	* mii_ethtool_set_link_ksettings - set settings that are specified in @cmd
	324	* @mii: MII interfaces
	325	* @cmd: requested ethtool_link_ksettings
	326	*
	327	* Returns 0 for success, negative on error.
	328	*/
	329	int mii_ethtool_set_link_ksettings(struct mii_if_info *mii,
	330	const struct ethtool_link_ksettings *cmd)
	331	{
	332	struct net_device *dev = mii->dev;
	333	u32 speed = cmd->base.speed;
	334
	335	if (speed != SPEED_10 &&
	336	speed != SPEED_100 &&
	337	speed != SPEED_1000)
	338	return -EINVAL;
	339	if (cmd->base.duplex != DUPLEX_HALF && cmd->base.duplex != DUPLEX_FULL)
	340	return -EINVAL;
	341	if (cmd->base.port != PORT_MII)
	342	return -EINVAL;
	343	if (cmd->base.phy_address != mii->phy_id)
	344	return -EINVAL;
	345	if (cmd->base.autoneg != AUTONEG_DISABLE &&
	346	cmd->base.autoneg != AUTONEG_ENABLE)
	347	return -EINVAL;
	348	if ((speed == SPEED_1000) && (!mii->supports_gmii))
	349	return -EINVAL;
	350
	351	/* ignore supported, maxtxpkt, maxrxpkt */
	352
	353	if (cmd->base.autoneg == AUTONEG_ENABLE) {
	354	u32 bmcr, advert, tmp;
	355	u32 advert2 = 0, tmp2 = 0;
	356	u32 advertising;
	357
	358	ethtool_convert_link_mode_to_legacy_u32(
	359	&advertising, cmd->link_modes.advertising);
	360
	361	if ((advertising & (ADVERTISED_10baseT_Half \|
	362	ADVERTISED_10baseT_Full \|
	363	ADVERTISED_100baseT_Half \|
	364	ADVERTISED_100baseT_Full \|
	365	ADVERTISED_1000baseT_Half \|
	366	ADVERTISED_1000baseT_Full)) == 0)
	367	return -EINVAL;
	368
	369	/* advertise only what has been requested */
	370	advert = mii->mdio_read(dev, mii->phy_id, MII_ADVERTISE);
	371	tmp = advert & ~(ADVERTISE_ALL \| ADVERTISE_100BASE4);
	372	if (mii->supports_gmii) {
	373	advert2 = mii->mdio_read(dev, mii->phy_id,
	374	MII_CTRL1000);
	375	tmp2 = advert2 &
	376	~(ADVERTISE_1000HALF \| ADVERTISE_1000FULL);
	377	}
	378	tmp \|= ethtool_adv_to_mii_adv_t(advertising);
	379
	380	if (mii->supports_gmii)
	381	tmp2 \|= ethtool_adv_to_mii_ctrl1000_t(advertising);
	382	if (advert != tmp) {
	383	mii->mdio_write(dev, mii->phy_id, MII_ADVERTISE, tmp);
	384	mii->advertising = tmp;
	385	}
386	if ((mii->supports_gmii) && (advert2 != tmp2))
387	mii->mdio_write(dev, mii->phy_id, MII_CTRL1000, tmp2);
388
389	/* turn on autonegotiation, and force a renegotiate */
390	bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
391	bmcr \|= (BMCR_ANENABLE \| BMCR_ANRESTART);
392	mii->mdio_write(dev, mii->phy_id, MII_BMCR, bmcr);
393
394	mii->force_media = 0;
395	} else {
396	u32 bmcr, tmp;
397
398	/* turn off auto negotiation, set speed and duplexity */
399	bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
400	tmp = bmcr & ~(BMCR_ANENABLE \| BMCR_SPEED100 \|
401	BMCR_SPEED1000 \| BMCR_FULLDPLX);
402	if (speed == SPEED_1000)
403	tmp \|= BMCR_SPEED1000;
404	else if (speed == SPEED_100)
405	tmp \|= BMCR_SPEED100;
406	if (cmd->base.duplex == DUPLEX_FULL) {
407	tmp \|= BMCR_FULLDPLX;
408	mii->full_duplex = 1;
409	} else {
410	mii->full_duplex = 0;
411	}
412	if (bmcr != tmp)
413	mii->mdio_write(dev, mii->phy_id, MII_BMCR, tmp);
414
415	mii->force_media = 1;
416	}
417	return 0;
418	}
419
32684ec6 RD	420	/**
	421	* mii_check_gmii_support - check if the MII supports Gb interfaces
	422	* @mii: the MII interface
	423	*/
43ec6e95 DF	424	int mii_check_gmii_support(struct mii_if_info *mii)
	425	{
	426	int reg;
	427
	428	reg = mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
	429	if (reg & BMSR_ESTATEN) {
	430	reg = mii->mdio_read(mii->dev, mii->phy_id, MII_ESTATUS);
	431	if (reg & (ESTATUS_1000_TFULL \| ESTATUS_1000_THALF))
	432	return 1;
	433	}
	434
	435	return 0;
	436	}
	437
32684ec6 RD	438	/**
	439	* mii_link_ok - is link status up/ok
	440	* @mii: the MII interface
	441	*
	442	* Returns 1 if the MII reports link status up/ok, 0 otherwise.
	443	*/
1da177e4 LT	444	int mii_link_ok (struct mii_if_info *mii)
	445	{
	446	/* first, a dummy read, needed to latch some MII phys */
	447	mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
	448	if (mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR) & BMSR_LSTATUS)
	449	return 1;
	450	return 0;
	451	}
	452
32684ec6 RD	453	/**
	454	* mii_nway_restart - restart NWay (autonegotiation) for this interface
	455	* @mii: the MII interface
	456	*
	457	* Returns 0 on success, negative on error.
	458	*/
1da177e4 LT	459	int mii_nway_restart (struct mii_if_info *mii)
	460	{
	461	int bmcr;
	462	int r = -EINVAL;
	463
	464	/* if autoneg is off, it's an error */
	465	bmcr = mii->mdio_read(mii->dev, mii->phy_id, MII_BMCR);
	466
	467	if (bmcr & BMCR_ANENABLE) {
	468	bmcr \|= BMCR_ANRESTART;
	469	mii->mdio_write(mii->dev, mii->phy_id, MII_BMCR, bmcr);
	470	r = 0;
	471	}
	472
	473	return r;
	474	}
	475
32684ec6 RD	476	/**
	477	* mii_check_link - check MII link status
	478	* @mii: MII interface
	479	*
	480	* If the link status changed (previous != current), call
	481	* netif_carrier_on() if current link status is Up or call
	482	* netif_carrier_off() if current link status is Down.
	483	*/
1da177e4 LT	484	void mii_check_link (struct mii_if_info *mii)
	485	{
	486	int cur_link = mii_link_ok(mii);
	487	int prev_link = netif_carrier_ok(mii->dev);
	488
	489	if (cur_link && !prev_link)
	490	netif_carrier_on(mii->dev);
	491	else if (prev_link && !cur_link)
	492	netif_carrier_off(mii->dev);
	493	}
	494
32684ec6	495	/**
5bdc7380	496	* mii_check_media - check the MII interface for a carrier/speed/duplex change
32684ec6 RD	497	* @mii: the MII interface
	498	* @ok_to_print: OK to print link up/down messages
	499	* @init_media: OK to save duplex mode in @mii
	500	*
	501	* Returns 1 if the duplex mode changed, 0 if not.
	502	* If the media type is forced, always returns 0.
	503	*/
1da177e4 LT	504	unsigned int mii_check_media (struct mii_if_info *mii,
	505	unsigned int ok_to_print,
	506	unsigned int init_media)
	507	{
	508	unsigned int old_carrier, new_carrier;
	509	int advertise, lpa, media, duplex;
	510	int lpa2 = 0;
	511
1da177e4 LT	512	/* check current and old link status */
	513	old_carrier = netif_carrier_ok(mii->dev) ? 1 : 0;
	514	new_carrier = (unsigned int) mii_link_ok(mii);
	515
	516	/* if carrier state did not change, this is a "bounce",
	517	* just exit as everything is already set correctly
	518	*/
	519	if ((!init_media) && (old_carrier == new_carrier))
	520	return 0; /* duplex did not change */
	521
	522	/* no carrier, nothing much to do */
	523	if (!new_carrier) {
	524	netif_carrier_off(mii->dev);
	525	if (ok_to_print)
967faf3b	526	netdev_info(mii->dev, "link down\n");
1da177e4 LT	527	return 0; /* duplex did not change */
	528	}
	529
	530	/*
	531	* we have carrier, see who's on the other end
	532	*/
	533	netif_carrier_on(mii->dev);
	534
5bdc7380 BH	535	if (mii->force_media) {
	536	if (ok_to_print)
	537	netdev_info(mii->dev, "link up\n");
	538	return 0; /* duplex did not change */
	539	}
	540
1da177e4 LT	541	/* get MII advertise and LPA values */
	542	if ((!init_media) && (mii->advertising))
	543	advertise = mii->advertising;
	544	else {
	545	advertise = mii->mdio_read(mii->dev, mii->phy_id, MII_ADVERTISE);
	546	mii->advertising = advertise;
	547	}
	548	lpa = mii->mdio_read(mii->dev, mii->phy_id, MII_LPA);
	549	if (mii->supports_gmii)
	550	lpa2 = mii->mdio_read(mii->dev, mii->phy_id, MII_STAT1000);
	551
	552	/* figure out media and duplex from advertise and LPA values */
	553	media = mii_nway_result(lpa & advertise);
	554	duplex = (media & ADVERTISE_FULL) ? 1 : 0;
	555	if (lpa2 & LPA_1000FULL)
	556	duplex = 1;
	557
	558	if (ok_to_print)
967faf3b JP	559	netdev_info(mii->dev, "link up, %uMbps, %s-duplex, lpa 0x%04X\n",
	560	lpa2 & (LPA_1000FULL \| LPA_1000HALF) ? 1000 :
	561	media & (ADVERTISE_100FULL \| ADVERTISE_100HALF) ?
	562	100 : 10,
	563	duplex ? "full" : "half",
	564	lpa);
1da177e4 LT	565
	566	if ((init_media) \|\| (mii->full_duplex != duplex)) {
	567	mii->full_duplex = duplex;
	568	return 1; /* duplex changed */
	569	}
	570
	571	return 0; /* duplex did not change */
	572	}
	573
32684ec6 RD	574	/**
	575	* generic_mii_ioctl - main MII ioctl interface
	576	* @mii_if: the MII interface
	577	* @mii_data: MII ioctl data structure
	578	* @cmd: MII ioctl command
	579	* @duplex_chg_out: pointer to @duplex_changed status if there was no
	580	* ioctl error
	581	*
	582	* Returns 0 on success, negative on error.
	583	*/
1da177e4 LT	584	int generic_mii_ioctl(struct mii_if_info *mii_if,
	585	struct mii_ioctl_data *mii_data, int cmd,
	586	unsigned int *duplex_chg_out)
	587	{
	588	int rc = 0;
	589	unsigned int duplex_changed = 0;
	590
	591	if (duplex_chg_out)
	592	*duplex_chg_out = 0;
	593
	594	mii_data->phy_id &= mii_if->phy_id_mask;
	595	mii_data->reg_num &= mii_if->reg_num_mask;
	596
	597	switch(cmd) {
	598	case SIOCGMIIPHY:
	599	mii_data->phy_id = mii_if->phy_id;
	600	/* fall through */
	601
	602	case SIOCGMIIREG:
	603	mii_data->val_out =
	604	mii_if->mdio_read(mii_if->dev, mii_data->phy_id,
	605	mii_data->reg_num);
	606	break;
	607
	608	case SIOCSMIIREG: {
	609	u16 val = mii_data->val_in;
	610
1da177e4 LT	611	if (mii_data->phy_id == mii_if->phy_id) {
	612	switch(mii_data->reg_num) {
	613	case MII_BMCR: {
	614	unsigned int new_duplex = 0;
	615	if (val & (BMCR_RESET\|BMCR_ANENABLE))
	616	mii_if->force_media = 0;
	617	else
	618	mii_if->force_media = 1;
	619	if (mii_if->force_media &&
	620	(val & BMCR_FULLDPLX))
	621	new_duplex = 1;
	622	if (mii_if->full_duplex != new_duplex) {
	623	duplex_changed = 1;
	624	mii_if->full_duplex = new_duplex;
	625	}
	626	break;
	627	}
	628	case MII_ADVERTISE:
	629	mii_if->advertising = val;
	630	break;
	631	default:
	632	/* do nothing */
	633	break;
	634	}
	635	}
	636
	637	mii_if->mdio_write(mii_if->dev, mii_data->phy_id,
	638	mii_data->reg_num, val);
	639	break;
	640	}
	641
	642	default:
	643	rc = -EOPNOTSUPP;
	644	break;
	645	}
	646
	647	if ((rc == 0) && (duplex_chg_out) && (duplex_changed))
	648	*duplex_chg_out = 1;
	649
	650	return rc;
	651	}
	652
	653	MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>");
	654	MODULE_DESCRIPTION ("MII hardware support library");
	655	MODULE_LICENSE("GPL");
	656
	657	EXPORT_SYMBOL(mii_link_ok);
	658	EXPORT_SYMBOL(mii_nway_restart);
	659	EXPORT_SYMBOL(mii_ethtool_gset);
bc8ee596	660	EXPORT_SYMBOL(mii_ethtool_get_link_ksettings);
1da177e4	661	EXPORT_SYMBOL(mii_ethtool_sset);
bc8ee596	662	EXPORT_SYMBOL(mii_ethtool_set_link_ksettings);
1da177e4 LT	663	EXPORT_SYMBOL(mii_check_link);
1da177e4 LT	664	EXPORT_SYMBOL(mii_check_media);
43ec6e95	665	EXPORT_SYMBOL(mii_check_gmii_support);
1da177e4 LT	666	EXPORT_SYMBOL(generic_mii_ioctl);
1da177e4 LT	667