Commit 73a1ff59 authored by David S. Miller's avatar David S. Miller

Merge branch 'bcmgenet-utilize-MDIO-unimac-driver'

Florian Fainelli says:

====================
net: bcmgenet: utilize MDIO unimac driver

This patch series migrates the Broadcom GENET driver to use the mdio-bcm-unimac
driver. This MDIO HW is the same as the one GENET internally embedds, yet for
historical reasons the two drivers lived their own lives. Because of the GENET
interrupt situation, we let it specify how it wants to signal MDIO operations
completion using its driver-private waitqueue.

The diffstat is not super impressive, but it's still negative! This would
make it easier in the future to absorb possible workarounds/bugs/features
within the same location.

This was tested on BCM7260 (GENETv5, single instance), BCM7439 (GENETv4, triple
instance) and BCM7445 (bcm_sf2 + mdio-bcm-unimac).

We also now have a nice /proc/iomem output:

f0b00000-f0b0fc4b : /rdb/ethernet@f0b00000
  f0b00e14-f0b00e1c : unimac-mdio.0
f0b20000-f0b2fc4b : /rdb/ethernet@f0b20000
  f0b20e14-f0b20e1c : unimac-mdio.1
f0b40000-f0b4fc4b : /rdb/ethernet@f0b40000
  f0b40e14-f0b40e1c : unimac-mdio.2
