[GitHub/mt8127/android_kernel_alcatel_ttab.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;

	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)) {
			ecmd->speed = SPEED_1000;
			ecmd->duplex = !!(nego & ADVERTISED_1000baseT_Full);
		} else if (nego & (ADVERTISED_100baseT_Full |
				   ADVERTISED_100baseT_Half)) {
			ecmd->speed = SPEED_100;
			ecmd->duplex = !!(nego & ADVERTISED_100baseT_Full);
		} else {
			ecmd->speed = SPEED_10;
			ecmd->duplex = !!(nego & ADVERTISED_10baseT_Full);
		}
	} else {
		ecmd->autoneg = AUTONEG_DISABLE;

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