[mirror_ubuntu-artful-kernel.git] / drivers / net / ethernet / broadcom / genet / bcmmii.c

/*
 * Broadcom GENET MDIO routines
 *
 * Copyright (c) 2014-2017 Broadcom
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */


#include <linux/types.h>
#include <linux/delay.h>
#include <linux/wait.h>
#include <linux/mii.h>
#include <linux/ethtool.h>
#include <linux/bitops.h>
#include <linux/netdevice.h>
#include <linux/platform_device.h>
#include <linux/phy.h>
#include <linux/phy_fixed.h>
#include <linux/brcmphy.h>
#include <linux/of.h>
#include <linux/of_net.h>
#include <linux/of_mdio.h>
#include <linux/platform_data/bcmgenet.h>

#include "bcmgenet.h"

/* read a value from the MII */
static int bcmgenet_mii_read(struct mii_bus *bus, int phy_id, int location)
{
	int ret;
	struct net_device *dev = bus->priv;
	struct bcmgenet_priv *priv = netdev_priv(dev);
	u32 reg;

	bcmgenet_umac_writel(priv, (MDIO_RD | (phy_id << MDIO_PMD_SHIFT) |
			     (location << MDIO_REG_SHIFT)), UMAC_MDIO_CMD);
	/* Start MDIO transaction*/
	reg = bcmgenet_umac_readl(priv, UMAC_MDIO_CMD);
	reg |= MDIO_START_BUSY;
	bcmgenet_umac_writel(priv, reg, UMAC_MDIO_CMD);
	wait_event_timeout(priv->wq,
			   !(bcmgenet_umac_readl(priv, UMAC_MDIO_CMD)
			   & MDIO_START_BUSY),
			   HZ / 100);
	ret = bcmgenet_umac_readl(priv, UMAC_MDIO_CMD);

	/* Some broken devices are known not to release the line during
	 * turn-around, e.g: Broadcom BCM53125 external switches, so check for
	 * that condition here and ignore the MDIO controller read failure
	 * indication.
	 */
	if (!(bus->phy_ignore_ta_mask & 1 << phy_id) && (ret & MDIO_READ_FAIL))
		return -EIO;

	return ret & 0xffff;
}

/* write a value to the MII */
static int bcmgenet_mii_write(struct mii_bus *bus, int phy_id,
			      int location, u16 val)
{
	struct net_device *dev = bus->priv;
	struct bcmgenet_priv *priv = netdev_priv(dev);
	u32 reg;

	bcmgenet_umac_writel(priv, (MDIO_WR | (phy_id << MDIO_PMD_SHIFT) |
			     (location << MDIO_REG_SHIFT) | (0xffff & val)),
			     UMAC_MDIO_CMD);
	reg = bcmgenet_umac_readl(priv, UMAC_MDIO_CMD);
	reg |= MDIO_START_BUSY;
	bcmgenet_umac_writel(priv, reg, UMAC_MDIO_CMD);
	wait_event_timeout(priv->wq,
			   !(bcmgenet_umac_readl(priv, UMAC_MDIO_CMD) &
			   MDIO_START_BUSY),
			   HZ / 100);

	return 0;
}

/* setup netdev link state when PHY link status change and
 * update UMAC and RGMII block when link up
 */
void bcmgenet_mii_setup(struct net_device *dev)
{
	struct bcmgenet_priv *priv = netdev_priv(dev);
	struct phy_device *phydev = priv->phydev;
	u32 reg, cmd_bits = 0;
	bool status_changed = false;

	if (priv->old_link != phydev->link) {
		status_changed = true;
		priv->old_link = phydev->link;
	}

	if (phydev->link) {
		/* check speed/duplex/pause changes */
		if (priv->old_speed != phydev->speed) {
			status_changed = true;
			priv->old_speed = phydev->speed;
		}

		if (priv->old_duplex != phydev->duplex) {
			status_changed = true;
			priv->old_duplex = phydev->duplex;
		}

		if (priv->old_pause != phydev->pause) {
			status_changed = true;
			priv->old_pause = phydev->pause;
		}

		/* done if nothing has changed */
		if (!status_changed)
			return;

		/* speed */
		if (phydev->speed == SPEED_1000)
			cmd_bits = UMAC_SPEED_1000;
		else if (phydev->speed == SPEED_100)
			cmd_bits = UMAC_SPEED_100;
		else
			cmd_bits = UMAC_SPEED_10;
		cmd_bits <<= CMD_SPEED_SHIFT;

		/* duplex */
		if (phydev->duplex != DUPLEX_FULL)
			cmd_bits |= CMD_HD_EN;

		/* pause capability */
		if (!phydev->pause)
			cmd_bits |= CMD_RX_PAUSE_IGNORE | CMD_TX_PAUSE_IGNORE;

		/*
		 * Program UMAC and RGMII block based on established
		 * link speed, duplex, and pause. The speed set in
		 * umac->cmd tell RGMII block which clock to use for
		 * transmit -- 25MHz(100Mbps) or 125MHz(1Gbps).
		 * Receive clock is provided by the PHY.
		 */
		reg = bcmgenet_ext_readl(priv, EXT_RGMII_OOB_CTRL);
		reg &= ~OOB_DISABLE;
		reg |= RGMII_LINK;
		bcmgenet_ext_writel(priv, reg, EXT_RGMII_OOB_CTRL);

		reg = bcmgenet_umac_readl(priv, UMAC_CMD);
		reg &= ~((CMD_SPEED_MASK << CMD_SPEED_SHIFT) |
			       CMD_HD_EN |
			       CMD_RX_PAUSE_IGNORE | CMD_TX_PAUSE_IGNORE);
		reg |= cmd_bits;
		bcmgenet_umac_writel(priv, reg, UMAC_CMD);
	} else {
		/* done if nothing has changed */
		if (!status_changed)
			return;

		/* needed for MoCA fixed PHY to reflect correct link status */
		netif_carrier_off(dev);
	}

	phy_print_status(phydev);
}


static int bcmgenet_fixed_phy_link_update(struct net_device *dev,
					  struct fixed_phy_status *status)
{
	if (dev && dev->phydev && status)
		status->link = dev->phydev->link;

	return 0;
}

/* Perform a voluntary PHY software reset, since the EPHY is very finicky about
 * not doing it and will start corrupting packets
 */
