[people/ms/u-boot.git] / drivers / net / phy / phy.c

/*
 * Generic PHY Management code
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 *
 *
 * Copyright 2011 Freescale Semiconductor, Inc.
 * author Andy Fleming
 *
 * Based loosely off of Linux's PHY Lib
 */

#include <config.h>
#include <common.h>
#include <malloc.h>
#include <net.h>
#include <command.h>
#include <miiphy.h>
#include <phy.h>
#include <errno.h>

/* Generic PHY support and helper functions */

/**
 * genphy_config_advert - sanitize and advertise auto-negotation parameters
 * @phydev: target phy_device struct
 *
 * Description: Writes MII_ADVERTISE with the appropriate values,
 *   after sanitizing the values to make sure we only advertise
 *   what is supported.  Returns < 0 on error, 0 if the PHY's advertisement
 *   hasn't changed, and > 0 if it has changed.
 */
int genphy_config_advert(struct phy_device *phydev)
{
	u32 advertise;
	int oldadv, adv;
	int err, changed = 0;

	/* Only allow advertising what
	 * this PHY supports */
	phydev->advertising &= phydev->supported;
	advertise = phydev->advertising;

	/* Setup standard advertisement */
	oldadv = adv = phy_read(phydev, MDIO_DEVAD_NONE, MII_ADVERTISE);

	if (adv < 0)
		return adv;

	adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP |
		 ADVERTISE_PAUSE_ASYM);
	if (advertise & ADVERTISED_10baseT_Half)
		adv |= ADVERTISE_10HALF;
	if (advertise & ADVERTISED_10baseT_Full)
		adv |= ADVERTISE_10FULL;
	if (advertise & ADVERTISED_100baseT_Half)
		adv |= ADVERTISE_100HALF;
	if (advertise & ADVERTISED_100baseT_Full)
		adv |= ADVERTISE_100FULL;
	if (advertise & ADVERTISED_Pause)
		adv |= ADVERTISE_PAUSE_CAP;
	if (advertise & ADVERTISED_Asym_Pause)
		adv |= ADVERTISE_PAUSE_ASYM;

	if (adv != oldadv) {
		err = phy_write(phydev, MDIO_DEVAD_NONE, MII_ADVERTISE, adv);

		if (err < 0)
			return err;
		changed = 1;
	}

	/* Configure gigabit if it's supported */
	if (phydev->supported & (SUPPORTED_1000baseT_Half |
				SUPPORTED_1000baseT_Full)) {
		oldadv = adv = phy_read(phydev, MDIO_DEVAD_NONE, MII_CTRL1000);

		if (adv < 0)
			return adv;

		adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
		if (advertise & SUPPORTED_1000baseT_Half)
			adv |= ADVERTISE_1000HALF;
		if (advertise & SUPPORTED_1000baseT_Full)
			adv |= ADVERTISE_1000FULL;

		if (adv != oldadv) {
			err = phy_write(phydev, MDIO_DEVAD_NONE, MII_CTRL1000,
					adv);

			if (err < 0)
				return err;
			changed = 1;
		}
	}

	return changed;
}


/**
 * genphy_setup_forced - configures/forces speed/duplex from @phydev
 * @phydev: target phy_device struct
 *
 * Description: Configures MII_BMCR to force speed/duplex
 *   to the values in phydev. Assumes that the values are valid.
 */
int genphy_setup_forced(struct phy_device *phydev)
{
	int err;
	int ctl = 0;

	phydev->pause = phydev->asym_pause = 0;

	if (SPEED_1000 == phydev->speed)
		ctl |= BMCR_SPEED1000;
	else if (SPEED_100 == phydev->speed)
		ctl |= BMCR_SPEED100;

	if (DUPLEX_FULL == phydev->duplex)
		ctl |= BMCR_FULLDPLX;

	err = phy_write(phydev, MDIO_DEVAD_NONE, MII_BMCR, ctl);

	return err;
}


/**
 * genphy_restart_aneg - Enable and Restart Autonegotiation
 * @phydev: target phy_device struct
 */
int genphy_restart_aneg(struct phy_device *phydev)
{
	int ctl;

	ctl = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMCR);

	if (ctl < 0)
		return ctl;

	ctl |= (BMCR_ANENABLE | BMCR_ANRESTART);

	/* Don't isolate the PHY if we're negotiating */
	ctl &= ~(BMCR_ISOLATE);

	ctl = phy_write(phydev, MDIO_DEVAD_NONE, MII_BMCR, ctl);

	return ctl;
}


/**
 * genphy_config_aneg - restart auto-negotiation or write BMCR
 * @phydev: target phy_device struct
 *
 * Description: If auto-negotiation is enabled, we configure the
 *   advertising, and then restart auto-negotiation.  If it is not
 *   enabled, then we write the BMCR.
 */
int genphy_config_aneg(struct phy_device *phydev)
{
	int result;

	if (AUTONEG_ENABLE != phydev->autoneg)
		return genphy_setup_forced(phydev);

	result = genphy_config_advert(phydev);

	if (result < 0) /* error */
		return result;

	if (result == 0) {
		/* Advertisment hasn't changed, but maybe aneg was never on to
		 * begin with?  Or maybe phy was isolated? */
		int ctl = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMCR);

		if (ctl < 0)
			return ctl;

		if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
			result = 1; /* do restart aneg */
	}

	/* Only restart aneg if we are advertising something different
	 * than we were before.	 */
	if (result > 0)
		result = genphy_restart_aneg(phydev);

	return result;
}

