ifb: add performance flags
[linux-2.6.git] / drivers / net / fs_enet / fs_enet-main.c
index 3e1a57a..d684f18 100644 (file)
 #include <linux/fs.h>
 #include <linux/platform_device.h>
 #include <linux/phy.h>
+#include <linux/of.h>
+#include <linux/of_mdio.h>
+#include <linux/of_platform.h>
+#include <linux/of_gpio.h>
 
 #include <linux/vmalloc.h>
 #include <asm/pgtable.h>
 #include <asm/irq.h>
 #include <asm/uaccess.h>
 
-#ifdef CONFIG_PPC_CPM_NEW_BINDING
-#include <asm/of_platform.h>
-#endif
-
 #include "fs_enet.h"
 
 /*************************************************/
 
-#ifndef CONFIG_PPC_CPM_NEW_BINDING
-static char version[] __devinitdata =
-    DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")" "\n";
-#endif
-
 MODULE_AUTHOR("Pantelis Antoniou <panto@intracom.gr>");
 MODULE_DESCRIPTION("Freescale Ethernet Driver");
 MODULE_LICENSE("GPL");
@@ -113,9 +108,7 @@ static int fs_enet_rx_napi(struct napi_struct *napi, int budget)
                 * the last indicator should be set.
                 */
                if ((sc & BD_ENET_RX_LAST) == 0)
-                       printk(KERN_WARNING DRV_MODULE_NAME
-                              ": %s rcv is not +last\n",
-                              dev->name);
+                       dev_warn(fep->dev, "rcv is not +last\n");
 
                /*
                 * Check for errors.
@@ -183,9 +176,8 @@ static int fs_enet_rx_napi(struct napi_struct *napi, int budget)
                                received++;
                                netif_receive_skb(skb);
                        } else {
-                               printk(KERN_WARNING DRV_MODULE_NAME
-                                      ": %s Memory squeeze, dropping packet.\n",
-                                      dev->name);
+                               dev_warn(fep->dev,
+                                        "Memory squeeze, dropping packet.\n");
                                fep->stats.rx_dropped++;
                                skbn = skb;
                        }
@@ -216,7 +208,7 @@ static int fs_enet_rx_napi(struct napi_struct *napi, int budget)
 
        if (received < budget) {
                /* done */
-               netif_rx_complete(dev, napi);
+               napi_complete(napi);
                (*fep->ops->napi_enable_rx)(dev);
        }
        return received;
@@ -247,9 +239,7 @@ static int fs_enet_rx_non_napi(struct net_device *dev)
                 * the last indicator should be set.
                 */
                if ((sc & BD_ENET_RX_LAST) == 0)
-                       printk(KERN_WARNING DRV_MODULE_NAME
-                              ": %s rcv is not +last\n",
-                              dev->name);
+                       dev_warn(fep->dev, "rcv is not +last\n");
 
                /*
                 * Check for errors.
@@ -318,9 +308,8 @@ static int fs_enet_rx_non_napi(struct net_device *dev)
                                received++;
                                netif_rx(skb);
                        } else {
-                               printk(KERN_WARNING DRV_MODULE_NAME
-                                      ": %s Memory squeeze, dropping packet.\n",
-                                      dev->name);
+                               dev_warn(fep->dev,
+                                        "Memory squeeze, dropping packet.\n");
                                fep->stats.rx_dropped++;
                                skbn = skb;
                        }
@@ -393,10 +382,10 @@ static void fs_enet_tx(struct net_device *dev)
                } else
                        fep->stats.tx_packets++;
 
-               if (sc & BD_ENET_TX_READY)
-                       printk(KERN_WARNING DRV_MODULE_NAME
-                              ": %s HEY! Enet xmit interrupt and TX_READY.\n",
-                              dev->name);
+               if (sc & BD_ENET_TX_READY) {
+                       dev_warn(fep->dev,
+                                "HEY! Enet xmit interrupt and TX_READY.\n");
+               }
 
                /*
                 * Deferred means some collisions occurred during transmit,
@@ -485,7 +474,7 @@ fs_enet_interrupt(int irq, void *dev_id)
                                /* NOTE: it is possible for FCCs in NAPI mode    */
                                /* to submit a spurious interrupt while in poll  */
                                if (napi_ok)
-                                       __netif_rx_schedule(dev, &fep->napi);
+                                       __napi_schedule(&fep->napi);
                        }
                }
 
@@ -516,9 +505,8 @@ void fs_init_bds(struct net_device *dev)
        for (i = 0, bdp = fep->rx_bd_base; i < fep->rx_ring; i++, bdp++) {
                skb = dev_alloc_skb(ENET_RX_FRSIZE);
                if (skb == NULL) {
-                       printk(KERN_WARNING DRV_MODULE_NAME
-                              ": %s Memory squeeze, unable to allocate skb\n",
-                              dev->name);
+                       dev_warn(fep->dev,
+                                "Memory squeeze, unable to allocate skb\n");
                        break;
                }
                skb_align(skb, ENET_RX_ALIGN);
@@ -592,6 +580,40 @@ void fs_cleanup_bds(struct net_device *dev)
 
 /**********************************************************************************/
 
+#ifdef CONFIG_FS_ENET_MPC5121_FEC
+/*
+ * MPC5121 FEC requeries 4-byte alignment for TX data buffer!
+ */
+static struct sk_buff *tx_skb_align_workaround(struct net_device *dev,
+                                              struct sk_buff *skb)
+{
+       struct sk_buff *new_skb;
+       struct fs_enet_private *fep = netdev_priv(dev);
+
+       /* Alloc new skb */
+       new_skb = dev_alloc_skb(skb->len + 4);
+       if (!new_skb) {
+               if (net_ratelimit()) {
+                       dev_warn(fep->dev,
+                                "Memory squeeze, dropping tx packet.\n");
+               }
+               return NULL;
+       }
+
+       /* Make sure new skb is properly aligned */
+       skb_align(new_skb, 4);
+
+       /* Copy data to new skb ... */
+       skb_copy_from_linear_data(skb, new_skb->data, skb->len);
+       skb_put(new_skb, skb->len);
+
+       /* ... and free an old one */
+       dev_kfree_skb_any(skb);
+
+       return new_skb;
+}
+#endif
+
 static int fs_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
        struct fs_enet_private *fep = netdev_priv(dev);
@@ -600,6 +622,19 @@ static int fs_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
        u16 sc;
        unsigned long flags;
 
+#ifdef CONFIG_FS_ENET_MPC5121_FEC
+       if (((unsigned long)skb->data) & 0x3) {
+               skb = tx_skb_align_workaround(dev, skb);
+               if (!skb) {
+                       /*
+                        * We have lost packet due to memory allocation error
+                        * in tx_skb_align_workaround(). Hopefully original
+                        * skb is still valid, so try transmit it later.
+                        */
+                       return NETDEV_TX_BUSY;
+               }
+       }
+#endif
        spin_lock_irqsave(&fep->tx_lock, flags);
 
        /*
@@ -615,8 +650,7 @@ static int fs_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 * Ooops.  All transmit buffers are full.  Bail out.
                 * This should not happen, since the tx queue should be stopped.
                 */
-               printk(KERN_WARNING DRV_MODULE_NAME
-                      ": %s tx queue full!.\n", dev->name);
+               dev_warn(fep->dev, "tx queue full!.\n");
                return NETDEV_TX_BUSY;
        }
 
@@ -640,8 +674,6 @@ static int fs_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
                                skb->data, skb->len, DMA_TO_DEVICE));
        CBDW_DATLEN(bdp, skb->len);
 
-       dev->trans_start = jiffies;
-
        /*
         * If this was the last BD in the ring, start at the beginning again.
         */
@@ -671,23 +703,6 @@ static int fs_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
        return NETDEV_TX_OK;
 }
 
