gianfar: Convert gianfar to an of_platform_driver

Does the same for the accompanying MDIO driver, and then modifies the TBI
configuration method.  The old way used fields in einfo, which no longer
exists.  The new way is to create an MDIO device-tree node for each instance
of gianfar, and create a tbi-handle property to associate ethernet controllers
with the TBI PHYs they are connected to.

Signed-off-by: Andy Fleming <afleming@freescale.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

5 files changed, 386 insertions, 192 deletions

diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index 55e319fa7fe6..7398704c4b55 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -25,11 +25,8 @@
  *
  *  Theory of operation
  *
- *  The driver is initialized through platform_device.  Structures which
- *  define the configuration needed by the board are defined in a
- *  board structure in arch/ppc/platforms (though I do not
- *  discount the possibility that other architectures could one
- *  day be supported.
+ *  The driver is initialized through of_device. Configuration information
+ *  is therefore conveyed through an OF-style device tree.
  *
  *  The Gianfar Ethernet Controller uses a ring of buffer
  *  descriptors.  The beginning is indicated by a register
@@ -78,7 +75,7 @@
 #include <linux/if_vlan.h>
 #include <linux/spinlock.h>
 #include <linux/mm.h>
-#include <linux/platform_device.h>
+#include <linux/of_platform.h>
 #include <linux/ip.h>
 #include <linux/tcp.h>
 #include <linux/udp.h>
@@ -92,6 +89,8 @@
 #include <linux/crc32.h>
 #include <linux/mii.h>
 #include <linux/phy.h>
+#include <linux/phy_fixed.h>
+#include <linux/of.h>
 
 #include "gianfar.h"
 #include "gianfar_mii.h"
@@ -119,8 +118,9 @@ static irqreturn_t gfar_interrupt(int irq, void *dev_id);
 static void adjust_link(struct net_device *dev);
 static void init_registers(struct net_device *dev);
 static int init_phy(struct net_device *dev);
-static int gfar_probe(struct platform_device *pdev);
-static int gfar_remove(struct platform_device *pdev);
+static int gfar_probe(struct of_device *ofdev,
+                const struct of_device_id *match);
+static int gfar_remove(struct of_device *ofdev);
 static void free_skb_resources(struct gfar_private *priv);
 static void gfar_set_multi(struct net_device *dev);
 static void gfar_set_hash_for_addr(struct net_device *dev, u8 *addr);
@@ -152,25 +152,158 @@ static inline int gfar_uses_fcb(struct gfar_private *priv)
         return (priv->vlan_enable || priv->rx_csum_enable);
 }
 
+static int gfar_of_init(struct net_device *dev)
+{
+        struct device_node *phy, *mdio;
+        const unsigned int *id;
+        const char *model;
+        const char *ctype;
+        const void *mac_addr;
+        const phandle *ph;
+        u64 addr, size;
+        int err = 0;
+        struct gfar_private *priv = netdev_priv(dev);
+        struct device_node *np = priv->node;
+        char bus_name[MII_BUS_ID_SIZE];
+
+        if (!np || !of_device_is_available(np))
+                return -ENODEV;
+
+        /* get a pointer to the register memory */
+        addr = of_translate_address(np, of_get_address(np, 0, &size, NULL));
+        priv->regs = ioremap(addr, size);
+
+        if (priv->regs == NULL)
+                return -ENOMEM;
+
+        priv->interruptTransmit = irq_of_parse_and_map(np, 0);
+
+        model = of_get_property(np, "model", NULL);
+
+        /* If we aren't the FEC we have multiple interrupts */
+        if (model && strcasecmp(model, "FEC")) {
+                priv->interruptReceive = irq_of_parse_and_map(np, 1);
+
+                priv->interruptError = irq_of_parse_and_map(np, 2);
+
+                if (priv->interruptTransmit < 0 ||
+                                priv->interruptReceive < 0 ||
+                                priv->interruptError < 0) {
+                        err = -EINVAL;
+                        goto err_out;
+                }
+        }
+
+        mac_addr = of_get_mac_address(np);
+        if (mac_addr)
+                memcpy(dev->dev_addr, mac_addr, MAC_ADDR_LEN);
+
+        if (model && !strcasecmp(model, "TSEC"))
+                priv->device_flags =
+                        FSL_GIANFAR_DEV_HAS_GIGABIT |
+                        FSL_GIANFAR_DEV_HAS_COALESCE |
+                        FSL_GIANFAR_DEV_HAS_RMON |
+                        FSL_GIANFAR_DEV_HAS_MULTI_INTR;
+        if (model && !strcasecmp(model, "eTSEC"))
+                priv->device_flags =
+                        FSL_GIANFAR_DEV_HAS_GIGABIT |
+                        FSL_GIANFAR_DEV_HAS_COALESCE |
+                        FSL_GIANFAR_DEV_HAS_RMON |
+                        FSL_GIANFAR_DEV_HAS_MULTI_INTR |
+                        FSL_GIANFAR_DEV_HAS_CSUM |
+                        FSL_GIANFAR_DEV_HAS_VLAN |
+                        FSL_GIANFAR_DEV_HAS_MAGIC_PACKET |
+                        FSL_GIANFAR_DEV_HAS_EXTENDED_HASH;
+
+        ctype = of_get_property(np, "phy-connection-type", NULL);
+
+        /* We only care about rgmii-id.  The rest are autodetected */
+        if (ctype && !strcmp(ctype, "rgmii-id"))
+                priv->interface = PHY_INTERFACE_MODE_RGMII_ID;
+        else
+                priv->interface = PHY_INTERFACE_MODE_MII;
+
+        if (of_get_property(np, "fsl,magic-packet", NULL))
+                priv->device_flags |= FSL_GIANFAR_DEV_HAS_MAGIC_PACKET;
+
+        ph = of_get_property(np, "phy-handle", NULL);
+        if (ph == NULL) {
+                u32 *fixed_link;
+
+                fixed_link = (u32 *)of_get_property(np, "fixed-link", NULL);
+                if (!fixed_link) {
+                        err = -ENODEV;
+                        goto err_out;
+                }
+
+                snprintf(priv->phy_bus_id, BUS_ID_SIZE, PHY_ID_FMT, "0",
+                                fixed_link[0]);
+        } else {
+                phy = of_find_node_by_phandle(*ph);
+
+                if (phy == NULL) {
+                        err = -ENODEV;
+                        goto err_out;
+                }
+
+                mdio = of_get_parent(phy);
+
+                id = of_get_property(phy, "reg", NULL);
+
+                of_node_put(phy);
+                of_node_put(mdio);
+
+                gfar_mdio_bus_name(bus_name, mdio);
+                snprintf(priv->phy_bus_id, BUS_ID_SIZE, "%s:%02x",
+                                bus_name, *id);
+        }
+
+        /* Find the TBI PHY.  If it's not there, we don't support SGMII */
+        ph = of_get_property(np, "tbi-handle", NULL);
+        if (ph) {
+                struct device_node *tbi = of_find_node_by_phandle(*ph);
+                struct of_device *ofdev;
+                struct mii_bus *bus;
+
+                if (!tbi)
+                        return 0;
+
+                mdio = of_get_parent(tbi);
+                if (!mdio)
+                        return 0;
+
+                ofdev = of_find_device_by_node(mdio);
+
+                of_node_put(mdio);
+
+                id = of_get_property(tbi, "reg", NULL);
+                if (!id)
+                        return 0;
+
+                of_node_put(tbi);
+
+                bus = dev_get_drvdata(&ofdev->dev);
+
+                priv->tbiphy = bus->phy_map[*id];
+        }
+
+        return 0;
+
+err_out:
+        iounmap(priv->regs);
+        return err;
+}
+
 /* Set up the ethernet device structure, private data,
  * and anything else we need before we start */