/**
 * genphy_update_link - update link status in @phydev
 * @phydev: target phy_device struct
 *
 * Description: Update the value in phydev->link to reflect the
 *   current link value.  In order to do this, we need to read
 *   the status register twice, keeping the second value.
 */
int genphy_update_link(struct phy_device *phydev)
{
	unsigned int mii_reg;

	/*
	 * Wait if the link is up, and autonegotiation is in progress
	 * (ie - we're capable and it's not done)
	 */
	mii_reg = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR);

	/*
	 * If we already saw the link up, and it hasn't gone down, then
	 * we don't need to wait for autoneg again
	 */
	if (phydev->link && mii_reg & BMSR_LSTATUS)
		return 0;

	if ((mii_reg & BMSR_ANEGCAPABLE) && !(mii_reg & BMSR_ANEGCOMPLETE)) {
		int i = 0;

		printf("%s Waiting for PHY auto negotiation to complete",
			phydev->dev->name);
		while (!(mii_reg & BMSR_ANEGCOMPLETE)) {
			/*
			 * Timeout reached ?
			 */
			if (i > PHY_ANEG_TIMEOUT) {
				printf(" TIMEOUT !\n");
				phydev->link = 0;
				return 0;
			}

			if (ctrlc()) {
				puts("user interrupt!\n");
				phydev->link = 0;
				return -EINTR;
			}

			if ((i++ % 500) == 0)
				printf(".");

			udelay(1000);	/* 1 ms */
			mii_reg = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR);
		}
		printf(" done\n");
		phydev->link = 1;
	} else {
		/* Read the link a second time to clear the latched state */
		mii_reg = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR);

		if (mii_reg & BMSR_LSTATUS)
			phydev->link = 1;
		else
			phydev->link = 0;
	}

	return 0;
}

/*
 * Generic function which updates the speed and duplex.  If
 * autonegotiation is enabled, it uses the AND of the link
 * partner's advertised capabilities and our advertised
 * capabilities.  If autonegotiation is disabled, we use the
 * appropriate bits in the control register.
 *
 * Stolen from Linux's mii.c and phy_device.c
 */
static int genphy_parse_link(struct phy_device *phydev)
{
	int mii_reg = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR);

	/* We're using autonegotiation */
	if (mii_reg & BMSR_ANEGCAPABLE) {
		u32 lpa = 0;
		u32 gblpa = 0;

		/* Check for gigabit capability */
		if (mii_reg & BMSR_ERCAP) {
			/* We want a list of states supported by
			 * both PHYs in the link
			 */
			gblpa = phy_read(phydev, MDIO_DEVAD_NONE, MII_STAT1000);
			gblpa &= phy_read(phydev,
					MDIO_DEVAD_NONE, MII_CTRL1000) << 2;
		}

		/* Set the baseline so we only have to set them
		 * if they're different
		 */
		phydev->speed = SPEED_10;
		phydev->duplex = DUPLEX_HALF;

		/* Check the gigabit fields */
		if (gblpa & (PHY_1000BTSR_1000FD | PHY_1000BTSR_1000HD)) {
			phydev->speed = SPEED_1000;

			if (gblpa & PHY_1000BTSR_1000FD)
				phydev->duplex = DUPLEX_FULL;

			/* We're done! */
			return 0;
		}

		lpa = phy_read(phydev, MDIO_DEVAD_NONE, MII_ADVERTISE);
		lpa &= phy_read(phydev, MDIO_DEVAD_NONE, MII_LPA);

		if (lpa & (LPA_100FULL | LPA_100HALF)) {
			phydev->speed = SPEED_100;

			if (lpa & LPA_100FULL)
				phydev->duplex = DUPLEX_FULL;

		} else if (lpa & LPA_10FULL)
			phydev->duplex = DUPLEX_FULL;
	} else {
		u32 bmcr = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMCR);

		phydev->speed = SPEED_10;
		phydev->duplex = DUPLEX_HALF;

		if (bmcr & BMCR_FULLDPLX)
			phydev->duplex = DUPLEX_FULL;

		if (bmcr & BMCR_SPEED1000)
			phydev->speed = SPEED_1000;
		else if (bmcr & BMCR_SPEED100)
			phydev->speed = SPEED_100;
	}

	return 0;
}

int genphy_config(struct phy_device *phydev)
{
	int val;
	u32 features;

	/* For now, I'll claim that the generic driver supports
	 * all possible port types */
	features = (SUPPORTED_TP | SUPPORTED_MII
			| SUPPORTED_AUI | SUPPORTED_FIBRE |
			SUPPORTED_BNC);

	/* Do we support autonegotiation? */
	val = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR);

	if (val < 0)
		return val;

	if (val & BMSR_ANEGCAPABLE)
		features |= SUPPORTED_Autoneg;

	if (val & BMSR_100FULL)
		features |= SUPPORTED_100baseT_Full;
	if (val & BMSR_100HALF)
		features |= SUPPORTED_100baseT_Half;
	if (val & BMSR_10FULL)
		features |= SUPPORTED_10baseT_Full;
	if (val & BMSR_10HALF)
		features |= SUPPORTED_10baseT_Half;

	if (val & BMSR_ESTATEN) {
		val = phy_read(phydev, MDIO_DEVAD_NONE, MII_ESTATUS);

		if (val < 0)
			return val;

		if (val & ESTATUS_1000_TFULL)
			features |= SUPPORTED_1000baseT_Full;
		if (val & ESTATUS_1000_THALF)
			features |= SUPPORTED_1000baseT_Half;
	}

	phydev->supported = features;
	phydev->advertising = features;

	genphy_config_aneg(phydev);

	return 0;
}