====================
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 834e0ecf 6f24b85e
...@@ -5140,6 +5140,7 @@ L: netdev@vger.kernel.org ...@@ -5140,6 +5140,7 @@ L: netdev@vger.kernel.org
S: Maintained S: Maintained
F: include/linux/phy.h F: include/linux/phy.h
F: include/linux/phy_fixed.h F: include/linux/phy_fixed.h
F: include/linux/platform_data/mdio-bcm-unimac.h
F: drivers/net/phy/ F: drivers/net/phy/
F: Documentation/networking/phy.txt F: Documentation/networking/phy.txt
F: drivers/of/of_mdio.c F: drivers/of/of_mdio.c
......
...@@ -65,6 +65,7 @@ config BCMGENET ...@@ -65,6 +65,7 @@ config BCMGENET
select PHYLIB select PHYLIB
select FIXED_PHY select FIXED_PHY
select BCM7XXX_PHY select BCM7XXX_PHY
select MDIO_BCM_UNIMAC
help help
This driver supports the built-in Ethernet MACs found in the This driver supports the built-in Ethernet MACs found in the
Broadcom BCM7xxx Set Top Box family chipset. Broadcom BCM7xxx Set Top Box family chipset.
......
...@@ -657,6 +657,7 @@ struct bcmgenet_priv { ...@@ -657,6 +657,7 @@ struct bcmgenet_priv {
struct clk *clk; struct clk *clk;
struct platform_device *pdev; struct platform_device *pdev;
struct platform_device *mii_pdev;
/* WOL */ /* WOL */
struct clk *clk_wol; struct clk *clk_wol;
......
...@@ -24,62 +24,10 @@ ...@@ -24,62 +24,10 @@
#include <linux/of_net.h> #include <linux/of_net.h>
#include <linux/of_mdio.h> #include <linux/of_mdio.h>
#include <linux/platform_data/bcmgenet.h> #include <linux/platform_data/bcmgenet.h>
#include <linux/platform_data/mdio-bcm-unimac.h>
#include "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 /* setup netdev link state when PHY link status change and
* update UMAC and RGMII block when link up * update UMAC and RGMII block when link up
*/ */
...@@ -392,104 +340,121 @@ int bcmgenet_mii_probe(struct net_device *dev) ...@@ -392,104 +340,121 @@ int bcmgenet_mii_probe(struct net_device *dev)
return 0; return 0;
} }
/* Workaround for integrated BCM7xxx Gigabit PHYs which have a problem with static struct device_node *bcmgenet_mii_of_find_mdio(struct bcmgenet_priv *priv)
* 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 device_node *dn = priv->pdev->dev.of_node;
struct bcmgenet_priv *priv = netdev_priv(dev); struct device *kdev = &priv->pdev->dev;
struct device_node *np = priv->mdio_dn; char *compat;
struct device_node *child = NULL;
u32 read_mask = 0;
int addr = 0;
if (!np) { compat = kasprintf(GFP_KERNEL, "brcm,genet-mdio-v%d", priv->version);
read_mask = 1 << priv->phy_addr; if (!compat)
} else { return NULL;
for_each_available_child_of_node(np, child) {
addr = of_mdio_parse_addr(&dev->dev, child);
if (addr < 0)
continue;
read_mask |= 1 << addr; 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 NULL;
} }
for (addr = 0; addr < PHY_MAX_ADDR; addr++) { return priv->mdio_dn;
if (read_mask & 1 << addr) { }
dev_dbg(&dev->dev, "Workaround for PHY @ %d\n", addr);
mdiobus_read(bus, addr, MII_BMSR); static void bcmgenet_mii_pdata_init(struct bcmgenet_priv *priv,
} struct unimac_mdio_pdata *ppd)
{
struct device *kdev = &priv->pdev->dev;
struct bcmgenet_platform_data *pd = kdev->platform_data;
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)
ppd->phy_mask = 1 << pd->phy_address;
else
ppd->phy_mask = 0;
} }
}
static int bcmgenet_mii_wait(void *wait_func_data)
{
struct bcmgenet_priv *priv = wait_func_data;
wait_event_timeout(priv->wq,
!(bcmgenet_umac_readl(priv, UMAC_MDIO_CMD)
& MDIO_START_BUSY),
HZ / 100);
return 0; return 0;
} }
static int bcmgenet_mii_alloc(struct bcmgenet_priv *priv) static int bcmgenet_mii_register(struct bcmgenet_priv *priv)
{ {
struct mii_bus *bus; struct platform_device *pdev = priv->pdev;
struct bcmgenet_platform_data *pdata = pdev->dev.platform_data;
struct device_node *dn = pdev->dev.of_node;
struct unimac_mdio_pdata ppd;
struct platform_device *ppdev;
struct resource *pres, res;
int id, ret;
pres = platform_get_resource(pdev, IORESOURCE_MEM, 0);
memset(&res, 0, sizeof(res));
memset(&ppd, 0, sizeof(ppd));
ppd.wait_func = bcmgenet_mii_wait;
ppd.wait_func_data = priv;
ppd.bus_name = "bcmgenet MII bus";
/* Unimac MDIO bus controller starts at UniMAC offset + MDIO_CMD
* and is 2 * 32-bits word long, 8 bytes total.
*/
res.start = pres->start + GENET_UMAC_OFF + UMAC_MDIO_CMD;
res.end = res.start + 8;
res.flags = IORESOURCE_MEM;
if (priv->mii_bus) if (dn)
return 0; id = of_alias_get_id(dn, "eth");
else
id = pdev->id;
priv->mii_bus = mdiobus_alloc(); ppdev = platform_device_alloc(UNIMAC_MDIO_DRV_NAME, id);
if (!priv->mii_bus) { if (!ppdev)
pr_err("failed to allocate\n");
return -ENOMEM; return -ENOMEM;
}
bus = priv->mii_bus; /* Retain this platform_device pointer for later cleanup */
bus->priv = priv->dev; priv->mii_pdev = ppdev;
bus->name = "bcmgenet MII bus"; ppdev->dev.parent = &pdev->dev;
bus->parent = &priv->pdev->dev; ppdev->dev.of_node = bcmgenet_mii_of_find_mdio(priv);
bus->read = bcmgenet_mii_read; if (pdata)
bus->write = bcmgenet_mii_write; bcmgenet_mii_pdata_init(priv, &ppd);
bus->reset = bcmgenet_mii_bus_reset;
snprintf(bus->id, MII_BUS_ID_SIZE, "%s-%d", ret = platform_device_add_resources(ppdev, &res, 1);
priv->pdev->name, priv->pdev->id); if (ret)
goto out;
ret = platform_device_add_data(ppdev, &ppd, sizeof(ppd));
if (ret)
goto out;
ret = platform_device_add(ppdev);
if (ret)
goto out;
return 0; return 0;
out:
platform_device_put(ppdev);
return ret;
} }
static int bcmgenet_mii_of_init(struct bcmgenet_priv *priv) static int bcmgenet_mii_of_init(struct bcmgenet_priv *priv)
{ {
struct device_node *dn = priv->pdev->dev.of_node; struct device_node *dn = priv->pdev->dev.of_node;
struct device *kdev = &priv->pdev->dev; struct device *kdev = &priv->pdev->dev;
struct phy_device *phydev = NULL; struct phy_device *phydev;
char *compat;
int phy_mode; int phy_mode;
int ret; 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 */ /* Fetch the PHY phandle */
priv->phy_dn = of_parse_phandle(dn, "phy-handle", 0); priv->phy_dn = of_parse_phandle(dn, "phy-handle", 0);
...@@ -536,33 +501,23 @@ static int bcmgenet_mii_pd_init(struct bcmgenet_priv *priv) ...@@ -536,33 +501,23 @@ static int bcmgenet_mii_pd_init(struct bcmgenet_priv *priv)
{ {
struct device *kdev = &priv->pdev->dev; struct device *kdev = &priv->pdev->dev;
struct bcmgenet_platform_data *pd = kdev->platform_data; struct bcmgenet_platform_data *pd = kdev->platform_data;
struct mii_bus *mdio = priv->mii_bus; char phy_name[MII_BUS_ID_SIZE + 3];
char mdio_bus_id[MII_BUS_ID_SIZE];
struct phy_device *phydev; struct phy_device *phydev;
int ret;
snprintf(mdio_bus_id, MII_BUS_ID_SIZE, "%s-%d",
UNIMAC_MDIO_DRV_NAME, priv->pdev->id);
if (pd->phy_interface != PHY_INTERFACE_MODE_MOCA && pd->mdio_enabled) { if (pd->phy_interface != PHY_INTERFACE_MODE_MOCA && pd->mdio_enabled) {
snprintf(phy_name, MII_BUS_ID_SIZE, PHY_ID_FMT,
mdio_bus_id, pd->phy_address);
/* /*
* Internal or external PHY with MDIO access * Internal or external PHY with MDIO access
*/ */
if (pd->phy_address >= 0 && pd->phy_address < PHY_MAX_ADDR) phydev = phy_attach(priv->dev, phy_name, pd->phy_interface);
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) { if (!phydev) {
dev_err(kdev, "failed to register PHY device\n"); dev_err(kdev, "failed to register PHY device\n");
mdiobus_unregister(mdio);
return -ENODEV; return -ENODEV;
} }
} else { } else {
...@@ -608,10 +563,9 @@ static int bcmgenet_mii_bus_init(struct bcmgenet_priv *priv) ...@@ -608,10 +563,9 @@ static int bcmgenet_mii_bus_init(struct bcmgenet_priv *priv)
int bcmgenet_mii_init(struct net_device *dev) int bcmgenet_mii_init(struct net_device *dev)
{ {
struct bcmgenet_priv *priv = netdev_priv(dev); struct bcmgenet_priv *priv = netdev_priv(dev);
struct device_node *dn = priv->pdev->dev.of_node;
int ret; int ret;
ret = bcmgenet_mii_alloc(priv); ret = bcmgenet_mii_register(priv);
if (ret) if (ret)
return ret; return ret;
...@@ -622,11 +576,7 @@ int bcmgenet_mii_init(struct net_device *dev) ...@@ -622,11 +576,7 @@ int bcmgenet_mii_init(struct net_device *dev)
return 0; return 0;
out: out:
if (of_phy_is_fixed_link(dn)) bcmgenet_mii_exit(dev);
of_phy_deregister_fixed_link(dn);
of_node_put(priv->phy_dn);
mdiobus_unregister(priv->mii_bus);
mdiobus_free(priv->mii_bus);
return ret; return ret;
} }
...@@ -638,6 +588,6 @@ void bcmgenet_mii_exit(struct net_device *dev) ...@@ -638,6 +588,6 @@ void bcmgenet_mii_exit(struct net_device *dev)
if (of_phy_is_fixed_link(dn)) if (of_phy_is_fixed_link(dn))
of_phy_deregister_fixed_link(dn); of_phy_deregister_fixed_link(dn);
of_node_put(priv->phy_dn); of_node_put(priv->phy_dn);
mdiobus_unregister(priv->mii_bus); platform_device_unregister(priv->mii_pdev);
mdiobus_free(priv->mii_bus); platform_device_put(priv->mii_pdev);
} }
...@@ -21,6 +21,8 @@ ...@@ -21,6 +21,8 @@
#include <linux/of_platform.h> #include <linux/of_platform.h>
#include <linux/of_mdio.h> #include <linux/of_mdio.h>
#include <linux/platform_data/mdio-bcm-unimac.h>
#define MDIO_CMD 0x00 #define MDIO_CMD 0x00
#define MDIO_START_BUSY (1 << 29) #define MDIO_START_BUSY (1 << 29)
#define MDIO_READ_FAIL (1 << 28) #define MDIO_READ_FAIL (1 << 28)
...@@ -41,6 +43,8 @@ ...@@ -41,6 +43,8 @@
struct unimac_mdio_priv { struct unimac_mdio_priv {
struct mii_bus *mii_bus; struct mii_bus *mii_bus;
void __iomem *base; void __iomem *base;
int (*wait_func) (void *wait_func_data);
void *wait_func_data;
}; };
static inline void unimac_mdio_start(struct unimac_mdio_priv *priv) static inline void unimac_mdio_start(struct unimac_mdio_priv *priv)
...@@ -57,10 +61,28 @@ static inline unsigned int unimac_mdio_busy(struct unimac_mdio_priv *priv) ...@@ -57,10 +61,28 @@ static inline unsigned int unimac_mdio_busy(struct unimac_mdio_priv *priv)
return __raw_readl(priv->base + MDIO_CMD) & MDIO_START_BUSY; return __raw_readl(priv->base + MDIO_CMD) & MDIO_START_BUSY;
} }
static int unimac_mdio_poll(void *wait_func_data)
{
struct unimac_mdio_priv *priv = wait_func_data;
unsigned int timeout = 1000;
do {
if (!unimac_mdio_busy(priv))
return 0;
usleep_range(1000, 2000);
} while (timeout--);
if (!timeout)
return -ETIMEDOUT;
return 0;
}
static int unimac_mdio_read(struct mii_bus *bus, int phy_id, int reg) static int unimac_mdio_read(struct mii_bus *bus, int phy_id, int reg)
{ {
struct unimac_mdio_priv *priv = bus->priv; struct unimac_mdio_priv *priv = bus->priv;
unsigned int timeout = 1000; int ret;
u32 cmd; u32 cmd;
/* Prepare the read operation */ /* Prepare the read operation */
...@@ -70,15 +92,9 @@ static int unimac_mdio_read(struct mii_bus *bus, int phy_id, int reg) ...@@ -70,15 +92,9 @@ static int unimac_mdio_read(struct mii_bus *bus, int phy_id, int reg)
/* Start MDIO transaction */ /* Start MDIO transaction */
unimac_mdio_start(priv); unimac_mdio_start(priv);
do { ret = priv->wait_func(priv->wait_func_data);
if (!unimac_mdio_busy(priv)) if (ret)
break; return ret;
usleep_range(1000, 2000);
} while (timeout--);
if (!timeout)
return -ETIMEDOUT;
cmd = __raw_readl(priv->base + MDIO_CMD); cmd = __raw_readl(priv->base + MDIO_CMD);
...@@ -97,7 +113,6 @@ static int unimac_mdio_write(struct mii_bus *bus, int phy_id, ...@@ -97,7 +113,6 @@ static int unimac_mdio_write(struct mii_bus *bus, int phy_id,
int reg, u16 val) int reg, u16 val)
{ {
struct unimac_mdio_priv *priv = bus->priv; struct unimac_mdio_priv *priv = bus->priv;
unsigned int timeout = 1000;
u32 cmd; u32 cmd;
/* Prepare the write operation */ /* Prepare the write operation */
...@@ -107,17 +122,7 @@ static int unimac_mdio_write(struct mii_bus *bus, int phy_id, ...@@ -107,17 +122,7 @@ static int unimac_mdio_write(struct mii_bus *bus, int phy_id,
unimac_mdio_start(priv); unimac_mdio_start(priv);
do { return priv->wait_func(priv->wait_func_data);
if (!unimac_mdio_busy(priv))
break;
usleep_range(1000, 2000);
} while (timeout--);
if (!timeout)
return -ETIMEDOUT;
return 0;
} }
/* Workaround for integrated BCM7xxx Gigabit PHYs which have a problem with /* Workaround for integrated BCM7xxx Gigabit PHYs which have a problem with
...@@ -155,8 +160,10 @@ static int unimac_mdio_reset(struct mii_bus *bus) ...@@ -155,8 +160,10 @@ static int unimac_mdio_reset(struct mii_bus *bus)
} }
for (addr = 0; addr < PHY_MAX_ADDR; addr++) { for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
if (read_mask & 1 << addr) if (read_mask & 1 << addr) {
dev_dbg(&bus->dev, "Workaround for PHY @ %d\n", addr);
mdiobus_read(bus, addr, MII_BMSR); mdiobus_read(bus, addr, MII_BMSR);
}
} }
return 0; return 0;
...@@ -164,6 +171,7 @@ static int unimac_mdio_reset(struct mii_bus *bus) ...@@ -164,6 +171,7 @@ static int unimac_mdio_reset(struct mii_bus *bus)
static int unimac_mdio_probe(struct platform_device *pdev) static int unimac_mdio_probe(struct platform_device *pdev)
{ {
struct unimac_mdio_pdata *pdata = pdev->dev.platform_data;
struct unimac_mdio_priv *priv; struct unimac_mdio_priv *priv;
struct device_node *np; struct device_node *np;
struct mii_bus *bus; struct mii_bus *bus;
...@@ -193,12 +201,21 @@ static int unimac_mdio_probe(struct platform_device *pdev) ...@@ -193,12 +201,21 @@ static int unimac_mdio_probe(struct platform_device *pdev)
bus = priv->mii_bus; bus = priv->mii_bus;
bus->priv = priv; bus->priv = priv;
bus->name = "unimac MII bus"; if (pdata) {
bus->name = pdata->bus_name;
priv->wait_func = pdata->wait_func;
priv->wait_func_data = pdata->wait_func_data;
bus->phy_mask = ~pdata->phy_mask;
} else {
bus->name = "unimac MII bus";
priv->wait_func_data = priv;
priv->wait_func = unimac_mdio_poll;
}
bus->parent = &pdev->dev; bus->parent = &pdev->dev;
bus->read = unimac_mdio_read; bus->read = unimac_mdio_read;
bus->write = unimac_mdio_write; bus->write = unimac_mdio_write;
bus->reset = unimac_mdio_reset; bus->reset = unimac_mdio_reset;
snprintf(bus->id, MII_BUS_ID_SIZE, "%s", pdev->name); snprintf(bus->id, MII_BUS_ID_SIZE, "%s-%d", pdev->name, pdev->id);
ret = of_mdiobus_register(bus, np); ret = of_mdiobus_register(bus, np);
if (ret) { if (ret) {
...@@ -240,7 +257,7 @@ MODULE_DEVICE_TABLE(of, unimac_mdio_ids); ...@@ -240,7 +257,7 @@ MODULE_DEVICE_TABLE(of, unimac_mdio_ids);
static struct platform_driver unimac_mdio_driver = { static struct platform_driver unimac_mdio_driver = {
.driver = { .driver = {
.name = "unimac-mdio", .name = UNIMAC_MDIO_DRV_NAME,
.of_match_table = unimac_mdio_ids, .of_match_table = unimac_mdio_ids,
}, },
.probe = unimac_mdio_probe, .probe = unimac_mdio_probe,
...@@ -251,4 +268,4 @@ module_platform_driver(unimac_mdio_driver); ...@@ -251,4 +268,4 @@ module_platform_driver(unimac_mdio_driver);
MODULE_AUTHOR("Broadcom Corporation"); MODULE_AUTHOR("Broadcom Corporation");
MODULE_DESCRIPTION("Broadcom UniMAC MDIO bus controller"); MODULE_DESCRIPTION("Broadcom UniMAC MDIO bus controller");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:unimac-mdio"); MODULE_ALIAS("platform:" UNIMAC_MDIO_DRV_NAME);
#ifndef __MDIO_BCM_UNIMAC_PDATA_H
#define __MDIO_BCM_UNIMAC_PDATA_H
struct unimac_mdio_pdata {
u32 phy_mask;
int (*wait_func)(void *data);
void *wait_func_data;
const char *bus_name;
};
#define UNIMAC_MDIO_DRV_NAME "unimac-mdio"
#endif /* __MDIO_BCM_UNIMAC_PDATA_H */
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment