static int greth_of_remove(struct platform_device *of_dev)
 {
-       struct net_device *ndev = dev_get_drvdata(&of_dev->dev);
+       struct net_device *ndev = platform_get_drvdata(of_dev);
        struct greth_private *greth = netdev_priv(ndev);
 
        /* Free descriptor areas */
 
        dma_free_coherent(&of_dev->dev, 1024, greth->tx_bd_base, greth->tx_bd_base_phys);
 
-       dev_set_drvdata(&of_dev->dev, NULL);
-
        if (greth->phy)
                phy_stop(greth->phy);
        mdiobus_unregister(greth->mdio);
 
                goto fail;
        }
 
-       dev_set_drvdata(&op->dev, lp);
+       platform_set_drvdata(op, lp);
 
        printk(KERN_INFO "%s: LANCE %pM\n",
               dev->name, dev->dev_addr);
 
 static int sunlance_sbus_remove(struct platform_device *op)
 {
-       struct lance_private *lp = dev_get_drvdata(&op->dev);
+       struct lance_private *lp = platform_get_drvdata(op);
        struct net_device *net_dev = lp->dev;
 
        unregister_netdev(net_dev);
 
        free_netdev(net_dev);
 
-       dev_set_drvdata(&op->dev, NULL);
-
        return 0;
 }
 
 
 
 static int sbmac_init(struct platform_device *pldev, long long base)
 {
-       struct net_device *dev = dev_get_drvdata(&pldev->dev);
+       struct net_device *dev = platform_get_drvdata(pldev);
        int idx = pldev->id;
        struct sbmac_softc *sc = netdev_priv(dev);
        unsigned char *eaddr;
                       dev->name);
                goto free_mdio;
        }
-       dev_set_drvdata(&pldev->dev, sc->mii_bus);
+       platform_set_drvdata(pldev, sc->mii_bus);
 
        err = register_netdev(dev);
        if (err) {
        return 0;
 unreg_mdio:
        mdiobus_unregister(sc->mii_bus);
-       dev_set_drvdata(&pldev->dev, NULL);
 free_mdio:
        mdiobus_free(sc->mii_bus);
 uninit_ctx:
                goto out_unmap;
        }
 