int genphy_startup(struct phy_device *phydev)
{
	genphy_update_link(phydev);
	genphy_parse_link(phydev);

	return 0;
}

int genphy_shutdown(struct phy_device *phydev)
{
	return 0;
}

static struct phy_driver genphy_driver = {
	.uid		= 0xffffffff,
	.mask		= 0xffffffff,
	.name		= "Generic PHY",
	.features	= 0,
	.config		= genphy_config,
	.startup	= genphy_startup,
	.shutdown	= genphy_shutdown,
};

static LIST_HEAD(phy_drivers);

int phy_init(void)
{
#ifdef CONFIG_PHY_ATHEROS
	phy_atheros_init();
#endif
#ifdef CONFIG_PHY_BROADCOM
	phy_broadcom_init();
#endif
#ifdef CONFIG_PHY_DAVICOM
	phy_davicom_init();
#endif
#ifdef CONFIG_PHY_LXT
	phy_lxt_init();
#endif
#ifdef CONFIG_PHY_MARVELL
	phy_marvell_init();
#endif
#ifdef CONFIG_PHY_MICREL
	phy_micrel_init();
#endif
#ifdef CONFIG_PHY_NATSEMI
	phy_natsemi_init();
#endif
#ifdef CONFIG_PHY_REALTEK
	phy_realtek_init();
#endif
#ifdef CONFIG_PHY_TERANETICS
	phy_teranetics_init();
#endif
#ifdef CONFIG_PHY_VITESSE
	phy_vitesse_init();
#endif

	return 0;
}

int phy_register(struct phy_driver *drv)
{
	INIT_LIST_HEAD(&drv->list);
	list_add_tail(&drv->list, &phy_drivers);

	return 0;
}

int phy_probe(struct phy_device *phydev)
{
	int err = 0;

	phydev->advertising = phydev->supported = phydev->drv->features;
	phydev->mmds = phydev->drv->mmds;

	if (phydev->drv->probe)
		err = phydev->drv->probe(phydev);

	return err;
}

static struct phy_driver *generic_for_interface(phy_interface_t interface)
{
#ifdef CONFIG_PHYLIB_10G
	if (is_10g_interface(interface))
		return &gen10g_driver;
#endif

	return &genphy_driver;
}

struct phy_driver *get_phy_driver(struct phy_device *phydev,
				phy_interface_t interface)
{
	struct list_head *entry;
	int phy_id = phydev->phy_id;
	struct phy_driver *drv = NULL;

	list_for_each(entry, &phy_drivers) {
		drv = list_entry(entry, struct phy_driver, list);
		if ((drv->uid & drv->mask) == (phy_id & drv->mask))
			return drv;
	}

	/* If we made it here, there's no driver for this PHY */
	return generic_for_interface(interface);
}

struct phy_device *phy_device_create(struct mii_dev *bus, int addr, int phy_id,
					phy_interface_t interface)
{
	struct phy_device *dev;

	/* We allocate the device, and initialize the
	 * default values */
	dev = malloc(sizeof(*dev));
	if (!dev) {
		printf("Failed to allocate PHY device for %s:%d\n",
			bus->name, addr);
		return NULL;
	}

	memset(dev, 0, sizeof(*dev));

	dev->duplex = -1;
	dev->link = 1;
	dev->interface = interface;

	dev->autoneg = AUTONEG_ENABLE;

	dev->addr = addr;
	dev->phy_id = phy_id;
	dev->bus = bus;

	dev->drv = get_phy_driver(dev, interface);

	phy_probe(dev);

	bus->phymap[addr] = dev;

	return dev;
}

/**
 * get_phy_id - reads the specified addr for its ID.
 * @bus: the target MII bus
 * @addr: PHY address on the MII bus
 * @phy_id: where to store the ID retrieved.
 *
 * Description: Reads the ID registers of the PHY at @addr on the
 *   @bus, stores it in @phy_id and returns zero on success.
 */
int get_phy_id(struct mii_dev *bus, int addr, int devad, u32 *phy_id)
{
	int phy_reg;

	/* Grab the bits from PHYIR1, and put them
	 * in the upper half */
	phy_reg = bus->read(bus, addr, devad, MII_PHYSID1);

	if (phy_reg < 0)
		return -EIO;

	*phy_id = (phy_reg & 0xffff) << 16;

	/* Grab the bits from PHYIR2, and put them in the lower half */
	phy_reg = bus->read(bus, addr, devad, MII_PHYSID2);

	if (phy_reg < 0)
		return -EIO;

	*phy_id |= (phy_reg & 0xffff);

	return 0;
}

/**
 * get_phy_device - reads the specified PHY device and returns its @phy_device struct
 * @bus: the target MII bus
 * @addr: PHY address on the MII bus
 *
 * Description: Reads the ID registers of the PHY at @addr on the
 *   @bus, then allocates and returns the phy_device to represent it.
 */
struct phy_device *get_phy_device(struct mii_dev *bus, int addr,
				phy_interface_t interface)
{
	u32 phy_id = 0x1fffffff;
	int i;
	int r;

	/* If we have one, return the existing device, with new interface */
	if (bus->phymap[addr]) {
		bus->phymap[addr]->interface = interface;

		return bus->phymap[addr];
	}

	/* Try Standard (ie Clause 22) access */
	r = get_phy_id(bus, addr, MDIO_DEVAD_NONE, &phy_id);
	if (r)
		return NULL;

	/* If the PHY ID is mostly f's, we didn't find anything */
	if ((phy_id & 0x1fffffff) != 0x1fffffff)
		return phy_device_create(bus, addr, phy_id, interface);

	/* Otherwise we have to try Clause 45 */
	for (i = 1; i < 5; i++) {
		r = get_phy_id(bus, addr, i, &phy_id);
		if (r)
			return NULL;

		/* If the phy_id is mostly Fs, there is no device there */
		if ((phy_id & 0x1fffffff) != 0x1fffffff)
			break;
	}

	return phy_device_create(bus, addr, phy_id, interface);
}

int phy_reset(struct phy_device *phydev)
{
	int reg;
	int timeout = 500;
	int devad = MDIO_DEVAD_NONE;

#ifdef CONFIG_PHYLIB_10G
	/* If it's 10G, we need to issue reset through one of the MMDs */
	if (is_10g_interface(phydev->interface)) {
		if (!phydev->mmds)
			gen10g_discover_mmds(phydev);

		devad = ffs(phydev->mmds) - 1;
	}
#endif

	reg = phy_read(phydev, devad, MII_BMCR);
	if (reg < 0) {
		debug("PHY status read failed\n");
		return -1;
	}

	reg |= BMCR_RESET;

	if (phy_write(phydev, devad, MII_BMCR, reg) < 0) {
		debug("PHY reset failed\n");
		return -1;
	}

#ifdef CONFIG_PHY_RESET_DELAY
	udelay(CONFIG_PHY_RESET_DELAY);	/* Intel LXT971A needs this */
#endif
	/*
	 * Poll the control register for the reset bit to go to 0 (it is
	 * auto-clearing).  This should happen within 0.5 seconds per the
	 * IEEE spec.
	 */
	while ((reg & BMCR_RESET) && timeout--) {
		reg = phy_read(phydev, devad, MII_BMCR);

		if (reg < 0) {
			debug("PHY status read failed\n");
			return -1;
		}
		udelay(1000);
	}

	if (reg & BMCR_RESET) {
		puts("PHY reset timed out\n");
		return -1;
	}

	return 0;
}

int miiphy_reset(const char *devname, unsigned char addr)
{
	struct mii_dev *bus = miiphy_get_dev_by_name(devname);
	struct phy_device *phydev;

	/*
	 * miiphy_reset was only used on standard PHYs, so we'll fake it here.
	 * If later code tries to connect with the right interface, this will
	 * be corrected by get_phy_device in phy_connect()
	 */
	phydev = get_phy_device(bus, addr, PHY_INTERFACE_MODE_MII);

	return phy_reset(phydev);
}

struct phy_device *phy_connect(struct mii_dev *bus, int addr,
				struct eth_device *dev,
				phy_interface_t interface)
{
	struct phy_device *phydev;

	/* Reset the bus */
	bus->reset(bus);

	/* Wait 15ms to make sure the PHY has come out of hard reset */
	udelay(15000);

	phydev = get_phy_device(bus, addr, interface);

	if (!phydev) {
		printf("Could not get PHY for %s:%d\n", bus->name, addr);

		return NULL;
	}

	/* Soft Reset the PHY */
	phy_reset(phydev);

	if (phydev->dev)
		printf("%s:%d is connected to %s.  Reconnecting to %s\n",
			bus->name, addr, phydev->dev->name, dev->name);

	phydev->dev = dev;

	printf("%s connected to %s\n", dev->name, phydev->drv->name);

	return phydev;
}

int phy_startup(struct phy_device *phydev)
{
	if (phydev->drv->startup)
		phydev->drv->startup(phydev);

	return 0;
}

static int __board_phy_config(struct phy_device *phydev)
{
	return 0;
}

int board_phy_config(struct phy_device *phydev)
	__attribute__((weak, alias("__board_phy_config")));

int phy_config(struct phy_device *phydev)
{
	if (phydev->drv->config)
		phydev->drv->config(phydev);

	/* Invoke an optional board-specific helper */
	board_phy_config(phydev);

	return 0;
}