-static int gfar_probe(struct platform_device *pdev)
+static int gfar_probe(struct of_device *ofdev,
+                const struct of_device_id *match)
 {
         u32 tempval;
         struct net_device *dev = NULL;
         struct gfar_private *priv = NULL;
-        struct gianfar_platform_data *einfo;
-        struct resource *r;
-        int err = 0, irq;
-
-        einfo = (struct gianfar_platform_data *) pdev->dev.platform_data;
-
-        if (NULL == einfo) {
-                printk(KERN_ERR "gfar %d: Missing additional data!\n",
-                       pdev->id);
-
-                return -ENODEV;
-        }
+        int err = 0;
+        DECLARE_MAC_BUF(mac);
 
         /* Create an ethernet device instance */
         dev = alloc_etherdev(sizeof (*priv));
@@ -180,48 +313,19 @@ static int gfar_probe(struct platform_device *pdev)
 
         priv = netdev_priv(dev);
         priv->dev = dev;
+        priv->node = ofdev->node;
 
-        /* Set the info in the priv to the current info */
-        priv->einfo = einfo;
-
-        /* fill out IRQ fields */
-        if (einfo->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
-                irq = platform_get_irq_byname(pdev, "tx");
-                if (irq < 0)
-                        goto regs_fail;
-                priv->interruptTransmit = irq;
-
-                irq = platform_get_irq_byname(pdev, "rx");
-                if (irq < 0)
-                        goto regs_fail;
-                priv->interruptReceive = irq;
-
-                irq = platform_get_irq_byname(pdev, "error");
-                if (irq < 0)
-                        goto regs_fail;
-                priv->interruptError = irq;
-        } else {
-                irq = platform_get_irq(pdev, 0);
-                if (irq < 0)
-                        goto regs_fail;
-                priv->interruptTransmit = irq;
-        }
-
-        /* get a pointer to the register memory */
-        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        priv->regs = ioremap(r->start, sizeof (struct gfar));
+        err = gfar_of_init(dev);
 
-        if (NULL == priv->regs) {
-                err = -ENOMEM;
+        if (err)
                 goto regs_fail;
-        }
 
         spin_lock_init(&priv->txlock);
         spin_lock_init(&priv->rxlock);
         spin_lock_init(&priv->bflock);
         INIT_WORK(&priv->reset_task, gfar_reset_task);
 
-        platform_set_drvdata(pdev, dev);
+        dev_set_drvdata(&ofdev->dev, priv);
 
         /* Stop the DMA engine now, in case it was running before */
         /* (The firmware could have used it, and left it running). */
@@ -239,13 +343,10 @@ static int gfar_probe(struct platform_device *pdev)
         /* Initialize ECNTRL */
         gfar_write(&priv->regs->ecntrl, ECNTRL_INIT_SETTINGS);
 
-        /* Copy the station address into the dev structure, */
-        memcpy(dev->dev_addr, einfo->mac_addr, MAC_ADDR_LEN);
-
         /* Set the dev->base_addr to the gfar reg region */
         dev->base_addr = (unsigned long) (priv->regs);
 
-        SET_NETDEV_DEV(dev, &pdev->dev);
+        SET_NETDEV_DEV(dev, &ofdev->dev);
 
         /* Fill in the dev structure */
         dev->open = gfar_enet_open;
@@ -263,7 +364,7 @@ static int gfar_probe(struct platform_device *pdev)
 
         dev->ethtool_ops = &gfar_ethtool_ops;
 
-        if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_CSUM) {
+        if (priv->device_flags & FSL_GIANFAR_DEV_HAS_CSUM) {
                 priv->rx_csum_enable = 1;
                 dev->features |= NETIF_F_IP_CSUM;
         } else
@@ -271,7 +372,7 @@ static int gfar_probe(struct platform_device *pdev)
 
         priv->vlgrp = NULL;
 
-        if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_VLAN) {
+        if (priv->device_flags & FSL_GIANFAR_DEV_HAS_VLAN) {
                 dev->vlan_rx_register = gfar_vlan_rx_register;
 
                 dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
@@ -279,7 +380,7 @@ static int gfar_probe(struct platform_device *pdev)
                 priv->vlan_enable = 1;
         }
 
-        if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_EXTENDED_HASH) {
+        if (priv->device_flags & FSL_GIANFAR_DEV_HAS_EXTENDED_HASH) {
                 priv->extended_hash = 1;
                 priv->hash_width = 9;
 
@@ -314,7 +415,7 @@ static int gfar_probe(struct platform_device *pdev)
                 priv->hash_regs[7] = &priv->regs->gaddr7;
         }
 
-        if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_PADDING)
+        if (priv->device_flags & FSL_GIANFAR_DEV_HAS_PADDING)
                 priv->padding = DEFAULT_PADDING;
         else
                 priv->padding = 0;
@@ -368,29 +469,28 @@ regs_fail:
         return err;
 }
 
-static int gfar_remove(struct platform_device *pdev)
+static int gfar_remove(struct of_device *ofdev)
 {
-        struct net_device *dev = platform_get_drvdata(pdev);
-        struct gfar_private *priv = netdev_priv(dev);
+        struct gfar_private *priv = dev_get_drvdata(&ofdev->dev);
 
-        platform_set_drvdata(pdev, NULL);
+        dev_set_drvdata(&ofdev->dev, NULL);
 
         iounmap(priv->regs);
-        free_netdev(dev);
+        free_netdev(priv->dev);
 
         return 0;
 }
 
 #ifdef CONFIG_PM
-static int gfar_suspend(struct platform_device *pdev, pm_message_t state)
+static int gfar_suspend(struct of_device *ofdev, pm_message_t state)
 {
-        struct net_device *dev = platform_get_drvdata(pdev);
-        struct gfar_private *priv = netdev_priv(dev);
+        struct gfar_private *priv = dev_get_drvdata(&ofdev->dev);
+        struct net_device *dev = priv->dev;
         unsigned long flags;
         u32 tempval;
 
         int magic_packet = priv->wol_en &&
-                (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);
+                (priv->device_flags & FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);
 
         netif_device_detach(dev);
 
@@ -431,14 +531,14 @@ static int gfar_suspend(struct platform_device *pdev, pm_message_t state)
         return 0;
 }
 