-       dev_set_drvdata(&pldev->dev, dev);
+       platform_set_drvdata(pldev, dev);
        SET_NETDEV_DEV(dev, &pldev->dev);
 
        sc = netdev_priv(dev);
 
 static int __exit sbmac_remove(struct platform_device *pldev)
 {
-       struct net_device *dev = dev_get_drvdata(&pldev->dev);
+       struct net_device *dev = platform_get_drvdata(pldev);
        struct sbmac_softc *sc = netdev_priv(dev);
 
        unregister_netdev(dev);
 
                goto err_node;
 
        /* We're done ! */
-       dev_set_drvdata(&op->dev, ndev);
+       platform_set_drvdata(op, ndev);
        netdev_info(ndev, "%s MAC %pM\n",
                    op->dev.of_node->full_name, ndev->dev_addr);
 
        struct net_device *ndev;
        struct mpc52xx_fec_priv *priv;
 
-       ndev = dev_get_drvdata(&op->dev);
+       ndev = platform_get_drvdata(op);
        priv = netdev_priv(ndev);
 
        unregister_netdev(ndev);
 
        free_netdev(ndev);
 
-       dev_set_drvdata(&op->dev, NULL);
        return 0;
 }
 
 #ifdef CONFIG_PM
 static int mpc52xx_fec_of_suspend(struct platform_device *op, pm_message_t state)
 {
-       struct net_device *dev = dev_get_drvdata(&op->dev);
+       struct net_device *dev = platform_get_drvdata(op);
 
        if (netif_running(dev))
                mpc52xx_fec_close(dev);
 
 static int mpc52xx_fec_of_resume(struct platform_device *op)
 {
-       struct net_device *dev = dev_get_drvdata(&op->dev);
+       struct net_device *dev = platform_get_drvdata(op);
 
        mpc52xx_fec_hw_init(dev);
        mpc52xx_fec_reset_stats(dev);
 
        }
 
        SET_NETDEV_DEV(ndev, &ofdev->dev);
-       dev_set_drvdata(&ofdev->dev, ndev);
+       platform_set_drvdata(ofdev, ndev);
 
        fep = netdev_priv(ndev);
        fep->dev = &ofdev->dev;
        fep->ops->cleanup_data(ndev);
 out_free_dev:
        free_netdev(ndev);
-       dev_set_drvdata(&ofdev->dev, NULL);
 out_put:
        of_node_put(fpi->phy_node);
 out_free_fpi:
 
 static int fs_enet_remove(struct platform_device *ofdev)
 {
-       struct net_device *ndev = dev_get_drvdata(&ofdev->dev);
+       struct net_device *ndev = platform_get_drvdata(ofdev);
        struct fs_enet_private *fep = netdev_priv(ndev);
 
        unregister_netdev(ndev);
 
        }
 
        new_bus->parent = &ofdev->dev;
-       dev_set_drvdata(&ofdev->dev, new_bus);
+       platform_set_drvdata(ofdev, new_bus);
 
        ret = of_mdiobus_register(new_bus, ofdev->dev.of_node);
        if (ret)
        return 0;
 
 out_free_irqs:
-       dev_set_drvdata(&ofdev->dev, NULL);
        kfree(new_bus->irq);
 out_unmap_regs:
        iounmap(bitbang->dir);
 
 static int fs_enet_mdio_remove(struct platform_device *ofdev)
 {
-       struct mii_bus *bus = dev_get_drvdata(&ofdev->dev);
+       struct mii_bus *bus = platform_get_drvdata(ofdev);
        struct bb_info *bitbang = bus->priv;
 
        mdiobus_unregister(bus);
-       dev_set_drvdata(&ofdev->dev, NULL);
        kfree(bus->irq);
        free_mdio_bitbang(bus);
        iounmap(bitbang->dir);
 
        }
 
        new_bus->parent = &ofdev->dev;
-       dev_set_drvdata(&ofdev->dev, new_bus);
+       platform_set_drvdata(ofdev, new_bus);
 
        ret = of_mdiobus_register(new_bus, ofdev->dev.of_node);
        if (ret)
        return 0;
 
 out_free_irqs:
-       dev_set_drvdata(&ofdev->dev, NULL);
        kfree(new_bus->irq);
 out_unmap_regs:
        iounmap(fec->fecp);
 
 static int fs_enet_mdio_remove(struct platform_device *ofdev)
 {
-       struct mii_bus *bus = dev_get_drvdata(&ofdev->dev);
+       struct mii_bus *bus = platform_get_drvdata(ofdev);
        struct fec_info *fec = bus->priv;
 
        mdiobus_unregister(bus);
-       dev_set_drvdata(&ofdev->dev, NULL);
        kfree(bus->irq);
        iounmap(fec->fecp);
        kfree(fec);
 
        spin_lock_init(&priv->bflock);
        INIT_WORK(&priv->reset_task, gfar_reset_task);
 
-       dev_set_drvdata(&ofdev->dev, priv);
+       platform_set_drvdata(ofdev, priv);
        regs = priv->gfargrp[0].regs;
 
        gfar_detect_errata(priv);
 
 static int gfar_remove(struct platform_device *ofdev)
 {
-       struct gfar_private *priv = dev_get_drvdata(&ofdev->dev);
+       struct gfar_private *priv = platform_get_drvdata(ofdev);
 
        if (priv->phy_node)
                of_node_put(priv->phy_node);
        if (priv->tbi_node)
                of_node_put(priv->tbi_node);
 
-       dev_set_drvdata(&ofdev->dev, NULL);
-
        unregister_netdev(priv->ndev);
        unmap_group_regs(priv);
        free_gfar_dev(priv);
 
        }
        gfar_phc_index = ptp_clock_index(etsects->clock);
 
-       dev_set_drvdata(&dev->dev, etsects);
+       platform_set_drvdata(dev, etsects);
 
        return 0;
 
 
 static int gianfar_ptp_remove(struct platform_device *dev)
 {
-       struct etsects *etsects = dev_get_drvdata(&dev->dev);
+       struct etsects *etsects = platform_get_drvdata(dev);
 
        gfar_write(&etsects->regs->tmr_temask, 0);
        gfar_write(&etsects->regs->tmr_ctrl,   0);
 
 
 static int ucc_geth_suspend(struct platform_device *ofdev, pm_message_t state)
 {
-       struct net_device *ndev = dev_get_drvdata(&ofdev->dev);
+       struct net_device *ndev = platform_get_drvdata(ofdev);
        struct ucc_geth_private *ugeth = netdev_priv(ndev);
 
        if (!netif_running(ndev))
 
 static int ucc_geth_resume(struct platform_device *ofdev)
 {
-       struct net_device *ndev = dev_get_drvdata(&ofdev->dev);
+       struct net_device *ndev = platform_get_drvdata(ofdev);
        struct ucc_geth_private *ugeth = netdev_priv(ndev);
        int err;
 
 
                goto err_registration;
        }
 
-       dev_set_drvdata(&pdev->dev, bus);
+       platform_set_drvdata(pdev, bus);
 
        return 0;
 
 
 static int xgmac_mdio_remove(struct platform_device *pdev)
 {
-       struct mii_bus *bus = dev_get_drvdata(&pdev->dev);
+       struct mii_bus *bus = platform_get_drvdata(pdev);
 
        mdiobus_unregister(bus);
        iounmap(bus->priv);
 
 
        adapter->pd = EHEA_PD_ID;
 
-       dev_set_drvdata(&dev->dev, adapter);
+       platform_set_drvdata(dev, adapter);
 
 
        /* initialize adapter and ports */
 
 static int ehea_remove(struct platform_device *dev)
 {
-       struct ehea_adapter *adapter = dev_get_drvdata(&dev->dev);
+       struct ehea_adapter *adapter = platform_get_drvdata(dev);
        int i;
 
        for (i = 0; i < EHEA_MAX_PORTS; i++)
 
 
        /* Advertise this instance to the rest of the world */
        wmb();
-       dev_set_drvdata(&ofdev->dev, mal);
+       platform_set_drvdata(ofdev, mal);
 
        mal_dbg_register(mal);
 
 
 static int mal_remove(struct platform_device *ofdev)
 {
-       struct mal_instance *mal = dev_get_drvdata(&ofdev->dev);
+       struct mal_instance *mal = platform_get_drvdata(ofdev);
 
        MAL_DBG(mal, "remove" NL);
 
                       "mal%d: commac list is not empty on remove!\n",
                       mal->index);
 
-       dev_set_drvdata(&ofdev->dev, NULL);
-
        free_irq(mal->serr_irq, mal);
        free_irq(mal->txde_irq, mal);
        free_irq(mal->txeob_irq, mal);
 
 
 int rgmii_attach(struct platform_device *ofdev, int input, int mode)
 {
-       struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
+       struct rgmii_instance *dev = platform_get_drvdata(ofdev);
        struct rgmii_regs __iomem *p = dev->base;
 
        RGMII_DBG(dev, "attach(%d)" NL, input);
 
 void rgmii_set_speed(struct platform_device *ofdev, int input, int speed)
 {
-       struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
+       struct rgmii_instance *dev = platform_get_drvdata(ofdev);
        struct rgmii_regs __iomem *p = dev->base;
        u32 ssr;
 
 
 void rgmii_get_mdio(struct platform_device *ofdev, int input)
 {
-       struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
+       struct rgmii_instance *dev = platform_get_drvdata(ofdev);
        struct rgmii_regs __iomem *p = dev->base;
        u32 fer;
 
 
 void rgmii_put_mdio(struct platform_device *ofdev, int input)
 {
-       struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
+       struct rgmii_instance *dev = platform_get_drvdata(ofdev);
        struct rgmii_regs __iomem *p = dev->base;
        u32 fer;
 
 
 void rgmii_detach(struct platform_device *ofdev, int input)
 {
-       struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
+       struct rgmii_instance *dev = platform_get_drvdata(ofdev);
        struct rgmii_regs __iomem *p;
 
        BUG_ON(!dev || dev->users == 0);
 
 void *rgmii_dump_regs(struct platform_device *ofdev, void *buf)
 {
-       struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
+       struct rgmii_instance *dev = platform_get_drvdata(ofdev);
        struct emac_ethtool_regs_subhdr *hdr = buf;
        struct rgmii_regs *regs = (struct rgmii_regs *)(hdr + 1);
 
               (dev->flags & EMAC_RGMII_FLAG_HAS_MDIO) ? "" : "out");
 
        wmb();
-       dev_set_drvdata(&ofdev->dev, dev);
+       platform_set_drvdata(ofdev, dev);
 
        return 0;
 
 
 static int rgmii_remove(struct platform_device *ofdev)
 {
-       struct rgmii_instance *dev = dev_get_drvdata(&ofdev->dev);
-
-       dev_set_drvdata(&ofdev->dev, NULL);
+       struct rgmii_instance *dev = platform_get_drvdata(ofdev);
 
        WARN_ON(dev->users != 0);
 
 
 
 int tah_attach(struct platform_device *ofdev, int channel)
 {
-       struct tah_instance *dev = dev_get_drvdata(&ofdev->dev);
+       struct tah_instance *dev = platform_get_drvdata(ofdev);
 
        mutex_lock(&dev->lock);
        /* Reset has been done at probe() time... nothing else to do for now */
 
 void tah_detach(struct platform_device *ofdev, int channel)
 {
-       struct tah_instance *dev = dev_get_drvdata(&ofdev->dev);
+       struct tah_instance *dev = platform_get_drvdata(ofdev);
 
        mutex_lock(&dev->lock);
        --dev->users;
 
 void tah_reset(struct platform_device *ofdev)
 {
-       struct tah_instance *dev = dev_get_drvdata(&ofdev->dev);
+       struct tah_instance *dev = platform_get_drvdata(ofdev);
        struct tah_regs __iomem *p = dev->base;
        int n;
 
 
 void *tah_dump_regs(struct platform_device *ofdev, void *buf)
 {
-       struct tah_instance *dev = dev_get_drvdata(&ofdev->dev);
+       struct tah_instance *dev = platform_get_drvdata(ofdev);
        struct emac_ethtool_regs_subhdr *hdr = buf;
        struct tah_regs *regs = (struct tah_regs *)(hdr + 1);
 
                goto err_free;
        }
 
-       dev_set_drvdata(&ofdev->dev, dev);
+       platform_set_drvdata(ofdev, dev);
 
        /* Initialize TAH and enable IPv4 checksum verification, no TSO yet */
        tah_reset(ofdev);
 
 static int tah_remove(struct platform_device *ofdev)
 {
-       struct tah_instance *dev = dev_get_drvdata(&ofdev->dev);
-
-       dev_set_drvdata(&ofdev->dev, NULL);
+       struct tah_instance *dev = platform_get_drvdata(ofdev);
 
        WARN_ON(dev->users != 0);
 
 
 
 int zmii_attach(struct platform_device *ofdev, int input, int *mode)
 {
-       struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
+       struct zmii_instance *dev = platform_get_drvdata(ofdev);
        struct zmii_regs __iomem *p = dev->base;
 
        ZMII_DBG(dev, "init(%d, %d)" NL, input, *mode);
 
 void zmii_get_mdio(struct platform_device *ofdev, int input)
 {
-       struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
+       struct zmii_instance *dev = platform_get_drvdata(ofdev);
        u32 fer;
 
        ZMII_DBG2(dev, "get_mdio(%d)" NL, input);
 
 void zmii_put_mdio(struct platform_device *ofdev, int input)
 {
-       struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
+       struct zmii_instance *dev = platform_get_drvdata(ofdev);
 
        ZMII_DBG2(dev, "put_mdio(%d)" NL, input);
        mutex_unlock(&dev->lock);
 
 void zmii_set_speed(struct platform_device *ofdev, int input, int speed)
 {
-       struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
+       struct zmii_instance *dev = platform_get_drvdata(ofdev);
        u32 ssr;
 
        mutex_lock(&dev->lock);
 
 void zmii_detach(struct platform_device *ofdev, int input)
 {
-       struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
+       struct zmii_instance *dev = platform_get_drvdata(ofdev);
 
        BUG_ON(!dev || dev->users == 0);
 
 
 void *zmii_dump_regs(struct platform_device *ofdev, void *buf)
 {
-       struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
+       struct zmii_instance *dev = platform_get_drvdata(ofdev);
        struct emac_ethtool_regs_subhdr *hdr = buf;
        struct zmii_regs *regs = (struct zmii_regs *)(hdr + 1);
 
        printk(KERN_INFO
               "ZMII %s initialized\n", ofdev->dev.of_node->full_name);
        wmb();
-       dev_set_drvdata(&ofdev->dev, dev);
+       platform_set_drvdata(ofdev, dev);
 
        return 0;
 
 
 static int zmii_remove(struct platform_device *ofdev)
 {
-       struct zmii_instance *dev = dev_get_drvdata(&ofdev->dev);
-
-       dev_set_drvdata(&ofdev->dev, NULL);
+       struct zmii_instance *dev = platform_get_drvdata(ofdev);
 
        WARN_ON(dev->users != 0);
 
 
 
 static int netx_eth_drv_remove(struct platform_device *pdev)
 {
-       struct net_device *ndev = dev_get_drvdata(&pdev->dev);
+       struct net_device *ndev = platform_get_drvdata(pdev);
        struct netx_eth_priv *priv = netdev_priv(ndev);
 
-       platform_set_drvdata(pdev, NULL);
-
        unregister_netdev(ndev);
        xc_stop(priv->xc);
        free_xc(priv->xc);
 
 
        SET_NETDEV_DEV(netdev, &pdev->dev);
 
-       dev_set_drvdata(&pdev->dev, netdev);
+       platform_set_drvdata(pdev, netdev);
        p = netdev_priv(netdev);
        netif_napi_add(netdev, &p->napi, octeon_mgmt_napi_poll,
                       OCTEON_MGMT_NAPI_WEIGHT);
 
 static int octeon_mgmt_remove(struct platform_device *pdev)
 {
-       struct net_device *netdev = dev_get_drvdata(&pdev->dev);
+       struct net_device *netdev = platform_get_drvdata(pdev);
 
        unregister_netdev(netdev);
        free_netdev(netdev);
 
                goto err_out_iounmap;
        }
 
-       dev_set_drvdata(&op->dev, dev);
+       platform_set_drvdata(op, dev);
 
        niu_device_announce(np);
 
 
 static int niu_of_remove(struct platform_device *op)
 {
-       struct net_device *dev = dev_get_drvdata(&op->dev);
+       struct net_device *dev = platform_get_drvdata(op);
 
        if (dev) {
                struct niu *np = netdev_priv(dev);
                niu_put_parent(np);
 
                free_netdev(dev);
-               dev_set_drvdata(&op->dev, NULL);
        }
        return 0;
 }
 
        struct quattro *qp;
 
        op = to_platform_device(parent);
-       qp = dev_get_drvdata(&op->dev);
+       qp = platform_get_drvdata(op);
        if (qp)
                return qp;
 
                qp->next = qfe_sbus_list;
                qfe_sbus_list = qp;
 
-               dev_set_drvdata(&op->dev, qp);
+               platform_set_drvdata(op, qp);
        }
        return qp;
 }
 
        struct platform_device *op = to_platform_device(child->dev.parent);
        struct sunqec *qecp;
 
-       qecp = dev_get_drvdata(&op->dev);
+       qecp = platform_get_drvdata(op);
        if (!qecp) {
                qecp = kzalloc(sizeof(struct sunqec), GFP_KERNEL);
                if (qecp) {
                                goto fail;
                        }
 
-                       dev_set_drvdata(&op->dev, qecp);
+                       platform_set_drvdata(op, qecp);
 
                        qecp->next_module = root_qec_dev;
                        root_qec_dev = qecp;
        if (res)
                goto fail;
 
-       dev_set_drvdata(&op->dev, qe);
+       platform_set_drvdata(op, qe);
 
        printk(KERN_INFO "%s: qe channel[%d] %pM\n", dev->name, qe->channel,
               dev->dev_addr);
 
 static int qec_sbus_remove(struct platform_device *op)
 {
-       struct sunqe *qp = dev_get_drvdata(&op->dev);
+       struct sunqe *qp = platform_get_drvdata(op);
        struct net_device *net_dev = qp->dev;
 
        unregister_netdev(net_dev);
 
        free_netdev(net_dev);
 
-       dev_set_drvdata(&op->dev, NULL);
-
        return 0;
 }
 
 
                return -ENOMEM;
 
        ether_setup(ndev);
-       dev_set_drvdata(&op->dev, ndev);
+       platform_set_drvdata(op, ndev);
        SET_NETDEV_DEV(ndev, &op->dev);
        ndev->flags &= ~IFF_MULTICAST;  /* clear multicast */
        ndev->features = NETIF_F_SG | NETIF_F_FRAGLIST;
 
 static int temac_of_remove(struct platform_device *op)
 {
-       struct net_device *ndev = dev_get_drvdata(&op->dev);
+       struct net_device *ndev = platform_get_drvdata(op);
        struct temac_local *lp = netdev_priv(ndev);
 
        temac_mdio_teardown(lp);
        if (lp->phy_node)
                of_node_put(lp->phy_node);
        lp->phy_node = NULL;
-       dev_set_drvdata(&op->dev, NULL);
        iounmap(lp->regs);
        if (lp->sdma_regs)
                iounmap(lp->sdma_regs);
 
                return -ENOMEM;
 
        ether_setup(ndev);
-       dev_set_drvdata(&op->dev, ndev);
+       platform_set_drvdata(op, ndev);
 
        SET_NETDEV_DEV(ndev, &op->dev);
        ndev->flags &= ~IFF_MULTICAST;  /* clear multicast */
 
 static int axienet_of_remove(struct platform_device *op)
 {
-       struct net_device *ndev = dev_get_drvdata(&op->dev);
+       struct net_device *ndev = platform_get_drvdata(op);
        struct axienet_local *lp = netdev_priv(ndev);
 
        axienet_mdio_teardown(lp);
                of_node_put(lp->phy_node);
        lp->phy_node = NULL;
 
-       dev_set_drvdata(&op->dev, NULL);
-
        iounmap(lp->regs);
        if (lp->dma_regs)
                iounmap(lp->dma_regs);