-static int fs_request_irq(struct net_device *dev, int irq, const char *name,
-               irq_handler_t irqf)
-{
-       struct fs_enet_private *fep = netdev_priv(dev);
-
-       (*fep->ops->pre_request_irq)(dev, irq);
-       return request_irq(irq, irqf, IRQF_SHARED, name, dev);
-}
-
-static void fs_free_irq(struct net_device *dev, int irq)
-{
-       struct fs_enet_private *fep = netdev_priv(dev);
-
-       free_irq(irq, dev);
-       (*fep->ops->post_free_irq)(dev, irq);
-}
-
 static void fs_timeout(struct net_device *dev)
 {
        struct fs_enet_private *fep = netdev_priv(dev);
@@ -737,9 +752,6 @@ static void generic_adjust_link(struct  net_device *dev)
                if (!fep->oldlink) {
                        new_state = 1;
                        fep->oldlink = 1;
-                       netif_schedule(dev);
-                       netif_carrier_on(dev);
-                       netif_start_queue(dev);
                }
 
                if (new_state)
@@ -749,8 +761,6 @@ static void generic_adjust_link(struct  net_device *dev)
                fep->oldlink = 0;
                fep->oldspeed = 0;
                fep->oldduplex = -1;
-               netif_carrier_off(dev);
-               netif_stop_queue(dev);
        }
 
        if (new_state && netif_msg_link(fep))
@@ -781,16 +791,16 @@ static int fs_init_phy(struct net_device *dev)
        fep->oldlink = 0;
        fep->oldspeed = 0;
        fep->oldduplex = -1;
