[deliverable/linux.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/mdio.h>

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

	advert = mii->mdio_read(mii->dev, mii->phy_id, addr);
	if (advert & LPA_LPACK)
		result |= ADVERTISED_Autoneg;
	if (advert & ADVERTISE_10HALF)
		result |= ADVERTISED_10baseT_Half;
	if (advert & ADVERTISE_10FULL)
		result |= ADVERTISED_10baseT_Full;
	if (advert & ADVERTISE_100HALF)
		result |= ADVERTISED_100baseT_Half;
	if (advert & ADVERTISE_100FULL)
		result |= ADVERTISED_100baseT_Full;
	if (advert & ADVERTISE_PAUSE_CAP)
		result |= ADVERTISED_Pause;
	if (advert & ADVERTISE_PAUSE_ASYM)
		result |= ADVERTISED_Asym_Pause;

	return result;
}

/**
 * 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 = 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 (ctrl1000 & ADVERTISE_1000HALF)
			ecmd->advertising |= ADVERTISED_1000baseT_Half;
		if (ctrl1000 & ADVERTISE_1000FULL)
			ecmd->advertising |= ADVERTISED_1000baseT_Full;

		if (bmsr & BMSR_ANEGCOMPLETE) {
			ecmd->lp_advertising = mii_get_an(mii, MII_LPA);
			if (stat1000 & LPA_1000HALF)
				ecmd->lp_advertising |=
					ADVERTISED_1000baseT_Half;
			if (stat1000 & LPA_1000FULL)
				ecmd->lp_advertising |=
					ADVERTISED_1000baseT_Full;
		} 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_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);
		}
		if (ecmd->advertising & ADVERTISED_10baseT_Half)
			tmp |= ADVERTISE_10HALF;
		if (ecmd->advertising & ADVERTISED_10baseT_Full)
			tmp |= ADVERTISE_10FULL;
		if (ecmd->advertising & ADVERTISED_100baseT_Half)
			tmp |= ADVERTISE_100HALF;
		if (ecmd->advertising & ADVERTISED_100baseT_Full)
			tmp |= ADVERTISE_100FULL;
		if (mii->supports_gmii) {
			if (ecmd->advertising & ADVERTISED_1000baseT_Half)
				tmp2 |= ADVERTISE_1000HALF;
			if (ecmd->advertising & ADVERTISED_1000baseT_Full)
				tmp2 |= ADVERTISE_1000FULL;
		}
		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_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 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;

	/* if forced media, go no further */
	if (mii->force_media)
		return 0; /* duplex did not change */

	/* 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);

	/* 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_sset);
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>
5974700c BH	34	#include <linux/mdio.h>
	35
	36	static u32 mii_get_an(struct mii_if_info *mii, u16 addr)
	37	{
	38	u32 result = 0;
	39	int advert;
	40
	41	advert = mii->mdio_read(mii->dev, mii->phy_id, addr);
	42	if (advert & LPA_LPACK)
	43	result \|= ADVERTISED_Autoneg;
	44	if (advert & ADVERTISE_10HALF)
	45	result \|= ADVERTISED_10baseT_Half;
	46	if (advert & ADVERTISE_10FULL)
	47	result \|= ADVERTISED_10baseT_Full;
	48	if (advert & ADVERTISE_100HALF)
	49	result \|= ADVERTISED_100baseT_Half;
	50	if (advert & ADVERTISE_100FULL)
	51	result \|= ADVERTISED_100baseT_Full;
2b5a4ace	52	if (advert & ADVERTISE_PAUSE_CAP)
	53	result \|= ADVERTISED_Pause;
	54	if (advert & ADVERTISE_PAUSE_ASYM)
	55	result \|= ADVERTISED_Asym_Pause;
5974700c BH	56
	57	return result;
	58	}
1da177e4	59
32684ec6 RD	60	/**
	61	* mii_ethtool_gset - get settings that are specified in @ecmd
	62	* @mii: MII interface
	63	* @ecmd: requested ethtool_cmd
	64	*
8ae6daca DD	65	* The @ecmd parameter is expected to have been cleared before calling
	66	* mii_ethtool_gset().
	67	*
32684ec6 RD	68	* Returns 0 for success, negative on error.
32684ec6 RD	69	*/
1da177e4 LT	70	int mii_ethtool_gset(struct mii_if_info mii, struct ethtool_cmd ecmd)
	71	{
	72	struct net_device *dev = mii->dev;
5974700c BH	73	u16 bmcr, bmsr, ctrl1000 = 0, stat1000 = 0;
5974700c BH	74	u32 nego;
1da177e4 LT	75
	76	ecmd->supported =
	77	(SUPPORTED_10baseT_Half \| SUPPORTED_10baseT_Full \|
	78	SUPPORTED_100baseT_Half \| SUPPORTED_100baseT_Full \|
	79	SUPPORTED_Autoneg \| SUPPORTED_TP \| SUPPORTED_MII);
	80	if (mii->supports_gmii)
	81	ecmd->supported \|= SUPPORTED_1000baseT_Half \|
	82	SUPPORTED_1000baseT_Full;
	83
	84	/* only supports twisted-pair */
	85	ecmd->port = PORT_MII;
	86
	87	/* only supports internal transceiver */
	88	ecmd->transceiver = XCVR_INTERNAL;
	89
	90	/* this isn't fully supported at higher layers */
	91	ecmd->phy_address = mii->phy_id;
5974700c	92	ecmd->mdio_support = MDIO_SUPPORTS_C22;
1da177e4 LT	93
1da177e4 LT	94	ecmd->advertising = ADVERTISED_TP \| ADVERTISED_MII;
1da177e4 LT	95
1da177e4 LT	96	bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
5974700c	97	bmsr = mii->mdio_read(dev, mii->phy_id, MII_BMSR);
1da177e4	98	if (mii->supports_gmii) {
5974700c BH	99	ctrl1000 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
5974700c BH	100	stat1000 = mii->mdio_read(dev, mii->phy_id, MII_STAT1000);
1da177e4 LT	101	}
	102	if (bmcr & BMCR_ANENABLE) {
	103	ecmd->advertising \|= ADVERTISED_Autoneg;
	104	ecmd->autoneg = AUTONEG_ENABLE;
6aa20a22	105
5974700c BH	106	ecmd->advertising \|= mii_get_an(mii, MII_ADVERTISE);
	107	if (ctrl1000 & ADVERTISE_1000HALF)
	108	ecmd->advertising \|= ADVERTISED_1000baseT_Half;
	109	if (ctrl1000 & ADVERTISE_1000FULL)
	110	ecmd->advertising \|= ADVERTISED_1000baseT_Full;
	111
	112	if (bmsr & BMSR_ANEGCOMPLETE) {
	113	ecmd->lp_advertising = mii_get_an(mii, MII_LPA);
	114	if (stat1000 & LPA_1000HALF)
	115	ecmd->lp_advertising \|=
	116	ADVERTISED_1000baseT_Half;
	117	if (stat1000 & LPA_1000FULL)
	118	ecmd->lp_advertising \|=
	119	ADVERTISED_1000baseT_Full;
	120	} else {
	121	ecmd->lp_advertising = 0;
	122	}
	123
	124	nego = ecmd->advertising & ecmd->lp_advertising;
	125
	126	if (nego & (ADVERTISED_1000baseT_Full \|
	127	ADVERTISED_1000baseT_Half)) {
70739497	128	ethtool_cmd_speed_set(ecmd, SPEED_1000);
5974700c BH	129	ecmd->duplex = !!(nego & ADVERTISED_1000baseT_Full);
	130	} else if (nego & (ADVERTISED_100baseT_Full \|
	131	ADVERTISED_100baseT_Half)) {
70739497	132	ethtool_cmd_speed_set(ecmd, SPEED_100);
5974700c	133	ecmd->duplex = !!(nego & ADVERTISED_100baseT_Full);
1da177e4	134	} else {
70739497	135	ethtool_cmd_speed_set(ecmd, SPEED_10);
5974700c	136	ecmd->duplex = !!(nego & ADVERTISED_10baseT_Full);
1da177e4 LT	137	}
	138	} else {
	139	ecmd->autoneg = AUTONEG_DISABLE;
	140
70739497 DD	141	ethtool_cmd_speed_set(ecmd,
	142	((bmcr & BMCR_SPEED1000 &&
	143	(bmcr & BMCR_SPEED100) == 0) ?
	144	SPEED_1000 :
	145	((bmcr & BMCR_SPEED100) ?
	146	SPEED_100 : SPEED_10)));
1da177e4 LT	147	ecmd->duplex = (bmcr & BMCR_FULLDPLX) ? DUPLEX_FULL : DUPLEX_HALF;
	148	}
	149
5974700c BH	150	mii->full_duplex = ecmd->duplex;
5974700c BH	151
1da177e4 LT	152	/* ignore maxtxpkt, maxrxpkt for now */
	153
	154	return 0;
	155	}
	156