void bcmgenet_mii_reset(struct net_device *dev)
{
	struct bcmgenet_priv *priv = netdev_priv(dev);

	if (GENET_IS_V4(priv))
		return;

	if (priv->phydev) {
		phy_init_hw(priv->phydev);
		phy_start_aneg(priv->phydev);
	}
}

void bcmgenet_phy_power_set(struct net_device *dev, bool enable)
{
	struct bcmgenet_priv *priv = netdev_priv(dev);
	u32 reg = 0;

	/* EXT_GPHY_CTRL is only valid for GENETv4 and onward */
	if (GENET_IS_V4(priv)) {
		reg = bcmgenet_ext_readl(priv, EXT_GPHY_CTRL);
		if (enable) {
			reg &= ~EXT_CK25_DIS;
			bcmgenet_ext_writel(priv, reg, EXT_GPHY_CTRL);
			mdelay(1);

			reg &= ~(EXT_CFG_IDDQ_BIAS | EXT_CFG_PWR_DOWN);
			reg |= EXT_GPHY_RESET;
			bcmgenet_ext_writel(priv, reg, EXT_GPHY_CTRL);
			mdelay(1);

			reg &= ~EXT_GPHY_RESET;
		} else {
			reg |= EXT_CFG_IDDQ_BIAS | EXT_CFG_PWR_DOWN |
			       EXT_GPHY_RESET;
			bcmgenet_ext_writel(priv, reg, EXT_GPHY_CTRL);
			mdelay(1);
			reg |= EXT_CK25_DIS;
		}
		bcmgenet_ext_writel(priv, reg, EXT_GPHY_CTRL);
		udelay(60);
	} else {
		mdelay(1);
	}
}

static void bcmgenet_moca_phy_setup(struct bcmgenet_priv *priv)
{
	u32 reg;

	if (!GENET_IS_V5(priv)) {
		/* Speed settings are set in bcmgenet_mii_setup() */
		reg = bcmgenet_sys_readl(priv, SYS_PORT_CTRL);
		reg |= LED_ACT_SOURCE_MAC;
		bcmgenet_sys_writel(priv, reg, SYS_PORT_CTRL);
	}

	if (priv->hw_params->flags & GENET_HAS_MOCA_LINK_DET)
		fixed_phy_set_link_update(priv->phydev,
					  bcmgenet_fixed_phy_link_update);
}

int bcmgenet_mii_config(struct net_device *dev, bool init)
{
	struct bcmgenet_priv *priv = netdev_priv(dev);
	struct phy_device *phydev = priv->phydev;
	struct device *kdev = &priv->pdev->dev;
	const char *phy_name = NULL;
	u32 id_mode_dis = 0;
	u32 port_ctrl;
	u32 reg;

	priv->ext_phy = !priv->internal_phy &&
			(priv->phy_interface != PHY_INTERFACE_MODE_MOCA);

	switch (priv->phy_interface) {
	case PHY_INTERFACE_MODE_INTERNAL:
	case PHY_INTERFACE_MODE_MOCA:
		/* Irrespective of the actually configured PHY speed (100 or
		 * 1000) GENETv4 only has an internal GPHY so we will just end
		 * up masking the Gigabit features from what we support, not
		 * switching to the EPHY
		 */
		if (GENET_IS_V4(priv))
			port_ctrl = PORT_MODE_INT_GPHY;
		else
			port_ctrl = PORT_MODE_INT_EPHY;

		bcmgenet_sys_writel(priv, port_ctrl, SYS_PORT_CTRL);

		if (priv->internal_phy) {
			phy_name = "internal PHY";
		} else if (priv->phy_interface == PHY_INTERFACE_MODE_MOCA) {
			phy_name = "MoCA";
			bcmgenet_moca_phy_setup(priv);
		}
		break;

	case PHY_INTERFACE_MODE_MII:
		phy_name = "external MII";
		phydev->supported &= PHY_BASIC_FEATURES;
		bcmgenet_sys_writel(priv,
				    PORT_MODE_EXT_EPHY, SYS_PORT_CTRL);
		break;

	case PHY_INTERFACE_MODE_REVMII:
		phy_name = "external RvMII";
		/* of_mdiobus_register took care of reading the 'max-speed'
		 * PHY property for us, effectively limiting the PHY supported
		 * capabilities, use that knowledge to also configure the
		 * Reverse MII interface correctly.
		 */
		if ((priv->phydev->supported & PHY_BASIC_FEATURES) ==
				PHY_BASIC_FEATURES)
			port_ctrl = PORT_MODE_EXT_RVMII_25;
		else
			port_ctrl = PORT_MODE_EXT_RVMII_50;
		bcmgenet_sys_writel(priv, port_ctrl, SYS_PORT_CTRL);
		break;

	case PHY_INTERFACE_MODE_RGMII:
		/* RGMII_NO_ID: TXC transitions at the same time as TXD
		 *		(requires PCB or receiver-side delay)
		 * RGMII:	Add 2ns delay on TXC (90 degree shift)
		 *
		 * ID is implicitly disabled for 100Mbps (RG)MII operation.
		 */
		id_mode_dis = BIT(16);
		/* fall through */
	case PHY_INTERFACE_MODE_RGMII_TXID:
		if (id_mode_dis)
			phy_name = "external RGMII (no delay)";
		else
			phy_name = "external RGMII (TX delay)";
		bcmgenet_sys_writel(priv,
				    PORT_MODE_EXT_GPHY, SYS_PORT_CTRL);
		break;
	default:
		dev_err(kdev, "unknown phy mode: %d\n", priv->phy_interface);
		return -EINVAL;
	}

	/* This is an external PHY (xMII), so we need to enable the RGMII
	 * block for the interface to work
	 */
	if (priv->ext_phy) {
		reg = bcmgenet_ext_readl(priv, EXT_RGMII_OOB_CTRL);
		reg |= RGMII_MODE_EN | id_mode_dis;
		bcmgenet_ext_writel(priv, reg, EXT_RGMII_OOB_CTRL);
	}

	if (init)
		dev_info(kdev, "configuring instance for %s\n", phy_name);

	return 0;
}

int bcmgenet_mii_probe(struct net_device *dev)
{
	struct bcmgenet_priv *priv = netdev_priv(dev);
	struct device_node *dn = priv->pdev->dev.of_node;
	struct phy_device *phydev;
	u32 phy_flags;
	int ret;

	/* Communicate the integrated PHY revision */
	phy_flags = priv->gphy_rev;

	/* Initialize link state variables that bcmgenet_mii_setup() uses */
	priv->old_link = -1;
	priv->old_speed = -1;
	priv->old_duplex = -1;
	priv->old_pause = -1;

	if (dn) {
		phydev = of_phy_connect(dev, priv->phy_dn, bcmgenet_mii_setup,
					phy_flags, priv->phy_interface);
		if (!phydev) {
			pr_err("could not attach to PHY\n");
			return -ENODEV;
		}
	} else {
		phydev = priv->phydev;
		phydev->dev_flags = phy_flags;

		ret = phy_connect_direct(dev, phydev, bcmgenet_mii_setup,
					 priv->phy_interface);
		if (ret) {
			pr_err("could not attach to PHY\n");
			return -ENODEV;
		}
	}

	priv->phydev = phydev;

	/* Configure port multiplexer based on what the probed PHY device since
	 * reading the 'max-speed' property determines the maximum supported
	 * PHY speed which is needed for bcmgenet_mii_config() to configure
	 * things appropriately.
	 */
	ret = bcmgenet_mii_config(dev, true);
	if (ret) {
		phy_disconnect(priv->phydev);
		return ret;
	}

	phydev->advertising = phydev->supported;

	/* The internal PHY has its link interrupts routed to the
	 * Ethernet MAC ISRs
	 */
	if (priv->internal_phy)
		priv->phydev->irq = PHY_IGNORE_INTERRUPT;

	return 0;
}

/* Workaround for integrated BCM7xxx Gigabit PHYs which have a problem with
 * their internal MDIO management controller making them fail to successfully
 * be read from or written to for the first transaction.  We insert a dummy
 * BMSR read here to make sure that phy_get_device() and get_phy_id() can
 * correctly read the PHY MII_PHYSID1/2 registers and successfully register a
 * PHY device for this peripheral.
 *
 * Once the PHY driver is registered, we can workaround subsequent reads from
 * there (e.g: during system-wide power management).
 *
 * bus->reset is invoked before mdiobus_scan during mdiobus_register and is
 * therefore the right location to stick that workaround. Since we do not want
 * to read from non-existing PHYs, we either use bus->phy_mask or do a manual
 * Device Tree scan to limit the search area.
 */
static int bcmgenet_mii_bus_reset(struct mii_bus *bus)
{
	struct net_device *dev = bus->priv;
	struct bcmgenet_priv *priv = netdev_priv(dev);
	struct device_node *np = priv->mdio_dn;
	struct device_node *child = NULL;
	u32 read_mask = 0;
	int addr = 0;

	if (!np) {
		read_mask = 1 << priv->phy_addr;
	} else {
		for_each_available_child_of_node(np, child) {
			addr = of_mdio_parse_addr(&dev->dev, child);
			if (addr < 0)
				continue;

			read_mask |= 1 << addr;
		}
	}

	for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
		if (read_mask & 1 << addr) {
			dev_dbg(&dev->dev, "Workaround for PHY @ %d\n", addr);
			mdiobus_read(bus, addr, MII_BMSR);
		}
	}

	return 0;
}

static int bcmgenet_mii_alloc(struct bcmgenet_priv *priv)
{
	struct mii_bus *bus;

	if (priv->mii_bus)
		return 0;

	priv->mii_bus = mdiobus_alloc();
	if (!priv->mii_bus) {
		pr_err("failed to allocate\n");
		return -ENOMEM;
	}

	bus = priv->mii_bus;
	bus->priv = priv->dev;
	bus->name = "bcmgenet MII bus";
	bus->parent = &priv->pdev->dev;
	bus->read = bcmgenet_mii_read;
	bus->write = bcmgenet_mii_write;
	bus->reset = bcmgenet_mii_bus_reset;
	snprintf(bus->id, MII_BUS_ID_SIZE, "%s-%d",
		 priv->pdev->name, priv->pdev->id);

	return 0;
}

static int bcmgenet_mii_of_init(struct bcmgenet_priv *priv)
{
	struct device_node *dn = priv->pdev->dev.of_node;
	struct device *kdev = &priv->pdev->dev;
	struct phy_device *phydev = NULL;
	char *compat;
	int phy_mode;
	int ret;

	compat = kasprintf(GFP_KERNEL, "brcm,genet-mdio-v%d", priv->version);
	if (!compat)
		return -ENOMEM;

	priv->mdio_dn = of_find_compatible_node(dn, NULL, compat);
	kfree(compat);
	if (!priv->mdio_dn) {
		dev_err(kdev, "unable to find MDIO bus node\n");
		return -ENODEV;
	}

	ret = of_mdiobus_register(priv->mii_bus, priv->mdio_dn);
	if (ret) {
		dev_err(kdev, "failed to register MDIO bus\n");
		return ret;
	}

	/* Fetch the PHY phandle */
	priv->phy_dn = of_parse_phandle(dn, "phy-handle", 0);

	/* In the case of a fixed PHY, the DT node associated
	 * to the PHY is the Ethernet MAC DT node.
	 */
	if (!priv->phy_dn && of_phy_is_fixed_link(dn)) {
		ret = of_phy_register_fixed_link(dn);
		if (ret)
			return ret;

		priv->phy_dn = of_node_get(dn);
	}

	/* Get the link mode */
	phy_mode = of_get_phy_mode(dn);
	if (phy_mode < 0) {
		dev_err(kdev, "invalid PHY mode property\n");
		return phy_mode;
	}

	priv->phy_interface = phy_mode;

	/* We need to specifically look up whether this PHY interface is internal
	 * or not *before* we even try to probe the PHY driver over MDIO as we
	 * may have shut down the internal PHY for power saving purposes.
	 */
	if (priv->phy_interface == PHY_INTERFACE_MODE_INTERNAL)
		priv->internal_phy = true;

	/* Make sure we initialize MoCA PHYs with a link down */
	if (phy_mode == PHY_INTERFACE_MODE_MOCA) {
		phydev = of_phy_find_device(dn);
		if (phydev) {
			phydev->link = 0;
			put_device(&phydev->mdio.dev);
		}
	}

	return 0;
}

