[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>
#include <linux/err.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.
 */
static 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.
 */
static 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_ET1011C
	phy_et1011c_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_SMSC
	phy_smsc_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;
}

static 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;
}

static 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);
}

static 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.
 */
static 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;
}

static struct phy_device *create_phy_by_mask(struct mii_dev *bus,
		unsigned phy_mask, int devad, phy_interface_t interface)
{
	u32 phy_id = 0xffffffff;
	while (phy_mask) {
		int addr = ffs(phy_mask) - 1;
		int r = get_phy_id(bus, addr, devad, &phy_id);
		if (r < 0)
			return ERR_PTR(r);
		/* 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);
		phy_mask &= ~(1 << addr);
	}
	return NULL;
}

static struct phy_device *search_for_existing_phy(struct mii_dev *bus,
		unsigned phy_mask, phy_interface_t interface)
{
	/* If we have one, return the existing device, with new interface */
	while (phy_mask) {
		int addr = ffs(phy_mask) - 1;
		if (bus->phymap[addr]) {
			bus->phymap[addr]->interface = interface;
			return bus->phymap[addr];
		}
		phy_mask &= ~(1 << addr);
	}
	return NULL;
}

static struct phy_device *get_phy_device_by_mask(struct mii_dev *bus,
		unsigned phy_mask, phy_interface_t interface)
{
	int i;
	struct phy_device *phydev;

	phydev = search_for_existing_phy(bus, phy_mask, interface);
	if (phydev)
		return phydev;
	/* Try Standard (ie Clause 22) access */
	/* Otherwise we have to try Clause 45 */
	for (i = 0; i < 5; i++) {
		phydev = create_phy_by_mask(bus, phy_mask,
				i ? i : MDIO_DEVAD_NONE, interface);
		if (IS_ERR(phydev))
			return NULL;
		if (phydev)
			return phydev;
	}
	printf("Phy not found\n");
	return phy_device_create(bus, ffs(phy_mask) - 1, 0xffffffff, interface);
}

/**
 * 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.
 */
static struct phy_device *get_phy_device(struct mii_dev *bus, int addr,
					 phy_interface_t interface)
{
	return get_phy_device_by_mask(bus, 1 << addr, 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_find_by_mask(struct mii_dev *bus, unsigned phy_mask,
		phy_interface_t interface)
{
	/* Reset the bus */
	if (bus->reset)
		bus->reset(bus);

	/* Wait 15ms to make sure the PHY has come out of hard reset */
	udelay(15000);
	return get_phy_device_by_mask(bus, phy_mask, interface);
}

void phy_connect_dev(struct phy_device *phydev, struct eth_device *dev)
{
	/* Soft Reset the PHY */
	phy_reset(phydev);
	if (phydev->dev) {
		printf("%s:%d is connected to %s.  Reconnecting to %s\n",
				phydev->bus->name, phydev->addr,
				phydev->dev->name, dev->name);
	}
	phydev->dev = dev;
	debug("%s connected to %s\n", dev->name, phydev->drv->name);
}

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

	phydev = phy_find_by_mask(bus, 1 << addr, interface);
	if (phydev)
		phy_connect_dev(phydev, dev);
	else
		printf("Could not get PHY for %s: addr %d\n", bus->name, addr);
	return phydev;
}

/*
 * Start the PHY.  Returns 0 on success, or a negative error code.
 */
int phy_startup(struct phy_device *phydev)
{
	if (phydev->drv->startup)
		return phydev->drv->startup(phydev);

	return 0;
}

static int __board_phy_config(struct phy_device *phydev)
{
	if (phydev->drv->config)
		return phydev->drv->config(phydev);
	return 0;
}

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

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