32684ec6 RD	157	/**
	158	* mii_ethtool_sset - set settings that are specified in @ecmd
	159	* @mii: MII interface
	160	* @ecmd: requested ethtool_cmd
	161	*
	162	* Returns 0 for success, negative on error.
	163	*/
1da177e4 LT	164	int mii_ethtool_sset(struct mii_if_info mii, struct ethtool_cmd ecmd)
	165	{
	166	struct net_device *dev = mii->dev;
25db0338	167	u32 speed = ethtool_cmd_speed(ecmd);
1da177e4	168
25db0338 DD	169	if (speed != SPEED_10 &&
	170	speed != SPEED_100 &&
	171	speed != SPEED_1000)
1da177e4 LT	172	return -EINVAL;
	173	if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
	174	return -EINVAL;
	175	if (ecmd->port != PORT_MII)
	176	return -EINVAL;
	177	if (ecmd->transceiver != XCVR_INTERNAL)
	178	return -EINVAL;
	179	if (ecmd->phy_address != mii->phy_id)
	180	return -EINVAL;
	181	if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
	182	return -EINVAL;
25db0338	183	if ((speed == SPEED_1000) && (!mii->supports_gmii))
1da177e4	184	return -EINVAL;
6aa20a22	185
1da177e4	186	/* ignore supported, maxtxpkt, maxrxpkt */
6aa20a22	187
1da177e4 LT	188	if (ecmd->autoneg == AUTONEG_ENABLE) {
	189	u32 bmcr, advert, tmp;
	190	u32 advert2 = 0, tmp2 = 0;
	191
	192	if ((ecmd->advertising & (ADVERTISED_10baseT_Half \|
	193	ADVERTISED_10baseT_Full \|
	194	ADVERTISED_100baseT_Half \|
	195	ADVERTISED_100baseT_Full \|
	196	ADVERTISED_1000baseT_Half \|
	197	ADVERTISED_1000baseT_Full)) == 0)
	198	return -EINVAL;
	199
	200	/* advertise only what has been requested */
	201	advert = mii->mdio_read(dev, mii->phy_id, MII_ADVERTISE);
	202	tmp = advert & ~(ADVERTISE_ALL \| ADVERTISE_100BASE4);
	203	if (mii->supports_gmii) {
	204	advert2 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
	205	tmp2 = advert2 & ~(ADVERTISE_1000HALF \| ADVERTISE_1000FULL);
	206	}
	207	if (ecmd->advertising & ADVERTISED_10baseT_Half)
	208	tmp \|= ADVERTISE_10HALF;
	209	if (ecmd->advertising & ADVERTISED_10baseT_Full)
	210	tmp \|= ADVERTISE_10FULL;
	211	if (ecmd->advertising & ADVERTISED_100baseT_Half)
	212	tmp \|= ADVERTISE_100HALF;
	213	if (ecmd->advertising & ADVERTISED_100baseT_Full)
	214	tmp \|= ADVERTISE_100FULL;
	215	if (mii->supports_gmii) {
	216	if (ecmd->advertising & ADVERTISED_1000baseT_Half)
	217	tmp2 \|= ADVERTISE_1000HALF;
	218	if (ecmd->advertising & ADVERTISED_1000baseT_Full)
	219	tmp2 \|= ADVERTISE_1000FULL;
	220	}
	221	if (advert != tmp) {
	222	mii->mdio_write(dev, mii->phy_id, MII_ADVERTISE, tmp);
	223	mii->advertising = tmp;
	224	}
	225	if ((mii->supports_gmii) && (advert2 != tmp2))
	226	mii->mdio_write(dev, mii->phy_id, MII_CTRL1000, tmp2);
6aa20a22	227
1da177e4 LT	228	/* turn on autonegotiation, and force a renegotiate */
	229	bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
	230	bmcr \|= (BMCR_ANENABLE \| BMCR_ANRESTART);
	231	mii->mdio_write(dev, mii->phy_id, MII_BMCR, bmcr);
	232
	233	mii->force_media = 0;
	234	} else {
	235	u32 bmcr, tmp;
	236
	237	/* turn off auto negotiation, set speed and duplexity */
	238	bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
6aa20a22	239	tmp = bmcr & ~(BMCR_ANENABLE \| BMCR_SPEED100 \|
1da177e4	240	BMCR_SPEED1000 \| BMCR_FULLDPLX);
25db0338	241	if (speed == SPEED_1000)
1da177e4	242	tmp \|= BMCR_SPEED1000;
25db0338	243	else if (speed == SPEED_100)
1da177e4 LT	244	tmp \|= BMCR_SPEED100;
	245	if (ecmd->duplex == DUPLEX_FULL) {
	246	tmp \|= BMCR_FULLDPLX;
	247	mii->full_duplex = 1;
	248	} else
	249	mii->full_duplex = 0;
	250	if (bmcr != tmp)
	251	mii->mdio_write(dev, mii->phy_id, MII_BMCR, tmp);
	252
	253	mii->force_media = 1;
	254	}
	255	return 0;
	256	}
	257