static int bcmgenet_mii_pd_init(struct bcmgenet_priv *priv)
{
	struct device *kdev = &priv->pdev->dev;
	struct bcmgenet_platform_data *pd = kdev->platform_data;
	struct mii_bus *mdio = priv->mii_bus;
	struct phy_device *phydev;
	int ret;

	if (pd->phy_interface != PHY_INTERFACE_MODE_MOCA && pd->mdio_enabled) {
		/*
		 * Internal or external PHY with MDIO access
		 */
		if (pd->phy_address >= 0 && pd->phy_address < PHY_MAX_ADDR)
			mdio->phy_mask = ~(1 << pd->phy_address);
		else
			mdio->phy_mask = 0;

		ret = mdiobus_register(mdio);
		if (ret) {
			dev_err(kdev, "failed to register MDIO bus\n");
			return ret;
		}

		if (pd->phy_address >= 0 && pd->phy_address < PHY_MAX_ADDR)
			phydev = mdiobus_get_phy(mdio, pd->phy_address);
		else
			phydev = phy_find_first(mdio);

		if (!phydev) {
			dev_err(kdev, "failed to register PHY device\n");
			mdiobus_unregister(mdio);
			return -ENODEV;
		}
	} else {
		/*
		 * MoCA port or no MDIO access.
		 * Use fixed PHY to represent the link layer.
		 */
		struct fixed_phy_status fphy_status = {
			.link = 1,
			.speed = pd->phy_speed,
			.duplex = pd->phy_duplex,
			.pause = 0,
			.asym_pause = 0,
		};

		phydev = fixed_phy_register(PHY_POLL, &fphy_status, -1, NULL);
		if (!phydev || IS_ERR(phydev)) {
			dev_err(kdev, "failed to register fixed PHY device\n");
			return -ENODEV;
		}

		/* Make sure we initialize MoCA PHYs with a link down */
		phydev->link = 0;

	}

	priv->phydev = phydev;
	priv->phy_interface = pd->phy_interface;

	return 0;
}

static int bcmgenet_mii_bus_init(struct bcmgenet_priv *priv)
{
	struct device_node *dn = priv->pdev->dev.of_node;

	if (dn)
		return bcmgenet_mii_of_init(priv);
	else
		return bcmgenet_mii_pd_init(priv);
}

int bcmgenet_mii_init(struct net_device *dev)
{
	struct bcmgenet_priv *priv = netdev_priv(dev);
	struct device_node *dn = priv->pdev->dev.of_node;
	int ret;

	ret = bcmgenet_mii_alloc(priv);
	if (ret)
		return ret;

	ret = bcmgenet_mii_bus_init(priv);
	if (ret)
		goto out;

	return 0;

out:
	if (of_phy_is_fixed_link(dn))
		of_phy_deregister_fixed_link(dn);
	of_node_put(priv->phy_dn);
	mdiobus_unregister(priv->mii_bus);
	mdiobus_free(priv->mii_bus);
	return ret;
}

void bcmgenet_mii_exit(struct net_device *dev)
{
	struct bcmgenet_priv *priv = netdev_priv(dev);
	struct device_node *dn = priv->pdev->dev.of_node;

	if (of_phy_is_fixed_link(dn))
		of_phy_deregister_fixed_link(dn);
	of_node_put(priv->phy_dn);
	mdiobus_unregister(priv->mii_bus);
	mdiobus_free(priv->mii_bus);
}
Commit	Line	Data
aa09677c FF	1	/*
	2	* Broadcom GENET MDIO routines
	3	*
42138085	4	* Copyright (c) 2014-2017 Broadcom
aa09677c FF	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
aa09677c FF	9	*/
	10
	11
	12	#include <linux/types.h>
	13	#include <linux/delay.h>
	14	#include <linux/wait.h>
	15	#include <linux/mii.h>
	16	#include <linux/ethtool.h>
	17	#include <linux/bitops.h>
	18	#include <linux/netdevice.h>
	19	#include <linux/platform_device.h>
	20	#include <linux/phy.h>
	21	#include <linux/phy_fixed.h>
	22	#include <linux/brcmphy.h>
	23	#include <linux/of.h>
	24	#include <linux/of_net.h>
	25	#include <linux/of_mdio.h>
b0ba512e	26	#include <linux/platform_data/bcmgenet.h>
aa09677c FF	27
	28	#include "bcmgenet.h"
	29
	30	/* read a value from the MII */
	31	static int bcmgenet_mii_read(struct mii_bus *bus, int phy_id, int location)
	32	{
	33	int ret;
	34	struct net_device *dev = bus->priv;
	35	struct bcmgenet_priv *priv = netdev_priv(dev);
	36	u32 reg;
	37
	38	bcmgenet_umac_writel(priv, (MDIO_RD \| (phy_id << MDIO_PMD_SHIFT) \|
c91b7f66	39	(location << MDIO_REG_SHIFT)), UMAC_MDIO_CMD);
aa09677c FF	40	/* Start MDIO transaction*/
	41	reg = bcmgenet_umac_readl(priv, UMAC_MDIO_CMD);
	42	reg \|= MDIO_START_BUSY;
	43	bcmgenet_umac_writel(priv, reg, UMAC_MDIO_CMD);
	44	wait_event_timeout(priv->wq,
c91b7f66 FF	45	!(bcmgenet_umac_readl(priv, UMAC_MDIO_CMD)
	46	& MDIO_START_BUSY),
	47	HZ / 100);
aa09677c FF	48	ret = bcmgenet_umac_readl(priv, UMAC_MDIO_CMD);
aa09677c FF	49
9d3366e9 FF	50	/* Some broken devices are known not to release the line during
	51	* turn-around, e.g: Broadcom BCM53125 external switches, so check for
	52	* that condition here and ignore the MDIO controller read failure
	53	* indication.
	54	*/
	55	if (!(bus->phy_ignore_ta_mask & 1 << phy_id) && (ret & MDIO_READ_FAIL))
aa09677c FF	56	return -EIO;
	57
	58	return ret & 0xffff;
	59	}
	60
	61	/* write a value to the MII */
	62	static int bcmgenet_mii_write(struct mii_bus *bus, int phy_id,
c91b7f66	63	int location, u16 val)
aa09677c FF	64	{
	65	struct net_device *dev = bus->priv;
	66	struct bcmgenet_priv *priv = netdev_priv(dev);
	67	u32 reg;
	68
	69	bcmgenet_umac_writel(priv, (MDIO_WR \| (phy_id << MDIO_PMD_SHIFT) \|
c91b7f66 FF	70	(location << MDIO_REG_SHIFT) \| (0xffff & val)),
c91b7f66 FF	71	UMAC_MDIO_CMD);
aa09677c FF	72	reg = bcmgenet_umac_readl(priv, UMAC_MDIO_CMD);
	73	reg \|= MDIO_START_BUSY;
	74	bcmgenet_umac_writel(priv, reg, UMAC_MDIO_CMD);
	75	wait_event_timeout(priv->wq,
c91b7f66 FF	76	!(bcmgenet_umac_readl(priv, UMAC_MDIO_CMD) &
	77	MDIO_START_BUSY),
	78	HZ / 100);
aa09677c FF	79
	80	return 0;
	81	}
	82
	83	/* setup netdev link state when PHY link status change and
	84	* update UMAC and RGMII block when link up
	85	*/