int phy_shutdown(struct phy_device *phydev)
{
	if (phydev->drv->shutdown)
		phydev->drv->shutdown(phydev);

	return 0;
}
Commit	Line	Data
5f184715 AF	1	/*
	2	* Generic PHY Management code
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License as
	6	* published by the Free Software Foundation; either version 2 of
	7	* the License, or (at your option) any later version.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write to the Free Software
	16	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	17	* MA 02111-1307 USA
	18	*
	19	*
	20	* Copyright 2011 Freescale Semiconductor, Inc.
	21	* author Andy Fleming
	22	*
	23	* Based loosely off of Linux's PHY Lib
	24	*/
	25
	26	#include <config.h>
	27	#include <common.h>
	28	#include <malloc.h>
	29	#include <net.h>
	30	#include <command.h>
	31	#include <miiphy.h>
	32	#include <phy.h>
	33	#include <errno.h>
	34
	35	/* Generic PHY support and helper functions */
	36
	37	/**
	38	* genphy_config_advert - sanitize and advertise auto-negotation parameters
	39	* @phydev: target phy_device struct
	40	*
	41	* Description: Writes MII_ADVERTISE with the appropriate values,
	42	* after sanitizing the values to make sure we only advertise
	43	* what is supported. Returns < 0 on error, 0 if the PHY's advertisement
	44	* hasn't changed, and > 0 if it has changed.
	45	*/
	46	int genphy_config_advert(struct phy_device *phydev)
	47	{
	48	u32 advertise;
	49	int oldadv, adv;
	50	int err, changed = 0;
	51
	52	/* Only allow advertising what
	53	* this PHY supports */
	54	phydev->advertising &= phydev->supported;
	55	advertise = phydev->advertising;
	56
	57	/* Setup standard advertisement */
	58	oldadv = adv = phy_read(phydev, MDIO_DEVAD_NONE, MII_ADVERTISE);
	59
	60	if (adv < 0)
	61	return adv;
	62
	63	adv &= ~(ADVERTISE_ALL \| ADVERTISE_100BASE4 \| ADVERTISE_PAUSE_CAP \|
	64	ADVERTISE_PAUSE_ASYM);
65	if (advertise & ADVERTISED_10baseT_Half)
66	adv \|= ADVERTISE_10HALF;
67	if (advertise & ADVERTISED_10baseT_Full)
68	adv \|= ADVERTISE_10FULL;
69	if (advertise & ADVERTISED_100baseT_Half)
70	adv \|= ADVERTISE_100HALF;
71	if (advertise & ADVERTISED_100baseT_Full)
72	adv \|= ADVERTISE_100FULL;
73	if (advertise & ADVERTISED_Pause)
74	adv \|= ADVERTISE_PAUSE_CAP;
75	if (advertise & ADVERTISED_Asym_Pause)
76	adv \|= ADVERTISE_PAUSE_ASYM;
77
78	if (adv != oldadv) {
79	err = phy_write(phydev, MDIO_DEVAD_NONE, MII_ADVERTISE, adv);
80
81	if (err < 0)
82	return err;
83	changed = 1;
84	}
85
86	/* Configure gigabit if it's supported */
87	if (phydev->supported & (SUPPORTED_1000baseT_Half \|
88	SUPPORTED_1000baseT_Full)) {
89	oldadv = adv = phy_read(phydev, MDIO_DEVAD_NONE, MII_CTRL1000);
90
91	if (adv < 0)
92	return adv;
93
94	adv &= ~(ADVERTISE_1000FULL \| ADVERTISE_1000HALF);
95	if (advertise & SUPPORTED_1000baseT_Half)
96	adv \|= ADVERTISE_1000HALF;
97	if (advertise & SUPPORTED_1000baseT_Full)
98	adv \|= ADVERTISE_1000FULL;
99
100	if (adv != oldadv) {
101	err = phy_write(phydev, MDIO_DEVAD_NONE, MII_CTRL1000,
102	adv);
103
104	if (err < 0)
105	return err;
106	changed = 1;
107	}
108	}
109
110	return changed;
111	}
112
113
114	/**
115	* genphy_setup_forced - configures/forces speed/duplex from @phydev
116	* @phydev: target phy_device struct
117	*
118	* Description: Configures MII_BMCR to force speed/duplex
119	* to the values in phydev. Assumes that the values are valid.
120	*/
121	int genphy_setup_forced(struct phy_device *phydev)
122	{
123	int err;
124	int ctl = 0;
125
126	phydev->pause = phydev->asym_pause = 0;
127
128	if (SPEED_1000 == phydev->speed)
129	ctl \|= BMCR_SPEED1000;
130	else if (SPEED_100 == phydev->speed)
131	ctl \|= BMCR_SPEED100;
132
133	if (DUPLEX_FULL == phydev->duplex)
134	ctl \|= BMCR_FULLDPLX;
135
136	err = phy_write(phydev, MDIO_DEVAD_NONE, MII_BMCR, ctl);
137
138	return err;
139	}
140
141
142	/**
143	* genphy_restart_aneg - Enable and Restart Autonegotiation
144	* @phydev: target phy_device struct
145	*/
146	int genphy_restart_aneg(struct phy_device *phydev)
147	{
148	int ctl;
149
150	ctl = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMCR);
151
152	if (ctl < 0)
153	return ctl;
154
155	ctl \|= (BMCR_ANENABLE \| BMCR_ANRESTART);
156
157	/* Don't isolate the PHY if we're negotiating */
158	ctl &= ~(BMCR_ISOLATE);
159
160	ctl = phy_write(phydev, MDIO_DEVAD_NONE, MII_BMCR, ctl);
161
162	return ctl;
163	}
164
165
166	/**
167	* genphy_config_aneg - restart auto-negotiation or write BMCR
168	* @phydev: target phy_device struct
169	*
170	* Description: If auto-negotiation is enabled, we configure the
171	* advertising, and then restart auto-negotiation. If it is not
172	* enabled, then we write the BMCR.
173	*/
174	int genphy_config_aneg(struct phy_device *phydev)
175	{
176	int result;
177
178	if (AUTONEG_ENABLE != phydev->autoneg)
179	return genphy_setup_forced(phydev);
180
181	result = genphy_config_advert(phydev);
182
183	if (result < 0) /* error */
184	return result;
185
186	if (result == 0) {
187	/* Advertisment hasn't changed, but maybe aneg was never on to
188	* begin with? Or maybe phy was isolated? */
189	int ctl = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMCR);
190
191	if (ctl < 0)
192	return ctl;
193
194	if (!(ctl & BMCR_ANENABLE) \|\| (ctl & BMCR_ISOLATE))
195	result = 1; /* do restart aneg */
196	}
197
198	/* Only restart aneg if we are advertising something different
199	* than we were before. */
200	if (result > 0)
201	result = genphy_restart_aneg(phydev);
202
203	return result;
204	}
205
206	/**
207	* genphy_update_link - update link status in @phydev
208	* @phydev: target phy_device struct
209	*
210	* Description: Update the value in phydev->link to reflect the
211	* current link value. In order to do this, we need to read
212	* the status register twice, keeping the second value.
213	*/
214	int genphy_update_link(struct phy_device *phydev)
215	{
216	unsigned int mii_reg;
217
218	/*
219	* Wait if the link is up, and autonegotiation is in progress
220	* (ie - we're capable and it's not done)
221	*/
222	mii_reg = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR);
223
224	/*
225	* If we already saw the link up, and it hasn't gone down, then
226	* we don't need to wait for autoneg again
227	*/
228	if (phydev->link && mii_reg & BMSR_LSTATUS)
229	return 0;
230
231	if ((mii_reg & BMSR_ANEGCAPABLE) && !(mii_reg & BMSR_ANEGCOMPLETE)) {
232	int i = 0;
233
234	printf("%s Waiting for PHY auto negotiation to complete",
235	phydev->dev->name);
236	while (!(mii_reg & BMSR_ANEGCOMPLETE)) {
237	/*
238	* Timeout reached ?
239	*/
240	if (i > PHY_ANEG_TIMEOUT) {
241	printf(" TIMEOUT !\n");
242	phydev->link = 0;
243	return 0;
244	}
245
246	if (ctrlc()) {
247	puts("user interrupt!\n");
248	phydev->link = 0;
249	return -EINTR;
250	}
251
252	if ((i++ % 500) == 0)
253	printf(".");
254
255	udelay(1000); /* 1 ms */
256	mii_reg = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR);
257	}
258	printf(" done\n");
259	phydev->link = 1;
260	} else {
261	/* Read the link a second time to clear the latched state */
262	mii_reg = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR);
263
264	if (mii_reg & BMSR_LSTATUS)
265	phydev->link = 1;
266	else
267	phydev->link = 0;
268	}
269
270	return 0;
271	}
272
273	/*
274	* Generic function which updates the speed and duplex. If
275	* autonegotiation is enabled, it uses the AND of the link
276	* partner's advertised capabilities and our advertised
277	* capabilities. If autonegotiation is disabled, we use the
278	* appropriate bits in the control register.
279	*
280	* Stolen from Linux's mii.c and phy_device.c
281	*/
282	static int genphy_parse_link(struct phy_device *phydev)
283	{
284	int mii_reg = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR);
285
286	/* We're using autonegotiation */
287	if (mii_reg & BMSR_ANEGCAPABLE) {
288	u32 lpa = 0;
289	u32 gblpa = 0;
290
291	/* Check for gigabit capability */
292	if (mii_reg & BMSR_ERCAP) {
293	/* We want a list of states supported by
294	* both PHYs in the link
295	*/
296	gblpa = phy_read(phydev, MDIO_DEVAD_NONE, MII_STAT1000);
297	gblpa &= phy_read(phydev,
298	MDIO_DEVAD_NONE, MII_CTRL1000) << 2;
299	}
300
301	/* Set the baseline so we only have to set them
302	* if they're different
303	*/
304	phydev->speed = SPEED_10;
305	phydev->duplex = DUPLEX_HALF;
306
307	/* Check the gigabit fields */
308	if (gblpa & (PHY_1000BTSR_1000FD \| PHY_1000BTSR_1000HD)) {
309	phydev->speed = SPEED_1000;
310
311	if (gblpa & PHY_1000BTSR_1000FD)
312	phydev->duplex = DUPLEX_FULL;
313
314	/* We're done! */
315	return 0;
316	}
317
318	lpa = phy_read(phydev, MDIO_DEVAD_NONE, MII_ADVERTISE);
319	lpa &= phy_read(phydev, MDIO_DEVAD_NONE, MII_LPA);
320
321	if (lpa & (LPA_100FULL \| LPA_100HALF)) {
322	phydev->speed = SPEED_100;
323
324	if (lpa & LPA_100FULL)
325	phydev->duplex = DUPLEX_FULL;
326
327	} else if (lpa & LPA_10FULL)
328	phydev->duplex = DUPLEX_FULL;
329	} else {
330	u32 bmcr = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMCR);
331
332	phydev->speed = SPEED_10;
333	phydev->duplex = DUPLEX_HALF;
334
335	if (bmcr & BMCR_FULLDPLX)
336	phydev->duplex = DUPLEX_FULL;
337
338	if (bmcr & BMCR_SPEED1000)
339	phydev->speed = SPEED_1000;
340	else if (bmcr & BMCR_SPEED100)
341	phydev->speed = SPEED_100;
342	}
343
344	return 0;
345	}
346
347	int genphy_config(struct phy_device *phydev)
348	{
349	int val;
350	u32 features;
351
352	/* For now, I'll claim that the generic driver supports
353	* all possible port types */
354	features = (SUPPORTED_TP \| SUPPORTED_MII
355	\| SUPPORTED_AUI \| SUPPORTED_FIBRE \|
356	SUPPORTED_BNC);
357
358	/* Do we support autonegotiation? */
359	val = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR);
360
361	if (val < 0)
362	return val;
363
364	if (val & BMSR_ANEGCAPABLE)
365	features \|= SUPPORTED_Autoneg;
366
367	if (val & BMSR_100FULL)
368	features \|= SUPPORTED_100baseT_Full;
369	if (val & BMSR_100HALF)
370	features \|= SUPPORTED_100baseT_Half;
371	if (val & BMSR_10FULL)
372	features \|= SUPPORTED_10baseT_Full;
373	if (val & BMSR_10HALF)
374	features \|= SUPPORTED_10baseT_Half;
375
376	if (val & BMSR_ESTATEN) {
377	val = phy_read(phydev, MDIO_DEVAD_NONE, MII_ESTATUS);
378
379	if (val < 0)
380	return val;
381
382	if (val & ESTATUS_1000_TFULL)
383	features \|= SUPPORTED_1000baseT_Full;
384	if (val & ESTATUS_1000_THALF)
385	features \|= SUPPORTED_1000baseT_Half;
386	}
387
388	phydev->supported = features;
389	phydev->advertising = features;
390
391	genphy_config_aneg(phydev);
392
393	return 0;
394	}
395
396	int genphy_startup(struct phy_device *phydev)
397	{
398	genphy_update_link(phydev);
399	genphy_parse_link(phydev);
400
401	return 0;
402	}
403
404	int genphy_shutdown(struct phy_device *phydev)
405	{
406	return 0;
407	}
408
409	static struct phy_driver genphy_driver = {
410	.uid = 0xffffffff,
411	.mask = 0xffffffff,
412	.name = "Generic PHY",
413	.features = 0,
414	.config = genphy_config,
415	.startup = genphy_startup,
416	.shutdown = genphy_shutdown,
417	};
418
419	static LIST_HEAD(phy_drivers);
420
421	int phy_init(void)
422	{
9082eeac AF	423	#ifdef CONFIG_PHY_ATHEROS
	424	phy_atheros_init();
	425	#endif
	426	#ifdef CONFIG_PHY_BROADCOM
	427	phy_broadcom_init();
	428	#endif
	429	#ifdef CONFIG_PHY_DAVICOM
	430	phy_davicom_init();
	431	#endif
	432	#ifdef CONFIG_PHY_LXT
	433	phy_lxt_init();
	434	#endif
	435	#ifdef CONFIG_PHY_MARVELL
	436	phy_marvell_init();
	437	#endif
	438	#ifdef CONFIG_PHY_MICREL
	439	phy_micrel_init();
	440	#endif
	441	#ifdef CONFIG_PHY_NATSEMI
	442	phy_natsemi_init();
	443	#endif
	444	#ifdef CONFIG_PHY_REALTEK
	445	phy_realtek_init();
	446	#endif
	447	#ifdef CONFIG_PHY_TERANETICS
	448	phy_teranetics_init();
	449	#endif
	450	#ifdef CONFIG_PHY_VITESSE
	451	phy_vitesse_init();
	452	#endif
	453
5f184715 AF	454	return 0;
	455	}
	456
	457	int phy_register(struct phy_driver *drv)
	458	{
	459	INIT_LIST_HEAD(&drv->list);
	460	list_add_tail(&drv->list, &phy_drivers);
	461
	462	return 0;
	463	}
	464
	465	int phy_probe(struct phy_device *phydev)
	466	{
	467	int err = 0;
	468
	469	phydev->advertising = phydev->supported = phydev->drv->features;
	470	phydev->mmds = phydev->drv->mmds;
	471
	472	if (phydev->drv->probe)
	473	err = phydev->drv->probe(phydev);
	474
	475	return err;
	476	}
	477
	478	static struct phy_driver *generic_for_interface(phy_interface_t interface)
	479	{
	480	#ifdef CONFIG_PHYLIB_10G
	481	if (is_10g_interface(interface))
	482	return &gen10g_driver;
	483	#endif
	484
	485	return &genphy_driver;
	486	}
	487
	488	struct phy_driver get_phy_driver(struct phy_device phydev,
	489	phy_interface_t interface)
	490	{
	491	struct list_head *entry;
	492	int phy_id = phydev->phy_id;
	493	struct phy_driver *drv = NULL;
	494
	495	list_for_each(entry, &phy_drivers) {
	496	drv = list_entry(entry, struct phy_driver, list);
	497	if ((drv->uid & drv->mask) == (phy_id & drv->mask))
	498	return drv;
	499	}
	500
	501	/* If we made it here, there's no driver for this PHY */
	502	return generic_for_interface(interface);
	503	}
	504
	505	struct phy_device phy_device_create(struct mii_dev bus, int addr, int phy_id,
	506	phy_interface_t interface)
	507	{
	508	struct phy_device *dev;
	509
	510	/* We allocate the device, and initialize the
	511	* default values */
	512	dev = malloc(sizeof(*dev));
	513	if (!dev) {
	514	printf("Failed to allocate PHY device for %s:%d\n",
	515	bus->name, addr);
	516	return NULL;
	517	}
518
519	memset(dev, 0, sizeof(*dev));
520
521	dev->duplex = -1;
522	dev->link = 1;
523	dev->interface = interface;
524
525	dev->autoneg = AUTONEG_ENABLE;
526
527	dev->addr = addr;
528	dev->phy_id = phy_id;
529	dev->bus = bus;
530
531	dev->drv = get_phy_driver(dev, interface);
532
533	phy_probe(dev);
534
535	bus->phymap[addr] = dev;
536
537	return dev;
538	}
539
540	/**
541	* get_phy_id - reads the specified addr for its ID.
542	* @bus: the target MII bus
543	* @addr: PHY address on the MII bus
544	* @phy_id: where to store the ID retrieved.
545	*
546	* Description: Reads the ID registers of the PHY at @addr on the
547	* @bus, stores it in @phy_id and returns zero on success.
548	*/
549	int get_phy_id(struct mii_dev bus, int addr, int devad, u32 phy_id)
550	{
551	int phy_reg;
552
553	/* Grab the bits from PHYIR1, and put them
554	* in the upper half */
555	phy_reg = bus->read(bus, addr, devad, MII_PHYSID1);
556
557	if (phy_reg < 0)
558	return -EIO;
559
560	*phy_id = (phy_reg & 0xffff) << 16;
561
562	/* Grab the bits from PHYIR2, and put them in the lower half */
563	phy_reg = bus->read(bus, addr, devad, MII_PHYSID2);
564
565	if (phy_reg < 0)
566	return -EIO;
567
568	*phy_id \|= (phy_reg & 0xffff);
569
570	return 0;
571	}
572
573	/**
574	* get_phy_device - reads the specified PHY device and returns its @phy_device struct
575	* @bus: the target MII bus
576	* @addr: PHY address on the MII bus
577	*
578	* Description: Reads the ID registers of the PHY at @addr on the
579	* @bus, then allocates and returns the phy_device to represent it.
580	*/
581	struct phy_device get_phy_device(struct mii_dev bus, int addr,
582	phy_interface_t interface)
583	{
584	u32 phy_id = 0x1fffffff;
585	int i;
586	int r;
587
588	/* If we have one, return the existing device, with new interface */
589	if (bus->phymap[addr]) {
590	bus->phymap[addr]->interface = interface;
591
592	return bus->phymap[addr];
593	}
594
595	/* Try Standard (ie Clause 22) access */
596	r = get_phy_id(bus, addr, MDIO_DEVAD_NONE, &phy_id);
597	if (r)
598	return NULL;
599
600	/* If the PHY ID is mostly f's, we didn't find anything */
601	if ((phy_id & 0x1fffffff) != 0x1fffffff)
602	return phy_device_create(bus, addr, phy_id, interface);
603
604	/* Otherwise we have to try Clause 45 */
605	for (i = 1; i < 5; i++) {
606	r = get_phy_id(bus, addr, i, &phy_id);
607	if (r)
608	return NULL;
609
610	/* If the phy_id is mostly Fs, there is no device there */
611	if ((phy_id & 0x1fffffff) != 0x1fffffff)
612	break;
613	}
614
615	return phy_device_create(bus, addr, phy_id, interface);
616	}
617
618	int phy_reset(struct phy_device *phydev)
619	{
620	int reg;
621	int timeout = 500;
622	int devad = MDIO_DEVAD_NONE;
623
624	#ifdef CONFIG_PHYLIB_10G
625	/* If it's 10G, we need to issue reset through one of the MMDs */
626	if (is_10g_interface(phydev->interface)) {
627	if (!phydev->mmds)
628	gen10g_discover_mmds(phydev);
629
630	devad = ffs(phydev->mmds) - 1;
631	}
632	#endif
633
634	reg = phy_read(phydev, devad, MII_BMCR);
635	if (reg < 0) {
636	debug("PHY status read failed\n");
637	return -1;
638	}
639
640	reg \|= BMCR_RESET;
641
642	if (phy_write(phydev, devad, MII_BMCR, reg) < 0) {
643	debug("PHY reset failed\n");
644	return -1;
645	}
646
647	#ifdef CONFIG_PHY_RESET_DELAY
648	udelay(CONFIG_PHY_RESET_DELAY); /* Intel LXT971A needs this */
649	#endif
650	/*
651	* Poll the control register for the reset bit to go to 0 (it is
652	* auto-clearing). This should happen within 0.5 seconds per the
653	* IEEE spec.
654	*/
655	while ((reg & BMCR_RESET) && timeout--) {
656	reg = phy_read(phydev, devad, MII_BMCR);
657
658	if (reg < 0) {
659	debug("PHY status read failed\n");
660	return -1;
661	}
662	udelay(1000);
663	}
664
665	if (reg & BMCR_RESET) {
666	puts("PHY reset timed out\n");
667	return -1;
668	}
669
670	return 0;
671	}
672
673	int miiphy_reset(const char *devname, unsigned char addr)
674	{
675	struct mii_dev *bus = miiphy_get_dev_by_name(devname);
676	struct phy_device *phydev;
677
678	/*
679	* miiphy_reset was only used on standard PHYs, so we'll fake it here.
680	* If later code tries to connect with the right interface, this will
681	* be corrected by get_phy_device in phy_connect()
682	*/
683	phydev = get_phy_device(bus, addr, PHY_INTERFACE_MODE_MII);
684
685	return phy_reset(phydev);
686	}
687
688	struct phy_device phy_connect(struct mii_dev bus, int addr,
689	struct eth_device *dev,
690	phy_interface_t interface)
691	{
692	struct phy_device *phydev;
693
694	/* Reset the bus */
695	bus->reset(bus);
696
697	/* Wait 15ms to make sure the PHY has come out of hard reset */
698	udelay(15000);
699
700	phydev = get_phy_device(bus, addr, interface);
701
702	if (!phydev) {
703	printf("Could not get PHY for %s:%d\n", bus->name, addr);
704
705	return NULL;
706	}
707
708	/* Soft Reset the PHY */
709	phy_reset(phydev);
710
711	if (phydev->dev)
712	printf("%s:%d is connected to %s. Reconnecting to %s\n",
713	bus->name, addr, phydev->dev->name, dev->name);
714
715	phydev->dev = dev;
716
717	printf("%s connected to %s\n", dev->name, phydev->drv->name);
718
719	return phydev;
720	}
721
722	int phy_startup(struct phy_device *phydev)
723	{
724	if (phydev->drv->startup)
725	phydev->drv->startup(phydev);
726
727	return 0;
728	}
729
730	static int __board_phy_config(struct phy_device *phydev)
731	{
732	return 0;
733	}
734
735	int board_phy_config(struct phy_device *phydev)
736	__attribute__((weak, alias("__board_phy_config")));
737
738	int phy_config(struct phy_device *phydev)
739	{
740	if (phydev->drv->config)
741	phydev->drv->config(phydev);
742
743	/* Invoke an optional board-specific helper */
744	board_phy_config(phydev);
745
746	return 0;
747	}
748
749	int phy_shutdown(struct phy_device *phydev)
750	{
751	if (phydev->drv->shutdown)
752	phydev->drv->shutdown(phydev);
753
754	return 0;
755	}