32684ec6 RD	258	/**
	259	* mii_check_gmii_support - check if the MII supports Gb interfaces
	260	* @mii: the MII interface
	261	*/
43ec6e95 DF	262	int mii_check_gmii_support(struct mii_if_info *mii)
	263	{
	264	int reg;
	265
	266	reg = mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
	267	if (reg & BMSR_ESTATEN) {
	268	reg = mii->mdio_read(mii->dev, mii->phy_id, MII_ESTATUS);
	269	if (reg & (ESTATUS_1000_TFULL \| ESTATUS_1000_THALF))
	270	return 1;
	271	}
	272
	273	return 0;
	274	}
	275
32684ec6 RD	276	/**
	277	* mii_link_ok - is link status up/ok
	278	* @mii: the MII interface
	279	*
	280	* Returns 1 if the MII reports link status up/ok, 0 otherwise.
	281	*/
1da177e4 LT	282	int mii_link_ok (struct mii_if_info *mii)
	283	{
	284	/* first, a dummy read, needed to latch some MII phys */
	285	mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
	286	if (mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR) & BMSR_LSTATUS)
	287	return 1;
	288	return 0;
	289	}
	290
32684ec6 RD	291	/**
	292	* mii_nway_restart - restart NWay (autonegotiation) for this interface
	293	* @mii: the MII interface
	294	*
	295	* Returns 0 on success, negative on error.
	296	*/