c96e731c	86	void bcmgenet_mii_setup(struct net_device *dev)
aa09677c FF	87	{
aa09677c FF	88	struct bcmgenet_priv *priv = netdev_priv(dev);
bf1a85a8	89	struct phy_device *phydev = priv->phydev;
aa09677c	90	u32 reg, cmd_bits = 0;
5ad6e6c5	91	bool status_changed = false;
aa09677c FF	92
aa09677c FF	93	if (priv->old_link != phydev->link) {
5ad6e6c5	94	status_changed = true;
aa09677c FF	95	priv->old_link = phydev->link;
	96	}
	97
	98	if (phydev->link) {
5ad6e6c5 PG	99	/* check speed/duplex/pause changes */
	100	if (priv->old_speed != phydev->speed) {
	101	status_changed = true;
	102	priv->old_speed = phydev->speed;
	103	}
	104
	105	if (priv->old_duplex != phydev->duplex) {
	106	status_changed = true;
	107	priv->old_duplex = phydev->duplex;
	108	}
	109
	110	if (priv->old_pause != phydev->pause) {
	111	status_changed = true;
	112	priv->old_pause = phydev->pause;
	113	}
	114
	115	/* done if nothing has changed */
	116	if (!status_changed)
	117	return;
aa09677c FF	118
	119	/* speed */
	120	if (phydev->speed == SPEED_1000)
	121	cmd_bits = UMAC_SPEED_1000;
	122	else if (phydev->speed == SPEED_100)
	123	cmd_bits = UMAC_SPEED_100;
	124	else
	125	cmd_bits = UMAC_SPEED_10;
	126	cmd_bits <<= CMD_SPEED_SHIFT;
	127
aa09677c FF	128	/* duplex */
	129	if (phydev->duplex != DUPLEX_FULL)
	130	cmd_bits \|= CMD_HD_EN;
	131
aa09677c FF	132	/* pause capability */
	133	if (!phydev->pause)
	134	cmd_bits \|= CMD_RX_PAUSE_IGNORE \| CMD_TX_PAUSE_IGNORE;
	135
5ad6e6c5 PG	136	/*
	137	* Program UMAC and RGMII block based on established
	138	* link speed, duplex, and pause. The speed set in
	139	* umac->cmd tell RGMII block which clock to use for
	140	* transmit -- 25MHz(100Mbps) or 125MHz(1Gbps).
	141	* Receive clock is provided by the PHY.
	142	*/
	143	reg = bcmgenet_ext_readl(priv, EXT_RGMII_OOB_CTRL);
	144	reg &= ~OOB_DISABLE;
	145	reg \|= RGMII_LINK;
	146	bcmgenet_ext_writel(priv, reg, EXT_RGMII_OOB_CTRL);
c677ba8b	147
aa09677c FF	148	reg = bcmgenet_umac_readl(priv, UMAC_CMD);
	149	reg &= ~((CMD_SPEED_MASK << CMD_SPEED_SHIFT) \|
	150	CMD_HD_EN \|
	151	CMD_RX_PAUSE_IGNORE \| CMD_TX_PAUSE_IGNORE);
	152	reg \|= cmd_bits;
	153	bcmgenet_umac_writel(priv, reg, UMAC_CMD);
5ad6e6c5 PG	154	} else {
	155	/* done if nothing has changed */
	156	if (!status_changed)
	157	return;
aa09677c	158
5ad6e6c5 PG	159	/* needed for MoCA fixed PHY to reflect correct link status */
5ad6e6c5 PG	160	netif_carrier_off(dev);
24052408	161	}
c677ba8b FF	162
c677ba8b FF	163	phy_print_status(phydev);
aa09677c FF	164	}
aa09677c FF	165
5dbebbb4	166
6ac9de5f FF	167	static int bcmgenet_fixed_phy_link_update(struct net_device *dev,
	168	struct fixed_phy_status *status)
	169	{
	170	if (dev && dev->phydev && status)
	171	status->link = dev->phydev->link;
	172
	173	return 0;
	174	}
	175
5dbebbb4 FF	176	/* Perform a voluntary PHY software reset, since the EPHY is very finicky about
	177	* not doing it and will start corrupting packets
	178	*/
	179	void bcmgenet_mii_reset(struct net_device *dev)
	180	{
	181	struct bcmgenet_priv *priv = netdev_priv(dev);
	182
	183	if (GENET_IS_V4(priv))
	184	return;
	185
bf1a85a8 FF	186	if (priv->phydev) {
	187	phy_init_hw(priv->phydev);
	188	phy_start_aneg(priv->phydev);
5dbebbb4 FF	189	}
	190	}
	191
