/* * drivers/net/phy/phy_device.c * * Framework for finding and configuring PHYs. * Also contains generic PHY driver * * Author: Andy Fleming * * Copyright (c) 2004 Freescale Semiconductor, Inc. * * 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. * */#include <linux/config.h>#include <linux/kernel.h>#include <linux/sched.h>#include <linux/string.h>#include <linux/errno.h>#include <linux/unistd.h>#include <linux/slab.h>#include <linux/interrupt.h>#include <linux/init.h>#include <linux/delay.h>#include <linux/netdevice.h>#include <linux/etherdevice.h>#include <linux/skbuff.h>#include <linux/spinlock.h>#include <linux/mm.h>#include <linux/module.h>#include <linux/mii.h>#include <linux/ethtool.h>#include <linux/phy.h>#include <asm/io.h>#include <asm/irq.h>#include <asm/uaccess.h>MODULE_DESCRIPTION("PHY library");MODULE_AUTHOR("Andy Fleming");MODULE_LICENSE("GPL");static struct phy_driver genphy_driver;extern int mdio_bus_init(void);extern void mdio_bus_exit(void);/* get_phy_device * * 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_bus *bus, int addr){	int phy_reg;	u32 phy_id;	struct phy_device *dev = NULL;	/* Grab the bits from PHYIR1, and put them	 * in the upper half */	phy_reg = bus->read(bus, addr, MII_PHYSID1);	if (phy_reg < 0)		return ERR_PTR(phy_reg);	phy_id = (phy_reg & 0xffff) << 16;	/* Grab the bits from PHYIR2, and put them in the lower half */	phy_reg = bus->read(bus, addr, MII_PHYSID2);	if (phy_reg < 0)		return ERR_PTR(phy_reg);	phy_id |= (phy_reg & 0xffff);	/* If the phy_id is all Fs, there is no device there */	if (0xffffffff == phy_id)		return NULL;	/* Otherwise, we allocate the device, and initialize the	 * default values */	dev = kcalloc(1, sizeof(*dev), GFP_KERNEL);	if (NULL == dev)		return ERR_PTR(-ENOMEM);	dev->speed = 0;	dev->duplex = -1;	dev->pause = dev->asym_pause = 0;	dev->link = 1;	dev->autoneg = AUTONEG_ENABLE;	dev->addr = addr;	dev->phy_id = phy_id;	dev->bus = bus;	dev->state = PHY_DOWN;	spin_lock_init(&dev->lock);	return dev;}/* phy_prepare_link: * * description: Tells the PHY infrastructure to handle the *   gory details on monitoring link status (whether through *   polling or an interrupt), and to call back to the *   connected device driver when the link status changes. *   If you want to monitor your own link state, don't call *   this function */void phy_prepare_link(struct phy_device *phydev,		void (*handler)(struct net_device *)){	phydev->adjust_link = handler;}/* phy_connect: * * description: Convenience function for connecting ethernet *   devices to PHY devices.  The default behavior is for *   the PHY infrastructure to handle everything, and only notify *   the connected driver when the link status changes.  If you *   don't want, or can't use the provided functionality, you may *   choose to call only the subset of functions which provide *   the desired functionality. */struct phy_device * phy_connect(struct net_device *dev, const char *phy_id,		void (*handler)(struct net_device *), u32 flags){	struct phy_device *phydev;	phydev = phy_attach(dev, phy_id, flags);	if (IS_ERR(phydev))		return phydev;	phy_prepare_link(phydev, handler);	phy_start_machine(phydev, NULL);	if (phydev->irq > 0)		phy_start_interrupts(phydev);	return phydev;}EXPORT_SYMBOL(phy_connect);void phy_disconnect(struct phy_device *phydev){	if (phydev->irq > 0)		phy_stop_interrupts(phydev);	phy_stop_machine(phydev);		phydev->adjust_link = NULL;	phy_detach(phydev);}EXPORT_SYMBOL(phy_disconnect);/* phy_attach: * *   description: Called by drivers to attach to a particular PHY *     device. The phy_device is found, and properly hooked up *     to the phy_driver.  If no driver is attached, then the *     genphy_driver is used.  The phy_device is given a ptr to *     the attaching device, and given a callback for link status *     change.  The phy_device is returned to the attaching *     driver. */static int phy_compare_id(struct device *dev, void *data){	return strcmp((char *)data, dev->bus_id) ? 0 : 1;}struct phy_device *phy_attach(struct net_device *dev,		const char *phy_id, u32 flags){	struct bus_type *bus = &mdio_bus_type;	struct phy_device *phydev;	struct device *d;	/* Search the list of PHY devices on the mdio bus for the	 * PHY with the requested name */	d = bus_find_device(bus, NULL, (void *)phy_id, phy_compare_id);	if (d) {		phydev = to_phy_device(d);	} else {		printk(KERN_ERR "%s not found\n", phy_id);		return ERR_PTR(-ENODEV);	}	/* Assume that if there is no driver, that it doesn't	 * exist, and we should use the genphy driver. */	if (NULL == d->driver) {		int err;		down_write(&d->bus->subsys.rwsem);		d->driver = &genphy_driver.driver;		err = d->driver->probe(d);		if (err < 0)			return ERR_PTR(err);		device_bind_driver(d);		up_write(&d->bus->subsys.rwsem);	}	if (phydev->attached_dev) {		printk(KERN_ERR "%s: %s already attached\n",				dev->name, phy_id);		return ERR_PTR(-EBUSY);	}	phydev->attached_dev = dev;	phydev->dev_flags = flags;	return phydev;}EXPORT_SYMBOL(phy_attach);void phy_detach(struct phy_device *phydev){	phydev->attached_dev = NULL;	/* If the device had no specific driver before (i.e. - it	 * was using the generic driver), we unbind the device	 * from the generic driver so that there's a chance a	 * real driver could be loaded */	if (phydev->dev.driver == &genphy_driver.driver) {		down_write(&phydev->dev.bus->subsys.rwsem);		device_release_driver(&phydev->dev);		up_write(&phydev->dev.bus->subsys.rwsem);	}}EXPORT_SYMBOL(phy_detach);/* Generic PHY support and helper functions *//* genphy_config_advert * * description: Writes MII_ADVERTISE with the appropriate values, *   after sanitizing the values to make sure we only advertise *   what is supported */int genphy_config_advert(struct phy_device *phydev){	u32 advertise;	int adv;	int err;	/* Only allow advertising what	 * this PHY supports */	phydev->advertising &= phydev->supported;	advertise = phydev->advertising;	/* Setup standard advertisement */	adv = phy_read(phydev, 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;	err = phy_write(phydev, MII_ADVERTISE, adv);	if (err < 0)		return err;	/* Configure gigabit if it's supported */	if (phydev->supported & (SUPPORTED_1000baseT_Half |				SUPPORTED_1000baseT_Full)) {		adv = phy_read(phydev, 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;		err = phy_write(phydev, MII_CTRL1000, adv);		if (err < 0)			return err;	}	return adv;}EXPORT_SYMBOL(genphy_config_advert);/* genphy_setup_forced * * description: Configures MII_BMCR to force speed/duplex *   to the values in phydev. Assumes that the values are valid. *   Please see phy_sanitize_settings() */int genphy_setup_forced(struct phy_device *phydev){	int ctl = BMCR_RESET;	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;		ctl = phy_write(phydev, MII_BMCR, ctl);	if (ctl < 0)		return ctl;	/* We just reset the device, so we'd better configure any	 * settings the PHY requires to operate */	if (phydev->drv->config_init)		ctl = phydev->drv->config_init(phydev);	return ctl;}/* Enable and Restart Autonegotiation */int genphy_restart_aneg(struct phy_device *phydev){	int ctl;