/* * 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. * */ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <linux/kernel.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/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"); void phy_device_free(struct phy_device *phydev){	put_device(&phydev->dev);}EXPORT_SYMBOL(phy_device_free); static void phy_device_release(struct device *dev){	kfree(to_phy_device(dev));} static struct phy_driver genphy_driver;extern int mdio_bus_init(void);extern void mdio_bus_exit(void); static LIST_HEAD(phy_fixup_list);static DEFINE_MUTEX(phy_fixup_lock); static int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,			     u32 flags, phy_interface_t interface); /* * Creates a new phy_fixup and adds it to the list * @bus_id: A string which matches phydev->dev.bus_id (or PHY_ANY_ID) * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY) * 	It can also be PHY_ANY_UID * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before * 	comparison * @run: The actual code to be run when a matching PHY is found */int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,		int (*run)(struct phy_device *)){	struct phy_fixup *fixup; 	fixup = kzalloc(sizeof(struct phy_fixup), GFP_KERNEL);	if (!fixup)		return -ENOMEM; 	strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));	fixup->phy_uid = phy_uid;	fixup->phy_uid_mask = phy_uid_mask;	fixup->run = run; 	mutex_lock(&phy_fixup_lock);	list_add_tail(&fixup->list, &phy_fixup_list);	mutex_unlock(&phy_fixup_lock); 	return 0;}EXPORT_SYMBOL(phy_register_fixup); /* Registers a fixup to be run on any PHY with the UID in phy_uid */int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,		int (*run)(struct phy_device *)){	return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);}EXPORT_SYMBOL(phy_register_fixup_for_uid); /* Registers a fixup to be run on the PHY with id string bus_id */int phy_register_fixup_for_id(const char *bus_id,		int (*run)(struct phy_device *)){	return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);}EXPORT_SYMBOL(phy_register_fixup_for_id); /* * Returns 1 if fixup matches phydev in bus_id and phy_uid. * Fixups can be set to match any in one or more fields. */static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup){	if (strcmp(fixup->bus_id, dev_name(&phydev->dev)) != 0)		if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)			return 0; 	if ((fixup->phy_uid & fixup->phy_uid_mask) !=			(phydev->phy_id & fixup->phy_uid_mask))		if (fixup->phy_uid != PHY_ANY_UID)			return 0; 	return 1;} /* Runs any matching fixups for this phydev */int phy_scan_fixups(struct phy_device *phydev){	struct phy_fixup *fixup; 	mutex_lock(&phy_fixup_lock);	list_for_each_entry(fixup, &phy_fixup_list, list) {		if (phy_needs_fixup(phydev, fixup)) {			int err; 			err = fixup->run(phydev); 			if (err < 0) {				mutex_unlock(&phy_fixup_lock);				return err;			}		}	}	mutex_unlock(&phy_fixup_lock); 	return 0;}EXPORT_SYMBOL(phy_scan_fixups); struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,			bool is_c45, struct phy_c45_device_ids *c45_ids){	struct phy_device *dev; 	/* We allocate the device, and initialize the	 * default values */	dev = kzalloc(sizeof(*dev), GFP_KERNEL); 	if (NULL == dev)		return (struct phy_device*) PTR_ERR((void*)-ENOMEM); 	dev->dev.release = phy_device_release; 	dev->speed = 0;	dev->duplex = -1;	dev->pause = dev->asym_pause = 0;	dev->link = 1;	dev->interface = PHY_INTERFACE_MODE_GMII; 	dev->autoneg = AUTONEG_ENABLE; 	dev->is_c45 = is_c45;	dev->addr = addr;	dev->phy_id = phy_id;	if (c45_ids)		dev->c45_ids = *c45_ids;	dev->bus = bus;	dev->dev.parent = bus->parent;	dev->dev.bus = &mdio_bus_type;	dev->irq = bus->irq != NULL ? bus->irq[addr] : PHY_POLL;	dev_set_name(&dev->dev, PHY_ID_FMT, bus->id, addr); 	dev->state = PHY_DOWN; 	mutex_init(&dev->lock);	INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);	INIT_WORK(&dev->phy_queue, phy_change); 	/* Request the appropriate module unconditionally; don't	   bother trying to do so only if it isn't already loaded,	   because that gets complicated. A hotplug event would have	   done an unconditional modprobe anyway.	   We don't do normal hotplug because it won't work for MDIO	   -- because it relies on the device staying around for long	   enough for the driver to get loaded. With MDIO, the NIC	   driver will get bored and give up as soon as it finds that	   there's no driver _already_ loaded. */	request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT, MDIO_ID_ARGS(phy_id)); 	device_initialize(&dev->dev); 	return dev;}EXPORT_SYMBOL(phy_device_create); /** * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs. * @bus: the target MII bus * @addr: PHY address on the MII bus * @phy_id: where to store the ID retrieved. * @c45_ids: where to store the c45 ID information. * *   If the PHY devices-in-package appears to be valid, it and the *   corresponding identifiers are stored in @c45_ids, zero is stored *   in @phy_id.  Otherwise 0xffffffff is stored in @phy_id.  Returns *   zero on success. * */static int get_phy_c45_ids(struct mii_bus *bus, int addr, u32 *phy_id,			   struct phy_c45_device_ids *c45_ids) {	int phy_reg;	int i, reg_addr;	const int num_ids = ARRAY_SIZE(c45_ids->device_ids); 	/* Find first non-zero Devices In package.  Device	 * zero is reserved, so don't probe it.	 */	for (i = 1;	     i < num_ids && c45_ids->devices_in_package == 0;	     i++) {		reg_addr = MII_ADDR_C45 | i << 16 | 6;		phy_reg = mdiobus_read(bus, addr, reg_addr);		if (phy_reg < 0)			return -EIO;		c45_ids->devices_in_package = (phy_reg & 0xffff) << 16; 		reg_addr = MII_ADDR_C45 | i << 16 | 5;		phy_reg = mdiobus_read(bus, addr, reg_addr);		if (phy_reg < 0)			return -EIO;		c45_ids->devices_in_package |= (phy_reg & 0xffff); 		/* If mostly Fs, there is no device there,		 * let's get out of here.		 */		if ((c45_ids->devices_in_package & 0x1fffffff) == 0x1fffffff) {			*phy_id = 0xffffffff;			return 0;		}	} 	/* Now probe Device Identifiers for each device present. */	for (i = 1; i < num_ids; i++) {		if (!(c45_ids->devices_in_package & (1 << i)))			continue; 		reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID1;		phy_reg = mdiobus_read(bus, addr, reg_addr);		if (phy_reg < 0)			return -EIO;		c45_ids->device_ids[i] = (phy_reg & 0xffff) << 16; 		reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID2;		phy_reg = mdiobus_read(bus, addr, reg_addr);		if (phy_reg < 0)			return -EIO;		c45_ids->device_ids[i] |= (phy_reg & 0xffff);	}	*phy_id = 0;	return 0;} /** * 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. * @is_c45: If true the PHY uses the 802.3 clause 45 protocol * @c45_ids: where to store the c45 ID information. * * Description: In the case of a 802.3-c22 PHY, reads the ID registers *   of the PHY at @addr on the @bus, stores it in @phy_id and returns *   zero on success. * *   In the case of a 802.3-c45 PHY, get_phy_c45_ids() is invoked, and *   its return value is in turn returned. * */static int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id,		      bool is_c45, struct phy_c45_device_ids *c45_ids){	int phy_reg; 	if (is_c45)		return get_phy_c45_ids(bus, addr, phy_id, c45_ids); 	/* Grab the bits from PHYIR1, and put them	 * in the upper half */	phy_reg = mdiobus_read(bus, addr, 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 = mdiobus_read(bus, addr, 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 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol * * 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, bool is_c45){	struct phy_c45_device_ids c45_ids = {0};	struct phy_device *dev = NULL;	u32 phy_id = 0;	int r; 	r = get_phy_id(bus, addr, &phy_id, is_c45, &c45_ids);	if (r)		return ERR_PTR(r); 	/* If the phy_id is mostly Fs, there is no device there */	if ((phy_id & 0x1fffffff) == 0x1fffffff)		return NULL; 	dev = phy_device_create(bus, addr, phy_id, is_c45, &c45_ids); 	return dev;}EXPORT_SYMBOL(get_phy_device); /** * phy_device_register - Register the phy device on the MDIO bus * @phydev: phy_device structure to be added to the MDIO bus */int phy_device_register(struct phy_device *phydev){	int err; 	/* Don't register a phy if one is already registered at this	 * address */	if (phydev->bus->phy_map[phydev->addr])		return -EINVAL;	phydev->bus->phy_map[phydev->addr] = phydev; 	/* Run all of the fixups for this PHY */	phy_scan_fixups(phydev); 	err = device_add(&phydev->dev);	if (err) {		pr_err("PHY %d failed to add\n", phydev->addr);		goto out;	} 	return 0;  out:	phydev->bus->phy_map[phydev->addr] = NULL;	return err;}EXPORT_SYMBOL(phy_device_register); /** * phy_find_first - finds the first PHY device on the bus * @bus: the target MII bus */struct phy_device *phy_find_first(struct mii_bus *bus){	int addr; 	for (addr = 0; addr < PHY_MAX_ADDR; addr++) {		if (bus->phy_map[addr])			return bus->phy_map[addr];	}	return NULL;}EXPORT_SYMBOL(phy_find_first); /** * phy_prepare_link - prepares the PHY layer to monitor link status * @phydev: target phy_device struct * @handler: callback function for link status change notifications * * 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. */static void phy_prepare_link(struct phy_device *phydev,		void (*handler)(struct net_device *)){	phydev->adjust_link = handler;} /** * phy_connect_direct - connect an ethernet device to a specific phy_device * @dev: the network device to connect * @phydev: the pointer to the phy device * @handler: callback function for state change notifications * @interface: PHY device's interface */int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,		       void (*handler)(struct net_device *),		       phy_interface_t interface){	int rc; 	rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);	if (rc)		return rc; 	phy_prepare_link(phydev, handler);	phy_start_machine(phydev, NULL);	if (phydev->irq > 0)		phy_start_interrupts(phydev); 	return 0;}EXPORT_SYMBOL(phy_connect_direct); /** * phy_connect - connect an ethernet device to a PHY device * @dev: the network device to connect * @bus_id: the id string of the PHY device to connect * @handler: callback function for state change notifications * @interface: PHY device's interface * * 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 *bus_id,		void (*handler)(struct net_device *),		phy_interface_t interface){	struct phy_device *phydev;	struct device *d;	int rc; 	/* Search the list of PHY devices on the mdio bus for the	 * PHY with the requested name */	d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);	if (!d) {		pr_err("PHY %s not found\n", bus_id);		return ERR_PTR(-ENODEV);	}	phydev = to_phy_device(d); 	rc = phy_connect_direct(dev, phydev, handler, interface);	if (rc)		return ERR_PTR(rc); 	return phydev;}EXPORT_SYMBOL(phy_connect); /** * phy_disconnect - disable interrupts, stop state machine, and detach a PHY device * @phydev: target phy_device struct */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); int phy_init_hw(struct phy_device *phydev)

Lines 1–500 of 1154. Load more