a642c4f7	192	void bcmgenet_phy_power_set(struct net_device *dev, bool enable)
aa09677c FF	193	{
	194	struct bcmgenet_priv *priv = netdev_priv(dev);
	195	u32 reg = 0;
	196
	197	/* EXT_GPHY_CTRL is only valid for GENETv4 and onward */
42138085 DB	198	if (GENET_IS_V4(priv)) {
	199	reg = bcmgenet_ext_readl(priv, EXT_GPHY_CTRL);
	200	if (enable) {
	201	reg &= ~EXT_CK25_DIS;
	202	bcmgenet_ext_writel(priv, reg, EXT_GPHY_CTRL);
	203	mdelay(1);
	204
	205	reg &= ~(EXT_CFG_IDDQ_BIAS \| EXT_CFG_PWR_DOWN);
	206	reg \|= EXT_GPHY_RESET;
	207	bcmgenet_ext_writel(priv, reg, EXT_GPHY_CTRL);
	208	mdelay(1);
	209
	210	reg &= ~EXT_GPHY_RESET;
	211	} else {
	212	reg \|= EXT_CFG_IDDQ_BIAS \| EXT_CFG_PWR_DOWN \|
	213	EXT_GPHY_RESET;
	214	bcmgenet_ext_writel(priv, reg, EXT_GPHY_CTRL);
	215	mdelay(1);
	216	reg \|= EXT_CK25_DIS;
	217	}
8212c983	218	bcmgenet_ext_writel(priv, reg, EXT_GPHY_CTRL);
42138085	219	udelay(60);
a9d608c1	220	} else {
a9d608c1	221	mdelay(1);
8212c983	222	}
aa09677c FF	223	}
aa09677c FF	224
aa09677c FF	225	static void bcmgenet_moca_phy_setup(struct bcmgenet_priv *priv)
	226	{
	227	u32 reg;
	228
42138085 DB	229	if (!GENET_IS_V5(priv)) {
	230	/* Speed settings are set in bcmgenet_mii_setup() */
	231	reg = bcmgenet_sys_readl(priv, SYS_PORT_CTRL);
	232	reg \|= LED_ACT_SOURCE_MAC;
	233	bcmgenet_sys_writel(priv, reg, SYS_PORT_CTRL);
	234	}
6ac9de5f FF	235
6ac9de5f FF	236	if (priv->hw_params->flags & GENET_HAS_MOCA_LINK_DET)
bf1a85a8	237	fixed_phy_set_link_update(priv->phydev,
6ac9de5f	238	bcmgenet_fixed_phy_link_update);
aa09677c FF	239	}
aa09677c FF	240
00d51094	241	int bcmgenet_mii_config(struct net_device *dev, bool init)
aa09677c FF	242	{
aa09677c FF	243	struct bcmgenet_priv *priv = netdev_priv(dev);
bf1a85a8	244	struct phy_device *phydev = priv->phydev;
aa09677c FF	245	struct device *kdev = &priv->pdev->dev;
	246	const char *phy_name = NULL;
	247	u32 id_mode_dis = 0;
	248	u32 port_ctrl;
	249	u32 reg;
	250
c624f891	251	priv->ext_phy = !priv->internal_phy &&
aa09677c FF	252	(priv->phy_interface != PHY_INTERFACE_MODE_MOCA);
aa09677c FF	253
aa09677c	254	switch (priv->phy_interface) {
40bc8b06	255	case PHY_INTERFACE_MODE_INTERNAL:
aa09677c FF	256	case PHY_INTERFACE_MODE_MOCA:
	257	/* Irrespective of the actually configured PHY speed (100 or
	258	* 1000) GENETv4 only has an internal GPHY so we will just end
	259	* up masking the Gigabit features from what we support, not
	260	* switching to the EPHY
	261	*/
	262	if (GENET_IS_V4(priv))
	263	port_ctrl = PORT_MODE_INT_GPHY;
	264	else
	265	port_ctrl = PORT_MODE_INT_EPHY;
	266
	267	bcmgenet_sys_writel(priv, port_ctrl, SYS_PORT_CTRL);
	268
c624f891	269	if (priv->internal_phy) {
aa09677c	270	phy_name = "internal PHY";
aa09677c FF	271	} else if (priv->phy_interface == PHY_INTERFACE_MODE_MOCA) {
	272	phy_name = "MoCA";
	273	bcmgenet_moca_phy_setup(priv);
	274	}
	275	break;
	276
	277	case PHY_INTERFACE_MODE_MII:
	278	phy_name = "external MII";
	279	phydev->supported &= PHY_BASIC_FEATURES;
	280	bcmgenet_sys_writel(priv,
c91b7f66	281	PORT_MODE_EXT_EPHY, SYS_PORT_CTRL);
aa09677c FF	282	break;
	283
	284	case PHY_INTERFACE_MODE_REVMII:
	285	phy_name = "external RvMII";
	286	/* of_mdiobus_register took care of reading the 'max-speed'
	287	* PHY property for us, effectively limiting the PHY supported
	288	* capabilities, use that knowledge to also configure the
	289	* Reverse MII interface correctly.
	290	*/
bf1a85a8	291	if ((priv->phydev->supported & PHY_BASIC_FEATURES) ==
aa09677c FF	292	PHY_BASIC_FEATURES)
	293	port_ctrl = PORT_MODE_EXT_RVMII_25;
	294	else
	295	port_ctrl = PORT_MODE_EXT_RVMII_50;
	296	bcmgenet_sys_writel(priv, port_ctrl, SYS_PORT_CTRL);
	297	break;
	298
	299	case PHY_INTERFACE_MODE_RGMII:
	300	/* RGMII_NO_ID: TXC transitions at the same time as TXD
	301	* (requires PCB or receiver-side delay)
	302	* RGMII: Add 2ns delay on TXC (90 degree shift)
	303	*
	304	* ID is implicitly disabled for 100Mbps (RG)MII operation.
	305	*/
	306	id_mode_dis = BIT(16);
	307	/* fall through */
	308	case PHY_INTERFACE_MODE_RGMII_TXID:
	309	if (id_mode_dis)
	310	phy_name = "external RGMII (no delay)";
	311	else
	312	phy_name = "external RGMII (TX delay)";
aa09677c	313	bcmgenet_sys_writel(priv,
c91b7f66	314	PORT_MODE_EXT_GPHY, SYS_PORT_CTRL);
aa09677c FF	315	break;
	316	default:
	317	dev_err(kdev, "unknown phy mode: %d\n", priv->phy_interface);
	318	return -EINVAL;
	319	}
	320
afe3f907 FF	321	/* This is an external PHY (xMII), so we need to enable the RGMII
	322	* block for the interface to work
	323	*/
	324	if (priv->ext_phy) {
	325	reg = bcmgenet_ext_readl(priv, EXT_RGMII_OOB_CTRL);
	326	reg \|= RGMII_MODE_EN \| id_mode_dis;
	327	bcmgenet_ext_writel(priv, reg, EXT_RGMII_OOB_CTRL);
	328	}
	329
00d51094 FF	330	if (init)
00d51094 FF	331	dev_info(kdev, "configuring instance for %s\n", phy_name);
aa09677c FF	332
	333	return 0;
	334	}
	335