1da177e4 LT	297	int mii_nway_restart (struct mii_if_info *mii)
	298	{
	299	int bmcr;
	300	int r = -EINVAL;
	301
	302	/* if autoneg is off, it's an error */
	303	bmcr = mii->mdio_read(mii->dev, mii->phy_id, MII_BMCR);
	304
	305	if (bmcr & BMCR_ANENABLE) {
	306	bmcr \|= BMCR_ANRESTART;
	307	mii->mdio_write(mii->dev, mii->phy_id, MII_BMCR, bmcr);
	308	r = 0;
	309	}
	310
	311	return r;
	312	}
	313
32684ec6 RD	314	/**
	315	* mii_check_link - check MII link status
	316	* @mii: MII interface
	317	*
	318	* If the link status changed (previous != current), call
	319	* netif_carrier_on() if current link status is Up or call
	320	* netif_carrier_off() if current link status is Down.
	321	*/
1da177e4 LT	322	void mii_check_link (struct mii_if_info *mii)
	323	{
	324	int cur_link = mii_link_ok(mii);
	325	int prev_link = netif_carrier_ok(mii->dev);
	326
	327	if (cur_link && !prev_link)
	328	netif_carrier_on(mii->dev);
	329	else if (prev_link && !cur_link)
	330	netif_carrier_off(mii->dev);
	331	}
	332