-static int gfar_resume(struct platform_device *pdev)
+static int gfar_resume(struct of_device *ofdev)
 {
-        struct net_device *dev = platform_get_drvdata(pdev);
-        struct gfar_private *priv = netdev_priv(dev);
+        struct gfar_private *priv = dev_get_drvdata(&ofdev->dev);
+        struct net_device *dev = priv->dev;
         unsigned long flags;
         u32 tempval;
         int magic_packet = priv->wol_en &&
-                (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);
+                (priv->device_flags & FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);
 
         if (!netif_running(dev)) {
                 netif_device_attach(dev);
@@ -497,7 +597,7 @@ static phy_interface_t gfar_get_interface(struct net_device *dev)
                 if (ecntrl & ECNTRL_REDUCED_MII_MODE)
                         return PHY_INTERFACE_MODE_RMII;
                 else {
-                        phy_interface_t interface = priv->einfo->interface;
+                        phy_interface_t interface = priv->interface;
 
                         /*
                          * This isn't autodetected right now, so it must
@@ -510,7 +610,7 @@ static phy_interface_t gfar_get_interface(struct net_device *dev)
                 }
         }
 
-        if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_GIGABIT)
+        if (priv->device_flags & FSL_GIANFAR_DEV_HAS_GIGABIT)
                 return PHY_INTERFACE_MODE_GMII;
 
         return PHY_INTERFACE_MODE_MII;
@@ -524,21 +624,18 @@ static int init_phy(struct net_device *dev)
 {
         struct gfar_private *priv = netdev_priv(dev);
         uint gigabit_support =
-                priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_GIGABIT ?
+                priv->device_flags & FSL_GIANFAR_DEV_HAS_GIGABIT ?
                 SUPPORTED_1000baseT_Full : 0;
         struct phy_device *phydev;
-        char phy_id[BUS_ID_SIZE];
         phy_interface_t interface;
 
         priv->oldlink = 0;
         priv->oldspeed = 0;
         priv->oldduplex = -1;
 
-        snprintf(phy_id, sizeof(phy_id), PHY_ID_FMT, priv->einfo->bus_id, priv->einfo->phy_id);
-
         interface = gfar_get_interface(dev);
 
-        phydev = phy_connect(dev, phy_id, &adjust_link, 0, interface);
+        phydev = phy_connect(dev, priv->phy_bus_id, &adjust_link, 0, interface);
 
         if (interface == PHY_INTERFACE_MODE_SGMII)
                 gfar_configure_serdes(dev);
@@ -569,35 +666,31 @@ static int init_phy(struct net_device *dev)
 static void gfar_configure_serdes(struct net_device *dev)
 {
         struct gfar_private *priv = netdev_priv(dev);
-        struct gfar_mii __iomem *regs =
-                        (void __iomem *)&priv->regs->gfar_mii_regs;
-        int tbipa = gfar_read(&priv->regs->tbipa);
-        struct mii_bus *bus = gfar_get_miibus(priv);
 
-        if (bus)
-                mutex_lock(&bus->mdio_lock);
+        if (!priv->tbiphy) {
+                printk(KERN_WARNING "SGMII mode requires that the device "
+                                "tree specify a tbi-handle\n");
+                return;
+        }
 
-        /* If the link is already up, we must already be ok, and don't need to
+        /*
+         * If the link is already up, we must already be ok, and don't need to
          * configure and reset the TBI<->SerDes link.  Maybe U-Boot configured
          * everything for us?  Resetting it takes the link down and requires
          * several seconds for it to come back.
          */
-        if (gfar_local_mdio_read(regs, tbipa, MII_BMSR) & BMSR_LSTATUS)
-                goto done;
+        if (phy_read(priv->tbiphy, MII_BMSR) & BMSR_LSTATUS)
+                return;
 
         /* Single clk mode, mii mode off(for serdes communication) */
-        gfar_local_mdio_write(regs, tbipa, MII_TBICON, TBICON_CLK_SELECT);
+        phy_write(priv->tbiphy, MII_TBICON, TBICON_CLK_SELECT);
 
-        gfar_local_mdio_write(regs, tbipa, MII_ADVERTISE,
+        phy_write(priv->tbiphy, MII_ADVERTISE,
                         ADVERTISE_1000XFULL | ADVERTISE_1000XPAUSE |
                         ADVERTISE_1000XPSE_ASYM);
 
-        gfar_local_mdio_write(regs, tbipa, MII_BMCR, BMCR_ANENABLE |
+        phy_write(priv->tbiphy, MII_BMCR, BMCR_ANENABLE |
                         BMCR_ANRESTART | BMCR_FULLDPLX | BMCR_SPEED1000);
-
-        done:
-        if (bus)
-                mutex_unlock(&bus->mdio_lock);
 }
 
 static void init_registers(struct net_device *dev)
@@ -630,7 +723,7 @@ static void init_registers(struct net_device *dev)
         gfar_write(&priv->regs->gaddr7, 0);
 
         /* Zero out the rmon mib registers if it has them */
-        if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_RMON) {
+        if (priv->device_flags & FSL_GIANFAR_DEV_HAS_RMON) {
                 memset_io(&(priv->regs->rmon), 0, sizeof (struct rmon_mib));
 
                 /* Mask off the CAM interrupts */
@@ -705,7 +798,7 @@ void stop_gfar(struct net_device *dev)
         spin_unlock_irqrestore(&priv->txlock, flags);
 
         /* Free the IRQs */
-        if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
+        if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
                 free_irq(priv->interruptError, dev);
                 free_irq(priv->interruptTransmit, dev);
                 free_irq(priv->interruptReceive, dev);
@@ -919,7 +1012,7 @@ int startup_gfar(struct net_device *dev)
 
         /* If the device has multiple interrupts, register for
          * them.  Otherwise, only register for the one */
-        if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
+        if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
                 /* Install our interrupt handlers for Error,
                  * Transmit, and Receive */
                 if (request_irq(priv->interruptError, gfar_error,
@@ -1751,7 +1844,7 @@ static void gfar_netpoll(struct net_device *dev)
         struct gfar_private *priv = netdev_priv(dev);
 
         /* If the device has multiple interrupts, run tx/rx */
-        if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
+        if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
                 disable_irq(priv->interruptTransmit);
                 disable_irq(priv->interruptReceive);
                 disable_irq(priv->interruptError);
@@ -2045,7 +2138,7 @@ static irqreturn_t gfar_error(int irq, void *dev_id)
         gfar_write(&priv->regs->ievent, events & IEVENT_ERR_MASK);
 
         /* Magic Packet is not an error. */
-        if ((priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_MAGIC_PACKET) &&
+        if ((priv->device_flags & FSL_GIANFAR_DEV_HAS_MAGIC_PACKET) &&
             (events & IEVENT_MAG))
                 events &= ~IEVENT_MAG;
 
@@ -2111,16 +2204,24 @@ static irqreturn_t gfar_error(int irq, void *dev_id)
 /* work with hotplug and coldplug */
 MODULE_ALIAS("platform:fsl-gianfar");
 
+static struct of_device_id gfar_match[] =
+{
+        {
+                .type = "network",
+                .compatible = "gianfar",
+        },
+        {},
+};
+
 /* Structure for a device driver */
-static struct platform_driver gfar_driver = {
+static struct of_platform_driver gfar_driver = {
+        .name = "fsl-gianfar",
+        .match_table = gfar_match,
+
         .probe = gfar_probe,
         .remove = gfar_remove,
         .suspend = gfar_suspend,
         .resume = gfar_resume,
-        .driver = {
-                .name = "fsl-gianfar",
-                .owner = THIS_MODULE,
-        },
 };
 
 static int __init gfar_init(void)
@@ -2130,7 +2231,7 @@ static int __init gfar_init(void)
         if (err)
                 return err;
 
-        err = platform_driver_register(&gfar_driver);
+        err = of_register_platform_driver(&gfar_driver);
 
         if (err)
                 gfar_mdio_exit();
@@ -2140,7 +2241,7 @@ static int __init gfar_init(void)
 
 static void __exit gfar_exit(void)
 {
-        platform_driver_unregister(&gfar_driver);
+        of_unregister_platform_driver(&gfar_driver);
         gfar_mdio_exit();
 }
 
diff --git a/drivers/net/gianfar.h b/drivers/net/gianfar.h
index f46e9b63af13..ca7f0a6a68c5 100644
--- a/drivers/net/gianfar.h
+++ b/drivers/net/gianfar.h
@@ -657,6 +657,19 @@ struct gfar {
 
 };
 
+/* Flags related to gianfar device features */
+#define FSL_GIANFAR_DEV_HAS_GIGABIT             0x00000001
+#define FSL_GIANFAR_DEV_HAS_COALESCE            0x00000002
+#define FSL_GIANFAR_DEV_HAS_RMON                0x00000004
+#define FSL_GIANFAR_DEV_HAS_MULTI_INTR          0x00000008
+#define FSL_GIANFAR_DEV_HAS_CSUM                0x00000010
+#define FSL_GIANFAR_DEV_HAS_VLAN                0x00000020
+#define FSL_GIANFAR_DEV_HAS_EXTENDED_HASH       0x00000040
+#define FSL_GIANFAR_DEV_HAS_PADDING             0x00000080
+#define FSL_GIANFAR_DEV_HAS_MAGIC_PACKET        0x00000100
+#define FSL_GIANFAR_DEV_HAS_BD_STASHING         0x00000200
+#define FSL_GIANFAR_DEV_HAS_BUF_STASHING        0x00000400
+
 /* Struct stolen almost completely (and shamelessly) from the FCC enet source
  * (Ok, that's not so true anymore, but there is a family resemblence)
  * The GFAR buffer descriptors track the ring buffers.  The rx_bd_base
@@ -694,6 +707,7 @@ struct gfar_private {
         /* RX Locked fields */
         spinlock_t rxlock;
 
+        struct device_node *node;
         struct net_device *dev;
         struct napi_struct napi;
 
@@ -733,6 +747,9 @@ struct gfar_private {
         /* Bitfield update lock */
         spinlock_t bflock;
 
+        phy_interface_t interface;
+        char    phy_bus_id[BUS_ID_SIZE];
+        u32 device_flags;
         unsigned char vlan_enable:1,
                 rx_csum_enable:1,
                 extended_hash:1,
@@ -744,11 +761,9 @@ struct gfar_private {
         unsigned int interruptReceive;
         unsigned int interruptError;
 
-        /* info structure initialized by platform code */
-        struct gianfar_platform_data *einfo;
-
         /* PHY stuff */
         struct phy_device *phydev;
+        struct phy_device *tbiphy;
         struct mii_bus *mii_bus;
         int oldspeed;
         int oldduplex;
diff --git a/drivers/net/gianfar_ethtool.c b/drivers/net/gianfar_ethtool.c
index fb7d3ccc0fdc..53944b120a3d 100644
--- a/drivers/net/gianfar_ethtool.c
+++ b/drivers/net/gianfar_ethtool.c
@@ -121,7 +121,7 @@ static void gfar_gstrings(struct net_device *dev, u32 stringset, u8 * buf)
 {
         struct gfar_private *priv = netdev_priv(dev);
 
-        if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_RMON)
+        if (priv->device_flags & FSL_GIANFAR_DEV_HAS_RMON)
                 memcpy(buf, stat_gstrings, GFAR_STATS_LEN * ETH_GSTRING_LEN);
         else
                 memcpy(buf, stat_gstrings,
@@ -138,7 +138,7 @@ static void gfar_fill_stats(struct net_device *dev, struct ethtool_stats *dummy,
         struct gfar_private *priv = netdev_priv(dev);
         u64 *extra = (u64 *) & priv->extra_stats;
 
-        if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_RMON) {
+        if (priv->device_flags & FSL_GIANFAR_DEV_HAS_RMON) {
                 u32 __iomem *rmon = (u32 __iomem *) & priv->regs->rmon;
                 struct gfar_stats *stats = (struct gfar_stats *) buf;
 
@@ -158,7 +158,7 @@ static int gfar_sset_count(struct net_device *dev, int sset)
 
         switch (sset) {
         case ETH_SS_STATS:
-                if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_RMON)
+                if (priv->device_flags & FSL_GIANFAR_DEV_HAS_RMON)
                         return GFAR_STATS_LEN;
                 else
                         return GFAR_EXTRA_STATS_LEN;
@@ -280,7 +280,7 @@ static int gfar_gcoalesce(struct net_device *dev, struct ethtool_coalesce *cvals
 {
         struct gfar_private *priv = netdev_priv(dev);
 
-        if (!(priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_COALESCE))
+        if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_COALESCE))
                 return -EOPNOTSUPP;
 
         if (NULL == priv->phydev)
@@ -332,7 +332,7 @@ static int gfar_scoalesce(struct net_device *dev, struct ethtool_coalesce *cvals
 {
         struct gfar_private *priv = netdev_priv(dev);
 
-        if (!(priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_COALESCE))
+        if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_COALESCE))
                 return -EOPNOTSUPP;
 
         /* Set up rx coalescing */
@@ -482,7 +482,7 @@ static int gfar_set_rx_csum(struct net_device *dev, uint32_t data)
         unsigned long flags;
         int err = 0;
 
-        if (!(priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_CSUM))
+        if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_CSUM))
                 return -EOPNOTSUPP;
 
         if (dev->flags & IFF_UP) {
@@ -515,7 +515,7 @@ static uint32_t gfar_get_rx_csum(struct net_device *dev)
 {
         struct gfar_private *priv = netdev_priv(dev);
 
-        if (!(priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_CSUM))
+        if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_CSUM))
                 return 0;
 
         return priv->rx_csum_enable;
@@ -526,7 +526,7 @@ static int gfar_set_tx_csum(struct net_device *dev, uint32_t data)
         unsigned long flags;
         struct gfar_private *priv = netdev_priv(dev);
 
-        if (!(priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_CSUM))
+        if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_CSUM))
                 return -EOPNOTSUPP;
 
         spin_lock_irqsave(&priv->txlock, flags);
@@ -547,7 +547,7 @@ static uint32_t gfar_get_tx_csum(struct net_device *dev)
 {
         struct gfar_private *priv = netdev_priv(dev);
 
-        if (!(priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_CSUM))
+        if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_CSUM))
                 return 0;
 
         return (dev->features & NETIF_F_IP_CSUM) != 0;
@@ -570,7 +570,7 @@ static void gfar_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
 {
         struct gfar_private *priv = netdev_priv(dev);
 
-        if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_MAGIC_PACKET) {
+        if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MAGIC_PACKET) {
                 wol->supported = WAKE_MAGIC;
                 wol->wolopts = priv->wol_en ? WAKE_MAGIC : 0;
         } else {
@@ -583,7 +583,7 @@ static int gfar_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
         struct gfar_private *priv = netdev_priv(dev);
         unsigned long flags;
 
-        if (!(priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_MAGIC_PACKET) &&
+        if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_MAGIC_PACKET) &&
             wol->wolopts != 0)
                 return -EINVAL;
 
diff --git a/drivers/net/gianfar_mii.c b/drivers/net/gianfar_mii.c
index 0e2595d24933..f3706e415b45 100644
--- a/drivers/net/gianfar_mii.c
+++ b/drivers/net/gianfar_mii.c
@@ -34,6 +34,8 @@
 #include <linux/crc32.h>
 #include <linux/mii.h>
 #include <linux/phy.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
 
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -150,19 +152,83 @@ static int gfar_mdio_reset(struct mii_bus *bus)
         return 0;
 }
 
+/* Allocate an array which provides irq #s for each PHY on the given bus */
+static int *create_irq_map(struct device_node *np)
+{
+        int *irqs;
+        int i;
+        struct device_node *child = NULL;
+
+        irqs = kcalloc(PHY_MAX_ADDR, sizeof(int), GFP_KERNEL);
+
+        if (!irqs)
+                return NULL;
+
+        for (i = 0; i < PHY_MAX_ADDR; i++)
+                irqs[i] = PHY_POLL;
+
+        while ((child = of_get_next_child(np, child)) != NULL) {
+                int irq = irq_of_parse_and_map(child, 0);
+                const u32 *id;
+
+                if (irq == NO_IRQ)
+                        continue;
+
+                id = of_get_property(child, "reg", NULL);
+
+                if (!id)
+                        continue;
+
+                if (*id < PHY_MAX_ADDR && *id >= 0)
+                        irqs[*id] = irq;
+                else
+                        printk(KERN_WARNING "%s: "
+                                        "%d is not a valid PHY address\n",
+                                        np->full_name, *id);
+        }
+
+        return irqs;
+}
+
+
+void gfar_mdio_bus_name(char *name, struct device_node *np)
+{
+        const u32 *reg;
+
+        reg = of_get_property(np, "reg", NULL);
 
-static int gfar_mdio_probe(struct device *dev)
+        snprintf(name, MII_BUS_ID_SIZE, "%s@%x", np->name, reg ? *reg : 0);
+}
+
+/* Scan the bus in reverse, looking for an empty spot */
+static int gfar_mdio_find_free(struct mii_bus *new_bus)
+{
+        int i;
+
+        for (i = PHY_MAX_ADDR; i > 0; i--) {
+                u32 phy_id;
+
+                if (get_phy_id(new_bus, i, &phy_id))
+                        return -1;
+
+                if (phy_id == 0xffffffff)
+                        break;
+        }
+
+        return i;
+}
+
+static int gfar_mdio_probe(struct of_device *ofdev,
+                const struct of_device_id *match)
 {
-        struct platform_device *pdev = to_platform_device(dev);
-        struct gianfar_mdio_data *pdata;
         struct gfar_mii __iomem *regs;
         struct gfar __iomem *enet_regs;
         struct mii_bus *new_bus;
-        struct resource *r;
-        int i, err = 0;
-
-        if (NULL == dev)
-                return -EINVAL;
+        int err = 0;
+        u64 addr, size;
+        struct device_node *np = ofdev->node;
+        struct device_node *tbi;
+        int tbiaddr = -1;
 
         new_bus = mdiobus_alloc();
         if (NULL == new_bus)
@@ -172,31 +238,28 @@ static int gfar_mdio_probe(struct device *dev)
         new_bus->read = &gfar_mdio_read,
         new_bus->write = &gfar_mdio_write,
         new_bus->reset = &gfar_mdio_reset,
-        snprintf(new_bus->id, MII_BUS_ID_SIZE, "%x", pdev->id);
-
-        pdata = (struct gianfar_mdio_data *)pdev->dev.platform_data;
-
-        if (NULL == pdata) {
-                printk(KERN_ERR "gfar mdio %d: Missing platform data!\n", pdev->id);
-                return -ENODEV;
-        }
-
-        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        gfar_mdio_bus_name(new_bus->id, np);
 
         /* Set the PHY base address */
-        regs = ioremap(r->start, sizeof (struct gfar_mii));
+        addr = of_translate_address(np, of_get_address(np, 0, &size, NULL));
+        regs = ioremap(addr, size);
 
         if (NULL == regs) {
                 err = -ENOMEM;
-                goto reg_map_fail;
+                goto err_free_bus;
         }
 
         new_bus->priv = (void __force *)regs;
 
-        new_bus->irq = pdata->irq;
+        new_bus->irq = create_irq_map(np);
+
+        if (new_bus->irq == NULL) {
+                err = -ENOMEM;
+                goto err_unmap_regs;
+        }
 
-        new_bus->parent = dev;
-        dev_set_drvdata(dev, new_bus);
+        new_bus->parent = &ofdev->dev;
+        dev_set_drvdata(&ofdev->dev, new_bus);
 
         /*
          * This is mildly evil, but so is our hardware for doing this.
@@ -206,96 +269,109 @@ static int gfar_mdio_probe(struct device *dev)
         enet_regs = (struct gfar __iomem *)
                 ((char *)regs - offsetof(struct gfar, gfar_mii_regs));
 
-        /* Scan the bus, looking for an empty spot for TBIPA */
-        gfar_write(&enet_regs->tbipa, 0);
-        for (i = PHY_MAX_ADDR; i > 0; i--) {
-                u32 phy_id;
+        for_each_child_of_node(np, tbi) {
+                if (!strncmp(tbi->type, "tbi-phy", 8))
+                        break;
+        }
 
-                err = get_phy_id(new_bus, i, &phy_id);
-                if (err)
-                        goto bus_register_fail;
+        if (tbi) {
+                const u32 *prop = of_get_property(tbi, "reg", NULL);
 
-                if (phy_id == 0xffffffff)
-                        break;
+                if (prop)
+                        tbiaddr = *prop;
         }
 
-        /* The bus is full.  We don't support using 31 PHYs, sorry */
-        if (i == 0) {
+        if (tbiaddr == -1) {
+                gfar_write(&enet_regs->tbipa, 0);
+
+                tbiaddr = gfar_mdio_find_free(new_bus);
+        }
+
+        /*
+         * We define TBIPA at 0 to be illegal, opting to fail for boards that
+         * have PHYs at 1-31, rather than change tbipa and rescan.
+         */
+        if (tbiaddr == 0) {
                 err = -EBUSY;
 
-                goto bus_register_fail;
+                goto err_free_irqs;
         }
 
-        gfar_write(&enet_regs->tbipa, i);
+        gfar_write(&enet_regs->tbipa, tbiaddr);
+
+        /*
+         * The TBIPHY-only buses will find PHYs at every address,
+         * so we mask them all but the TBI
+         */
+        if (!of_device_is_compatible(np, "fsl,gianfar-mdio"))
+                new_bus->phy_mask = ~(1 << tbiaddr);
 
         err = mdiobus_register(new_bus);
 
-        if (0 != err) {
+        if (err != 0) {
                 printk (KERN_ERR "%s: Cannot register as MDIO bus\n",
                                 new_bus->name);
-                goto bus_register_fail;
+                goto err_free_irqs;
         }
 
         return 0;
 
-bus_register_fail:
+err_free_irqs:
+        kfree(new_bus->irq);
+err_unmap_regs:
         iounmap(regs);
-reg_map_fail:
+err_free_bus:
         mdiobus_free(new_bus);
 
         return err;
 }
 
 
-static int gfar_mdio_remove(struct device *dev)
+static int gfar_mdio_remove(struct of_device *ofdev)
 {
-        struct mii_bus *bus = dev_get_drvdata(dev);
+        struct mii_bus *bus = dev_get_drvdata(&ofdev->dev);
 
         mdiobus_unregister(bus);
 
-        dev_set_drvdata(dev, NULL);
+        dev_set_drvdata(&ofdev->dev, NULL);
 
         iounmap((void __iomem *)bus->priv);
         bus->priv = NULL;
+        kfree(bus->irq);
         mdiobus_free(bus);
 
         return 0;
 }
 
-static struct device_driver gianfar_mdio_driver = {
+static struct of_device_id gfar_mdio_match[] =
+{
+        {
+                .compatible = "fsl,gianfar-mdio",
+        },
+        {
+                .compatible = "fsl,gianfar-tbi",
+        },
+        {
+                .type = "mdio",
+                .compatible = "gianfar",
+        },
+        {},
+};
+
+static struct of_platform_driver gianfar_mdio_driver = {
         .name = "fsl-gianfar_mdio",
-        .bus = &platform_bus_type,
+        .match_table = gfar_mdio_match,
+
         .probe = gfar_mdio_probe,
         .remove = gfar_mdio_remove,
 };
 
-static int match_mdio_bus(struct device *dev, void *data)
-{
-        const struct gfar_private *priv = data;
-        const struct platform_device *pdev = to_platform_device(dev);
-
-        return !strcmp(pdev->name, gianfar_mdio_driver.name) &&
-                pdev->id == priv->einfo->mdio_bus;
-}
-
-/* Given a gfar_priv structure, find the mii_bus controlled by this device (not
- * necessarily the same as the bus the gfar's PHY is on), if one exists.
- * Normally only the first gianfar controls a mii_bus.  */
-struct mii_bus *gfar_get_miibus(const struct gfar_private *priv)
-{
-        /*const*/ struct device *d;
-
-        d = bus_find_device(gianfar_mdio_driver.bus, NULL, (void *)priv,
-                            match_mdio_bus);
-        return d ? dev_get_drvdata(d) : NULL;
-}
-
 int __init gfar_mdio_init(void)
 {
-        return driver_register(&gianfar_mdio_driver);
+        return of_register_platform_driver(&gianfar_mdio_driver);
 }
 
 void gfar_mdio_exit(void)
 {
-        driver_unregister(&gianfar_mdio_driver);
+        of_unregister_platform_driver(&gianfar_mdio_driver);
 }
diff --git a/drivers/net/gianfar_mii.h b/drivers/net/gianfar_mii.h
index 02dc970ca1ff..65c242cd468a 100644
--- a/drivers/net/gianfar_mii.h
+++ b/drivers/net/gianfar_mii.h
@@ -49,4 +49,6 @@ int gfar_local_mdio_read(struct gfar_mii __iomem *regs, int mii_id, int regnum);
 struct mii_bus *gfar_get_miibus(const struct gfar_private *priv);
 int __init gfar_mdio_init(void);
 void gfar_mdio_exit(void);
+
+void gfar_mdio_bus_name(char *name, struct device_node *np);
 #endif /* GIANFAR_PHY_H */