6cc8e6d4	336	int bcmgenet_mii_probe(struct net_device *dev)
aa09677c FF	337	{
aa09677c FF	338	struct bcmgenet_priv *priv = netdev_priv(dev);
9abf0c2b	339	struct device_node *dn = priv->pdev->dev.of_node;
aa09677c	340	struct phy_device *phydev;
487320c5	341	u32 phy_flags;
aa09677c FF	342	int ret;
aa09677c FF	343
487320c5 FF	344	/* Communicate the integrated PHY revision */
	345	phy_flags = priv->gphy_rev;
	346
5ad6e6c5 PG	347	/* Initialize link state variables that bcmgenet_mii_setup() uses */
	348	priv->old_link = -1;
	349	priv->old_speed = -1;
	350	priv->old_duplex = -1;
	351	priv->old_pause = -1;
	352
b0ba512e	353	if (dn) {
b0ba512e PG	354	phydev = of_phy_connect(dev, priv->phy_dn, bcmgenet_mii_setup,
	355	phy_flags, priv->phy_interface);
	356	if (!phydev) {
	357	pr_err("could not attach to PHY\n");
	358	return -ENODEV;
	359	}
	360	} else {
bf1a85a8	361	phydev = priv->phydev;
b0ba512e PG	362	phydev->dev_flags = phy_flags;
	363
	364	ret = phy_connect_direct(dev, phydev, bcmgenet_mii_setup,
	365	priv->phy_interface);
	366	if (ret) {
	367	pr_err("could not attach to PHY\n");
	368	return -ENODEV;
	369	}
aa09677c FF	370	}
aa09677c FF	371
bf1a85a8 FF	372	priv->phydev = phydev;
bf1a85a8 FF	373
aa09677c FF	374	/* Configure port multiplexer based on what the probed PHY device since
	375	* reading the 'max-speed' property determines the maximum supported
	376	* PHY speed which is needed for bcmgenet_mii_config() to configure
	377	* things appropriately.
	378	*/
00d51094	379	ret = bcmgenet_mii_config(dev, true);
aa09677c	380	if (ret) {
bf1a85a8	381	phy_disconnect(priv->phydev);
aa09677c FF	382	return ret;
	383	}
	384
aa09677c FF	385	phydev->advertising = phydev->supported;
	386
	387	/* The internal PHY has its link interrupts routed to the
	388	* Ethernet MAC ISRs
	389	*/
c624f891	390	if (priv->internal_phy)
bf1a85a8	391	priv->phydev->irq = PHY_IGNORE_INTERRUPT;
aa09677c	392
aa09677c FF	393	return 0;
	394	}
	395
7b635da8 FF	396	/* Workaround for integrated BCM7xxx Gigabit PHYs which have a problem with
	397	* their internal MDIO management controller making them fail to successfully
	398	* be read from or written to for the first transaction. We insert a dummy
	399	* BMSR read here to make sure that phy_get_device() and get_phy_id() can
	400	* correctly read the PHY MII_PHYSID1/2 registers and successfully register a
	401	* PHY device for this peripheral.
	402	*
	403	* Once the PHY driver is registered, we can workaround subsequent reads from
	404	* there (e.g: during system-wide power management).
	405	*
	406	* bus->reset is invoked before mdiobus_scan during mdiobus_register and is
	407	* therefore the right location to stick that workaround. Since we do not want
	408	* to read from non-existing PHYs, we either use bus->phy_mask or do a manual
	409	* Device Tree scan to limit the search area.
	410	*/
	411	static int bcmgenet_mii_bus_reset(struct mii_bus *bus)
	412	{
	413	struct net_device *dev = bus->priv;
	414	struct bcmgenet_priv *priv = netdev_priv(dev);
	415	struct device_node *np = priv->mdio_dn;
	416	struct device_node *child = NULL;
	417	u32 read_mask = 0;
	418	int addr = 0;
	419
	420	if (!np) {
	421	read_mask = 1 << priv->phy_addr;
	422	} else {
	423	for_each_available_child_of_node(np, child) {
	424	addr = of_mdio_parse_addr(&dev->dev, child);
	425	if (addr < 0)
	426	continue;
	427
	428	read_mask \|= 1 << addr;
	429	}
	430	}
	431
	432	for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
	433	if (read_mask & 1 << addr) {
	434	dev_dbg(&dev->dev, "Workaround for PHY @ %d\n", addr);
	435	mdiobus_read(bus, addr, MII_BMSR);
	436	}
	437	}
	438
	439	return 0;
	440	}
	441
aa09677c FF	442	static int bcmgenet_mii_alloc(struct bcmgenet_priv *priv)
	443	{
	444	struct mii_bus *bus;
	445
	446	if (priv->mii_bus)
	447	return 0;
	448
	449	priv->mii_bus = mdiobus_alloc();
	450	if (!priv->mii_bus) {
	451	pr_err("failed to allocate\n");
	452	return -ENOMEM;
	453	}
	454
	455	bus = priv->mii_bus;
	456	bus->priv = priv->dev;
	457	bus->name = "bcmgenet MII bus";
	458	bus->parent = &priv->pdev->dev;
	459	bus->read = bcmgenet_mii_read;
	460	bus->write = bcmgenet_mii_write;
7b635da8	461	bus->reset = bcmgenet_mii_bus_reset;
aa09677c	462	snprintf(bus->id, MII_BUS_ID_SIZE, "%s-%d",
c91b7f66	463	priv->pdev->name, priv->pdev->id);
aa09677c	464
aa09677c FF	465	return 0;
	466	}
	467
	468	static int bcmgenet_mii_of_init(struct bcmgenet_priv *priv)
	469	{
	470	struct device_node *dn = priv->pdev->dev.of_node;
	471	struct device *kdev = &priv->pdev->dev;
6ac9de5f	472	struct phy_device *phydev = NULL;
aa09677c	473	char *compat;
c624f891	474	int phy_mode;
aa09677c FF	475	int ret;
	476
	477	compat = kasprintf(GFP_KERNEL, "brcm,genet-mdio-v%d", priv->version);
	478	if (!compat)
	479	return -ENOMEM;
	480
7b635da8	481	priv->mdio_dn = of_find_compatible_node(dn, NULL, compat);
aa09677c	482	kfree(compat);
7b635da8	483	if (!priv->mdio_dn) {
aa09677c FF	484	dev_err(kdev, "unable to find MDIO bus node\n");
	485	return -ENODEV;
	486	}
	487
7b635da8	488	ret = of_mdiobus_register(priv->mii_bus, priv->mdio_dn);
aa09677c FF	489	if (ret) {
	490	dev_err(kdev, "failed to register MDIO bus\n");
	491	return ret;
	492	}
	493
	494	/* Fetch the PHY phandle */
	495	priv->phy_dn = of_parse_phandle(dn, "phy-handle", 0);
	496
6cc8e6d4 FF	497	/* In the case of a fixed PHY, the DT node associated
	498	* to the PHY is the Ethernet MAC DT node.
	499	*/
	500	if (!priv->phy_dn && of_phy_is_fixed_link(dn)) {
	501	ret = of_phy_register_fixed_link(dn);
	502	if (ret)
	503	return ret;
	504
	505	priv->phy_dn = of_node_get(dn);
	506	}
	507
aa09677c	508	/* Get the link mode */
c624f891	509	phy_mode = of_get_phy_mode(dn);
40bc8b06 FF	510	if (phy_mode < 0) {
	511	dev_err(kdev, "invalid PHY mode property\n");
	512	return phy_mode;
	513	}
	514
c624f891 FF	515	priv->phy_interface = phy_mode;
	516
	517	/* We need to specifically look up whether this PHY interface is internal
	518	* or not before we even try to probe the PHY driver over MDIO as we
	519	* may have shut down the internal PHY for power saving purposes.
	520	*/
40bc8b06 FF	521	if (priv->phy_interface == PHY_INTERFACE_MODE_INTERNAL)
40bc8b06 FF	522	priv->internal_phy = true;
aa09677c	523
6ac9de5f FF	524	/* Make sure we initialize MoCA PHYs with a link down */
	525	if (phy_mode == PHY_INTERFACE_MODE_MOCA) {
	526	phydev = of_phy_find_device(dn);
0da60541	527	if (phydev) {
6ac9de5f	528	phydev->link = 0;
0da60541 JH	529	put_device(&phydev->mdio.dev);
0da60541 JH	530	}
6ac9de5f	531	}
8d88c6eb PG	532
	533	return 0;
	534	}
	535
b0ba512e PG	536	static int bcmgenet_mii_pd_init(struct bcmgenet_priv *priv)
	537	{
	538	struct device *kdev = &priv->pdev->dev;
	539	struct bcmgenet_platform_data *pd = kdev->platform_data;
	540	struct mii_bus *mdio = priv->mii_bus;
	541	struct phy_device *phydev;
	542	int ret;
	543
	544	if (pd->phy_interface != PHY_INTERFACE_MODE_MOCA && pd->mdio_enabled) {
	545	/*
	546	* Internal or external PHY with MDIO access
	547	*/
	548	if (pd->phy_address >= 0 && pd->phy_address < PHY_MAX_ADDR)
	549	mdio->phy_mask = ~(1 << pd->phy_address);
	550	else
	551	mdio->phy_mask = 0;
	552
	553	ret = mdiobus_register(mdio);
	554	if (ret) {
	555	dev_err(kdev, "failed to register MDIO bus\n");
	556	return ret;
	557	}
	558
	559	if (pd->phy_address >= 0 && pd->phy_address < PHY_MAX_ADDR)
7f854420	560	phydev = mdiobus_get_phy(mdio, pd->phy_address);
b0ba512e PG	561	else
	562	phydev = phy_find_first(mdio);
	563
	564	if (!phydev) {
	565	dev_err(kdev, "failed to register PHY device\n");
	566	mdiobus_unregister(mdio);
	567	return -ENODEV;
	568	}
	569	} else {
	570	/*
	571	* MoCA port or no MDIO access.
	572	* Use fixed PHY to represent the link layer.
	573	*/
	574	struct fixed_phy_status fphy_status = {
	575	.link = 1,
	576	.speed = pd->phy_speed,
	577	.duplex = pd->phy_duplex,
	578	.pause = 0,
	579	.asym_pause = 0,
	580	};
	581
a5597008	582	phydev = fixed_phy_register(PHY_POLL, &fphy_status, -1, NULL);
b0ba512e PG	583	if (!phydev \|\| IS_ERR(phydev)) {
	584	dev_err(kdev, "failed to register fixed PHY device\n");
	585	return -ENODEV;
	586	}
8d88c6eb	587
6ac9de5f FF	588	/* Make sure we initialize MoCA PHYs with a link down */
	589	phydev->link = 0;
	590
b0ba512e PG	591	}
b0ba512e PG	592
bf1a85a8	593	priv->phydev = phydev;
b0ba512e PG	594	priv->phy_interface = pd->phy_interface;
	595
	596	return 0;
	597	}
	598
	599	static int bcmgenet_mii_bus_init(struct bcmgenet_priv *priv)
	600	{
	601	struct device_node *dn = priv->pdev->dev.of_node;
	602
	603	if (dn)
	604	return bcmgenet_mii_of_init(priv);
	605	else
	606	return bcmgenet_mii_pd_init(priv);
	607	}
	608
aa09677c FF	609	int bcmgenet_mii_init(struct net_device *dev)
	610	{
	611	struct bcmgenet_priv *priv = netdev_priv(dev);
140ca9d3	612	struct device_node *dn = priv->pdev->dev.of_node;
aa09677c FF	613	int ret;
	614
	615	ret = bcmgenet_mii_alloc(priv);
	616	if (ret)
	617	return ret;
	618
b0ba512e	619	ret = bcmgenet_mii_bus_init(priv);
aa09677c FF	620	if (ret)
	621	goto out;
	622
	623	return 0;
	624
	625	out:
140ca9d3 JH	626	if (of_phy_is_fixed_link(dn))
140ca9d3 JH	627	of_phy_deregister_fixed_link(dn);
9518259f	628	of_node_put(priv->phy_dn);
aa09677c	629	mdiobus_unregister(priv->mii_bus);
aa09677c FF	630	mdiobus_free(priv->mii_bus);
	631	return ret;
	632	}
	633
	634	void bcmgenet_mii_exit(struct net_device *dev)
	635	{
	636	struct bcmgenet_priv *priv = netdev_priv(dev);
140ca9d3	637	struct device_node *dn = priv->pdev->dev.of_node;
aa09677c	638
140ca9d3 JH	639	if (of_phy_is_fixed_link(dn))
140ca9d3 JH	640	of_phy_deregister_fixed_link(dn);
9518259f	641	of_node_put(priv->phy_dn);
aa09677c	642	mdiobus_unregister(priv->mii_bus);
aa09677c FF	643	mdiobus_free(priv->mii_bus);
aa09677c FF	644	}