32684ec6 RD	333	/**
	334	* mii_check_media - check the MII interface for a duplex change
	335	* @mii: the MII interface
	336	* @ok_to_print: OK to print link up/down messages
	337	* @init_media: OK to save duplex mode in @mii
	338	*
	339	* Returns 1 if the duplex mode changed, 0 if not.
	340	* If the media type is forced, always returns 0.
	341	*/
1da177e4 LT	342	unsigned int mii_check_media (struct mii_if_info *mii,
	343	unsigned int ok_to_print,
	344	unsigned int init_media)
	345	{
	346	unsigned int old_carrier, new_carrier;
	347	int advertise, lpa, media, duplex;
	348	int lpa2 = 0;
	349
	350	/* if forced media, go no further */
	351	if (mii->force_media)
	352	return 0; /* duplex did not change */
	353
	354	/* check current and old link status */
	355	old_carrier = netif_carrier_ok(mii->dev) ? 1 : 0;
	356	new_carrier = (unsigned int) mii_link_ok(mii);
	357
	358	/* if carrier state did not change, this is a "bounce",
	359	* just exit as everything is already set correctly
	360	*/
	361	if ((!init_media) && (old_carrier == new_carrier))
	362	return 0; /* duplex did not change */
	363
	364	/* no carrier, nothing much to do */
	365	if (!new_carrier) {
	366	netif_carrier_off(mii->dev);
	367	if (ok_to_print)
967faf3b	368	netdev_info(mii->dev, "link down\n");
1da177e4 LT	369	return 0; /* duplex did not change */
	370	}
	371
	372	/*
	373	* we have carrier, see who's on the other end
	374	*/
	375	netif_carrier_on(mii->dev);
	376
	377	/* get MII advertise and LPA values */
	378	if ((!init_media) && (mii->advertising))
	379	advertise = mii->advertising;
	380	else {
	381	advertise = mii->mdio_read(mii->dev, mii->phy_id, MII_ADVERTISE);
	382	mii->advertising = advertise;
	383	}
	384	lpa = mii->mdio_read(mii->dev, mii->phy_id, MII_LPA);
	385	if (mii->supports_gmii)
	386	lpa2 = mii->mdio_read(mii->dev, mii->phy_id, MII_STAT1000);
	387
	388	/* figure out media and duplex from advertise and LPA values */
	389	media = mii_nway_result(lpa & advertise);
	390	duplex = (media & ADVERTISE_FULL) ? 1 : 0;
	391	if (lpa2 & LPA_1000FULL)
	392	duplex = 1;
	393
	394	if (ok_to_print)
967faf3b JP	395	netdev_info(mii->dev, "link up, %uMbps, %s-duplex, lpa 0x%04X\n",
	396	lpa2 & (LPA_1000FULL \| LPA_1000HALF) ? 1000 :
	397	media & (ADVERTISE_100FULL \| ADVERTISE_100HALF) ?
	398	100 : 10,
	399	duplex ? "full" : "half",
	400	lpa);
1da177e4 LT	401
	402	if ((init_media) \|\| (mii->full_duplex != duplex)) {
	403	mii->full_duplex = duplex;
	404	return 1; /* duplex changed */
	405	}
	406
	407	return 0; /* duplex did not change */
	408	}
	409
32684ec6 RD	410	/**
	411	* generic_mii_ioctl - main MII ioctl interface
	412	* @mii_if: the MII interface
	413	* @mii_data: MII ioctl data structure
	414	* @cmd: MII ioctl command
	415	* @duplex_chg_out: pointer to @duplex_changed status if there was no
	416	* ioctl error
	417	*
	418	* Returns 0 on success, negative on error.
	419	*/
1da177e4 LT	420	int generic_mii_ioctl(struct mii_if_info *mii_if,
	421	struct mii_ioctl_data *mii_data, int cmd,
	422	unsigned int *duplex_chg_out)
	423	{
	424	int rc = 0;
	425	unsigned int duplex_changed = 0;
	426
	427	if (duplex_chg_out)
	428	*duplex_chg_out = 0;
	429
	430	mii_data->phy_id &= mii_if->phy_id_mask;
	431	mii_data->reg_num &= mii_if->reg_num_mask;
	432
	433	switch(cmd) {
	434	case SIOCGMIIPHY:
	435	mii_data->phy_id = mii_if->phy_id;
	436	/* fall through */
	437
	438	case SIOCGMIIREG:
	439	mii_data->val_out =
	440	mii_if->mdio_read(mii_if->dev, mii_data->phy_id,
	441	mii_data->reg_num);
	442	break;
	443
	444	case SIOCSMIIREG: {
	445	u16 val = mii_data->val_in;
	446
1da177e4 LT	447	if (mii_data->phy_id == mii_if->phy_id) {
	448	switch(mii_data->reg_num) {
	449	case MII_BMCR: {
	450	unsigned int new_duplex = 0;
	451	if (val & (BMCR_RESET\|BMCR_ANENABLE))
	452	mii_if->force_media = 0;
	453	else
	454	mii_if->force_media = 1;
	455	if (mii_if->force_media &&
	456	(val & BMCR_FULLDPLX))
	457	new_duplex = 1;
	458	if (mii_if->full_duplex != new_duplex) {
	459	duplex_changed = 1;
	460	mii_if->full_duplex = new_duplex;
	461	}
	462	break;
	463	}
	464	case MII_ADVERTISE:
	465	mii_if->advertising = val;
	466	break;
	467	default:
	468	/* do nothing */
	469	break;
	470	}
	471	}
	472
	473	mii_if->mdio_write(mii_if->dev, mii_data->phy_id,
	474	mii_data->reg_num, val);
	475	break;
	476	}
	477
	478	default:
	479	rc = -EOPNOTSUPP;
	480	break;
	481	}
	482
	483	if ((rc == 0) && (duplex_chg_out) && (duplex_changed))
	484	*duplex_chg_out = 1;
	485
	486	return rc;
	487	}
	488
	489	MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>");
	490	MODULE_DESCRIPTION ("MII hardware support library");
	491	MODULE_LICENSE("GPL");
	492
	493	EXPORT_SYMBOL(mii_link_ok);
	494	EXPORT_SYMBOL(mii_nway_restart);
	495	EXPORT_SYMBOL(mii_ethtool_gset);
	496	EXPORT_SYMBOL(mii_ethtool_sset);
	497	EXPORT_SYMBOL(mii_check_link);
	498	EXPORT_SYMBOL(mii_check_media);
43ec6e95	499	EXPORT_SYMBOL(mii_check_gmii_support);
1da177e4 LT	500	EXPORT_SYMBOL(generic_mii_ioctl);
1da177e4 LT	501