-       if(fep->fpi->bus_id)
-               phydev = phy_connect(dev, fep->fpi->bus_id, &fs_adjust_link, 0,
+
+       phydev = of_phy_connect(dev, fep->fpi->phy_node, &fs_adjust_link, 0,
                                PHY_INTERFACE_MODE_MII);
-       else {
-               printk("No phy bus ID specified in BSP code\n");
-               return -EINVAL;
+       if (!phydev) {
+               phydev = of_phy_connect_fixed_link(dev, &fs_adjust_link,
+                                                  PHY_INTERFACE_MODE_MII);
        }
-       if (IS_ERR(phydev)) {
-               printk(KERN_ERR "%s: Could not attach to PHY\n", dev->name);
-               return PTR_ERR(phydev);
+       if (!phydev) {
+               dev_err(&dev->dev, "Could not attach to PHY\n");
+               return -ENODEV;
        }
 
        fep->phydev = phydev;
@@ -804,14 +814,18 @@ static int fs_enet_open(struct net_device *dev)
        int r;
        int err;
 
+       /* to initialize the fep->cur_rx,... */
+       /* not doing this, will cause a crash in fs_enet_rx_napi */
+       fs_init_bds(fep->ndev);
+
        if (fep->fpi->use_napi)
                napi_enable(&fep->napi);
 
        /* Install our interrupt handler. */
-       r = fs_request_irq(dev, fep->interrupt, "fs_enet-mac", fs_enet_interrupt);
+       r = request_irq(fep->interrupt, fs_enet_interrupt, IRQF_SHARED,
+                       "fs_enet-mac", dev);
        if (r != 0) {
-               printk(KERN_ERR DRV_MODULE_NAME
-                      ": %s Could not allocate FS_ENET IRQ!", dev->name);
+               dev_err(fep->dev, "Could not allocate FS_ENET IRQ!");
                if (fep->fpi->use_napi)
                        napi_disable(&fep->napi);
                return -EINVAL;
@@ -819,12 +833,15 @@ static int fs_enet_open(struct net_device *dev)
 
        err = fs_init_phy(dev);
        if (err) {
+               free_irq(fep->interrupt, dev);
                if (fep->fpi->use_napi)
                        napi_disable(&fep->napi);
                return err;
        }
        phy_start(fep->phydev);
 
+       netif_start_queue(dev);
+
        return 0;
 }
 
@@ -835,7 +852,8 @@ static int fs_enet_close(struct net_device *dev)
 
        netif_stop_queue(dev);
        netif_carrier_off(dev);
-       napi_disable(&fep->napi);
+       if (fep->fpi->use_napi)
+               napi_disable(&fep->napi);
        phy_stop(fep->phydev);
 
        spin_lock_irqsave(&fep->lock, flags);
@@ -847,7 +865,7 @@ static int fs_enet_close(struct net_device *dev)
        /* release any irqs */
        phy_disconnect(fep->phydev);
        fep->phydev = NULL;
-       fs_free_irq(dev, fep->interrupt);
+       free_irq(fep->interrupt, dev);
 
        return 0;
 }
@@ -894,14 +912,21 @@ static void fs_get_regs(struct net_device *dev, struct ethtool_regs *regs,
 static int fs_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
        struct fs_enet_private *fep = netdev_priv(dev);
+
+       if (!fep->phydev)
+               return -ENODEV;
+
        return phy_ethtool_gset(fep->phydev, cmd);
 }
 
 static int fs_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
        struct fs_enet_private *fep = netdev_priv(dev);
-       phy_ethtool_sset(fep->phydev, cmd);
-       return 0;
+
+       if (!fep->phydev)
+               return -ENODEV;
+
+       return phy_ethtool_sset(fep->phydev, cmd);
 }
 
 static int fs_nway_reset(struct net_device *dev)
@@ -938,276 +963,41 @@ static const struct ethtool_ops fs_ethtool_ops = {
 static int fs_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 {
        struct fs_enet_private *fep = netdev_priv(dev);
-       struct mii_ioctl_data *mii = (struct mii_ioctl_data *)&rq->ifr_data;
-       unsigned long flags;
-       int rc;
 
        if (!netif_running(dev))
                return -EINVAL;
 
-       spin_lock_irqsave(&fep->lock, flags);
-       rc = phy_mii_ioctl(fep->phydev, mii, cmd);
-       spin_unlock_irqrestore(&fep->lock, flags);
-       return rc;
+       return phy_mii_ioctl(fep->phydev, rq, cmd);
 }
 
 extern int fs_mii_connect(struct net_device *dev);
 extern void fs_mii_disconnect(struct net_device *dev);
 
-#ifndef CONFIG_PPC_CPM_NEW_BINDING
-static struct net_device *fs_init_instance(struct device *dev,
-               struct fs_platform_info *fpi)
-{
-       struct net_device *ndev = NULL;
-       struct fs_enet_private *fep = NULL;
-       int privsize, i, r, err = 0, registered = 0;
-
-       fpi->fs_no = fs_get_id(fpi);
-       /* guard */
-       if ((unsigned int)fpi->fs_no >= FS_MAX_INDEX)
-               return ERR_PTR(-EINVAL);
-
-       privsize = sizeof(*fep) + (sizeof(struct sk_buff **) *
-                           (fpi->rx_ring + fpi->tx_ring));
-
-       ndev = alloc_etherdev(privsize);
-       if (!ndev) {
-               err = -ENOMEM;
-               goto err;
-       }
-
-       fep = netdev_priv(ndev);
-
-       fep->dev = dev;
-       dev_set_drvdata(dev, ndev);
-       fep->fpi = fpi;
-       if (fpi->init_ioports)
-               fpi->init_ioports((struct fs_platform_info *)fpi);
-
-#ifdef CONFIG_FS_ENET_HAS_FEC
-       if (fs_get_fec_index(fpi->fs_no) >= 0)
-               fep->ops = &fs_fec_ops;
-#endif
-
-#ifdef CONFIG_FS_ENET_HAS_SCC
-       if (fs_get_scc_index(fpi->fs_no) >=0)
-               fep->ops = &fs_scc_ops;
-#endif
-
-#ifdef CONFIG_FS_ENET_HAS_FCC
-       if (fs_get_fcc_index(fpi->fs_no) >= 0)
-               fep->ops = &fs_fcc_ops;
-#endif
-
-       if (fep->ops == NULL) {
-               printk(KERN_ERR DRV_MODULE_NAME
-                      ": %s No matching ops found (%d).\n",
-                      ndev->name, fpi->fs_no);
-               err = -EINVAL;
-               goto err;
-       }
-
-       r = (*fep->ops->setup_data)(ndev);
-       if (r != 0) {
-               printk(KERN_ERR DRV_MODULE_NAME
-                      ": %s setup_data failed\n",
-                       ndev->name);
-               err = r;
-               goto err;
-       }
-
-       /* point rx_skbuff, tx_skbuff */
-       fep->rx_skbuff = (struct sk_buff **)&fep[1];
-       fep->tx_skbuff = fep->rx_skbuff + fpi->rx_ring;
-
-       /* init locks */
-       spin_lock_init(&fep->lock);
-       spin_lock_init(&fep->tx_lock);
-
-       /*
-        * Set the Ethernet address.
-        */
-       for (i = 0; i < 6; i++)
-               ndev->dev_addr[i] = fpi->macaddr[i];
-
-       r = (*fep->ops->allocate_bd)(ndev);
-
-       if (fep->ring_base == NULL) {
-               printk(KERN_ERR DRV_MODULE_NAME
-                      ": %s buffer descriptor alloc failed (%d).\n", ndev->name, r);
-               err = r;
-               goto err;
-       }
-
-       /*
-        * Set receive and transmit descriptor base.
-        */
-       fep->rx_bd_base = fep->ring_base;
-       fep->tx_bd_base = fep->rx_bd_base + fpi->rx_ring;
-
-       /* initialize ring size variables */
-       fep->tx_ring = fpi->tx_ring;
-       fep->rx_ring = fpi->rx_ring;
-
-       /*
-        * The FEC Ethernet specific entries in the device structure.
-        */
-       ndev->open = fs_enet_open;
-       ndev->hard_start_xmit = fs_enet_start_xmit;
-       ndev->tx_timeout = fs_timeout;
-       ndev->watchdog_timeo = 2 * HZ;
-       ndev->stop = fs_enet_close;
-       ndev->get_stats = fs_enet_get_stats;
-       ndev->set_multicast_list = fs_set_multicast_list;
-
-#ifdef CONFIG_NET_POLL_CONTROLLER
-       ndev->poll_controller = fs_enet_netpoll;
-#endif
-
-       netif_napi_add(ndev, &fep->napi,
-                      fs_enet_rx_napi, fpi->napi_weight);
-
-       ndev->ethtool_ops = &fs_ethtool_ops;
-       ndev->do_ioctl = fs_ioctl;
-
-       init_timer(&fep->phy_timer_list);
-
-       netif_carrier_off(ndev);
-
-       err = register_netdev(ndev);
-       if (err != 0) {
-               printk(KERN_ERR DRV_MODULE_NAME
-                      ": %s register_netdev failed.\n", ndev->name);
-               goto err;
-       }
-       registered = 1;
-
-
-       return ndev;
-
-err:
-       if (ndev != NULL) {
-               if (registered)
-                       unregister_netdev(ndev);
-
-               if (fep != NULL) {
-                       (*fep->ops->free_bd)(ndev);
-                       (*fep->ops->cleanup_data)(ndev);
-               }
-
-               free_netdev(ndev);
-       }
-
-       dev_set_drvdata(dev, NULL);
-
-       return ERR_PTR(err);
-}
-
-static int fs_cleanup_instance(struct net_device *ndev)
-{
-       struct fs_enet_private *fep;
-       const struct fs_platform_info *fpi;
-       struct device *dev;
-
-       if (ndev == NULL)
-               return -EINVAL;
-
-       fep = netdev_priv(ndev);
-       if (fep == NULL)
-               return -EINVAL;
-
-       fpi = fep->fpi;
-
-       unregister_netdev(ndev);
-
-       dma_free_coherent(fep->dev, (fpi->tx_ring + fpi->rx_ring) * sizeof(cbd_t),
-                         (void __force *)fep->ring_base, fep->ring_mem_addr);
-
-       /* reset it */
-       (*fep->ops->cleanup_data)(ndev);
-
-       dev = fep->dev;
-       if (dev != NULL) {
-               dev_set_drvdata(dev, NULL);
-               fep->dev = NULL;
-       }
-
-       free_netdev(ndev);
-
-       return 0;
-}
-#endif
-
-/**************************************************************************************/
-
-/* handy pointer to the immap */
-void __iomem *fs_enet_immap = NULL;
-
-static int setup_immap(void)
-{
-#ifdef CONFIG_CPM1
-       fs_enet_immap = ioremap(IMAP_ADDR, 0x4000);
-       WARN_ON(!fs_enet_immap);
-#elif defined(CONFIG_CPM2)
-       fs_enet_immap = cpm2_immr;
-#endif
-
-       return 0;
-}
-
-static void cleanup_immap(void)
-{
-#if defined(CONFIG_CPM1)
-       iounmap(fs_enet_immap);
-#endif
-}
-
 /**************************************************************************************/
 
-#ifdef CONFIG_PPC_CPM_NEW_BINDING
-static int __devinit find_phy(struct device_node *np,
-                              struct fs_platform_info *fpi)
-{
-       struct device_node *phynode, *mdionode;
-       struct resource res;
-       int ret = 0, len;
-
-       const u32 *data = of_get_property(np, "phy-handle", &len);
-       if (!data || len != 4)
-               return -EINVAL;
-
-       phynode = of_find_node_by_phandle(*data);
-       if (!phynode)
-               return -EINVAL;
-
-       mdionode = of_get_parent(phynode);
-       if (!mdionode)
-               goto out_put_phy;
-
-       ret = of_address_to_resource(mdionode, 0, &res);
-       if (ret)
-               goto out_put_mdio;
-
-       data = of_get_property(phynode, "reg", &len);
-       if (!data || len != 4)
-               goto out_put_mdio;
-
-       snprintf(fpi->bus_id, 16, PHY_ID_FMT, res.start, *data);
-
-out_put_mdio:
-       of_node_put(mdionode);
-out_put_phy:
-       of_node_put(phynode);
-       return ret;
-}
-
 #ifdef CONFIG_FS_ENET_HAS_FEC
 #define IS_FEC(match) ((match)->data == &fs_fec_ops)
 #else
 #define IS_FEC(match) 0
 #endif
 
-static int __devinit fs_enet_probe(struct of_device *ofdev,
+static const struct net_device_ops fs_enet_netdev_ops = {
+       .ndo_open               = fs_enet_open,
+       .ndo_stop               = fs_enet_close,
+       .ndo_get_stats          = fs_enet_get_stats,
+       .ndo_start_xmit         = fs_enet_start_xmit,
+       .ndo_tx_timeout         = fs_timeout,
+       .ndo_set_multicast_list = fs_set_multicast_list,
+       .ndo_do_ioctl           = fs_ioctl,
+       .ndo_validate_addr      = eth_validate_addr,
+       .ndo_set_mac_address    = eth_mac_addr,
+       .ndo_change_mtu         = eth_change_mtu,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+       .ndo_poll_controller    = fs_enet_netpoll,
+#endif
+};
+
+static int __devinit fs_enet_probe(struct platform_device *ofdev,
                                    const struct of_device_id *match)
 {
        struct net_device *ndev;
@@ -1222,7 +1012,7 @@ static int __devinit fs_enet_probe(struct of_device *ofdev,
                return -ENOMEM;
 
        if (!IS_FEC(match)) {
-               data = of_get_property(ofdev->node, "fsl,cpm-command", &len);
+               data = of_get_property(ofdev->dev.of_node, "fsl,cpm-command", &len);
                if (!data || len != 4)
                        goto out_free_fpi;
 
@@ -1234,9 +1024,9 @@ static int __devinit fs_enet_probe(struct of_device *ofdev,
        fpi->rx_copybreak = 240;
        fpi->use_napi = 1;
        fpi->napi_weight = 17;
-
-       ret = find_phy(ofdev->node, fpi);
-       if (ret)
+       fpi->phy_node = of_parse_phandle(ofdev->dev.of_node, "phy-handle", 0);
+       if ((!fpi->phy_node) && (!of_get_property(ofdev->dev.of_node, "fixed-link",
+                                                 NULL)))
                goto out_free_fpi;
 
        privsize = sizeof(*fep) +
@@ -1246,9 +1036,10 @@ static int __devinit fs_enet_probe(struct of_device *ofdev,
        ndev = alloc_etherdev(privsize);
        if (!ndev) {
                ret = -ENOMEM;
-               goto out_free_fpi;
+               goto out_put;
        }
 
+       SET_NETDEV_DEV(ndev, &ofdev->dev);
        dev_set_drvdata(&ofdev->dev, ndev);
 
        fep = netdev_priv(ndev);
@@ -1267,7 +1058,7 @@ static int __devinit fs_enet_probe(struct of_device *ofdev,
        spin_lock_init(&fep->lock);
        spin_lock_init(&fep->tx_lock);
 
-       mac_addr = of_get_mac_address(ofdev->node);
+       mac_addr = of_get_mac_address(ofdev->dev.of_node);
        if (mac_addr)
                memcpy(ndev->dev_addr, mac_addr, 6);
 
@@ -1281,20 +1072,13 @@ static int __devinit fs_enet_probe(struct of_device *ofdev,
        fep->tx_ring = fpi->tx_ring;
        fep->rx_ring = fpi->rx_ring;
 
-       ndev->open = fs_enet_open;
-       ndev->hard_start_xmit = fs_enet_start_xmit;
-       ndev->tx_timeout = fs_timeout;
+       ndev->netdev_ops = &fs_enet_netdev_ops;
        ndev->watchdog_timeo = 2 * HZ;
-       ndev->stop = fs_enet_close;
-       ndev->get_stats = fs_enet_get_stats;
-       ndev->set_multicast_list = fs_set_multicast_list;
-
        if (fpi->use_napi)
                netif_napi_add(ndev, &fep->napi, fs_enet_rx_napi,
                               fpi->napi_weight);
 
        ndev->ethtool_ops = &fs_ethtool_ops;
-       ndev->do_ioctl = fs_ioctl;
 
        init_timer(&fep->phy_timer_list);
 
@@ -1304,10 +1088,7 @@ static int __devinit fs_enet_probe(struct of_device *ofdev,
        if (ret)
                goto out_free_bd;
 
-       printk(KERN_INFO "%s: fs_enet: %02x:%02x:%02x:%02x:%02x:%02x\n",
-              ndev->name,
-              ndev->dev_addr[0], ndev->dev_addr[1], ndev->dev_addr[2],
-              ndev->dev_addr[3], ndev->dev_addr[4], ndev->dev_addr[5]);
+       pr_info("%s: fs_enet: %pM\n", ndev->name, ndev->dev_addr);
 
        return 0;
 
@@ -1318,12 +1099,14 @@ out_cleanup_data:
 out_free_dev:
        free_netdev(ndev);
        dev_set_drvdata(&ofdev->dev, NULL);
+out_put:
+       of_node_put(fpi->phy_node);
 out_free_fpi:
        kfree(fpi);
        return ret;
 }
 
-static int fs_enet_remove(struct of_device *ofdev)
+static int fs_enet_remove(struct platform_device *ofdev)
 {
        struct net_device *ndev = dev_get_drvdata(&ofdev->dev);
        struct fs_enet_private *fep = netdev_priv(ndev);
@@ -1333,7 +1116,7 @@ static int fs_enet_remove(struct of_device *ofdev)
        fep->ops->free_bd(ndev);
        fep->ops->cleanup_data(ndev);
        dev_set_drvdata(fep->dev, NULL);
-
+       of_node_put(fep->fpi->phy_node);
        free_netdev(ndev);
        return 0;
 }
@@ -1344,6 +1127,10 @@ static struct of_device_id fs_enet_match[] = {
                .compatible = "fsl,cpm1-scc-enet",
                .data = (void *)&fs_scc_ops,
        },
+       {
+               .compatible = "fsl,cpm2-scc-enet",
+               .data = (void *)&fs_scc_ops,
+       },
 #endif
 #ifdef CONFIG_FS_ENET_HAS_FCC
        {
@@ -1352,164 +1139,47 @@ static struct of_device_id fs_enet_match[] = {
        },
 #endif
 #ifdef CONFIG_FS_ENET_HAS_FEC
+#ifdef CONFIG_FS_ENET_MPC5121_FEC
+       {
+               .compatible = "fsl,mpc5121-fec",
+               .data = (void *)&fs_fec_ops,
+       },
+#else
        {
                .compatible = "fsl,pq1-fec-enet",
                .data = (void *)&fs_fec_ops,
        },
 #endif
+#endif
        {}
 };
+MODULE_DEVICE_TABLE(of, fs_enet_match);
 
 static struct of_platform_driver fs_enet_driver = {
-       .name   = "fs_enet",
-       .match_table = fs_enet_match,
+       .driver = {
+               .owner = THIS_MODULE,
+               .name = "fs_enet",
+               .of_match_table = fs_enet_match,
+       },
        .probe = fs_enet_probe,
        .remove = fs_enet_remove,
 };
 
 static int __init fs_init(void)
 {
-       int r = setup_immap();
-       if (r != 0)
-               return r;
-
-       r = of_register_platform_driver(&fs_enet_driver);
-       if (r != 0)
-               goto out;
-
-       return 0;
-
-out:
-       cleanup_immap();
-       return r;
+       return of_register_platform_driver(&fs_enet_driver);
 }
 
 static void __exit fs_cleanup(void)
 {
        of_unregister_platform_driver(&fs_enet_driver);
-       cleanup_immap();
 }
-#else
-static int __devinit fs_enet_probe(struct device *dev)
-{
-       struct net_device *ndev;
-
-       /* no fixup - no device */
-       if (dev->platform_data == NULL) {
-               printk(KERN_INFO "fs_enet: "
-                               "probe called with no platform data; "
-                               "remove unused devices\n");
-               return -ENODEV;
-       }
-
-       ndev = fs_init_instance(dev, dev->platform_data);
-       if (IS_ERR(ndev))
-               return PTR_ERR(ndev);
-       return 0;
-}
-
-static int fs_enet_remove(struct device *dev)
-{
-       return fs_cleanup_instance(dev_get_drvdata(dev));
-}
-
-static struct device_driver fs_enet_fec_driver = {
-       .name           = "fsl-cpm-fec",
-       .bus            = &platform_bus_type,
-       .probe          = fs_enet_probe,
-       .remove         = fs_enet_remove,
-#ifdef CONFIG_PM
-/*     .suspend        = fs_enet_suspend,      TODO */
-/*     .resume         = fs_enet_resume,       TODO */
-#endif
-};
-
-static struct device_driver fs_enet_scc_driver = {
-       .name           = "fsl-cpm-scc",
-       .bus            = &platform_bus_type,
-       .probe          = fs_enet_probe,
-       .remove         = fs_enet_remove,
-#ifdef CONFIG_PM
-/*     .suspend        = fs_enet_suspend,      TODO */
-/*     .resume         = fs_enet_resume,       TODO */
-#endif
-};
-
-static struct device_driver fs_enet_fcc_driver = {
-       .name           = "fsl-cpm-fcc",
-       .bus            = &platform_bus_type,
-       .probe          = fs_enet_probe,
-       .remove         = fs_enet_remove,
-#ifdef CONFIG_PM
-/*     .suspend        = fs_enet_suspend,      TODO */
-/*     .resume         = fs_enet_resume,       TODO */
-#endif
-};
-
-static int __init fs_init(void)
-{
-       int r;
-
-       printk(KERN_INFO
-                       "%s", version);
-
-       r = setup_immap();
-       if (r != 0)
-               return r;
-
-#ifdef CONFIG_FS_ENET_HAS_FCC
-       /* let's insert mii stuff */
-       r = fs_enet_mdio_bb_init();
-
-       if (r != 0) {
-               printk(KERN_ERR DRV_MODULE_NAME
-                       "BB PHY init failed.\n");
-               return r;
-       }
-       r = driver_register(&fs_enet_fcc_driver);
-       if (r != 0)
-               goto err;
-#endif
-
-#ifdef CONFIG_FS_ENET_HAS_FEC
-       r =  fs_enet_mdio_fec_init();
-       if (r != 0) {
-               printk(KERN_ERR DRV_MODULE_NAME
-                       "FEC PHY init failed.\n");
-               return r;
-       }
-
-       r = driver_register(&fs_enet_fec_driver);
-       if (r != 0)
-               goto err;
-#endif
-
-#ifdef CONFIG_FS_ENET_HAS_SCC
-       r = driver_register(&fs_enet_scc_driver);
-       if (r != 0)
-               goto err;
-#endif
-
-       return 0;
-err:
-       cleanup_immap();
-       return r;
-}
-
-static void __exit fs_cleanup(void)
-{
-       driver_unregister(&fs_enet_fec_driver);
-       driver_unregister(&fs_enet_fcc_driver);
-       driver_unregister(&fs_enet_scc_driver);
-       cleanup_immap();
-}
-#endif
 
 #ifdef CONFIG_NET_POLL_CONTROLLER
 static void fs_enet_netpoll(struct net_device *dev)
 {
        disable_irq(dev->irq);
-       fs_enet_interrupt(dev->irq, dev, NULL);
+       fs_enet_interrupt(dev->irq, dev);
        enable_irq(dev->irq);
 }
 #endif