static int gfar_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 {
-       struct gfar_private *priv = netdev_priv(dev);
+       struct phy_device *phydev = dev->phydev;
 
        if (!netif_running(dev))
                return -EINVAL;
        if (cmd == SIOCGHWTSTAMP)
                return gfar_hwtstamp_get(dev, rq);
 
-       if (!priv->phydev)
+       if (!phydev)
                return -ENODEV;
 
-       return phy_mii_ioctl(priv->phydev, rq, cmd);
+       return phy_mii_ioctl(phydev, rq, cmd);
 }
 
 static u32 cluster_entry_per_class(struct gfar_private *priv, u32 rqfar,
                gfar_start_wol_filer(priv);
 
        } else {
-               phy_stop(priv->phydev);
+               phy_stop(ndev->phydev);
        }
 
        return 0;
                gfar_filer_restore_table(priv);
 
        } else {
-               phy_start(priv->phydev);
+               phy_start(ndev->phydev);
        }
 
        gfar_start(priv);
        priv->oldspeed = 0;
        priv->oldduplex = -1;
 
-       if (priv->phydev)
-               phy_start(priv->phydev);
+       if (ndev->phydev)
+               phy_start(ndev->phydev);
 
        netif_device_attach(ndev);
        enable_napi(priv);
                priv->device_flags & FSL_GIANFAR_DEV_HAS_GIGABIT ?
                GFAR_SUPPORTED_GBIT : 0;
        phy_interface_t interface;
+       struct phy_device *phydev;
 
        priv->oldlink = 0;
        priv->oldspeed = 0;
 
        interface = gfar_get_interface(dev);
 
-       priv->phydev = of_phy_connect(dev, priv->phy_node, &adjust_link, 0,
-                                     interface);
-       if (!priv->phydev) {
+       phydev = of_phy_connect(dev, priv->phy_node, &adjust_link, 0,
+                               interface);
+       if (!phydev) {
                dev_err(&dev->dev, "could not attach to PHY\n");
                return -ENODEV;
        }
                gfar_configure_serdes(dev);
 
        /* Remove any features not supported by the controller */
-       priv->phydev->supported &= (GFAR_SUPPORTED | gigabit_support);
-       priv->phydev->advertising = priv->phydev->supported;
+       phydev->supported &= (GFAR_SUPPORTED | gigabit_support);
+       phydev->advertising = phydev->supported;
 
        /* Add support for flow control, but don't advertise it by default */
-       priv->phydev->supported |= (SUPPORTED_Pause | SUPPORTED_Asym_Pause);
+       phydev->supported |= (SUPPORTED_Pause | SUPPORTED_Asym_Pause);
 
        return 0;
 }
        /* disable ints and gracefully shut down Rx/Tx DMA */
        gfar_halt(priv);
 
-       phy_stop(priv->phydev);
+       phy_stop(dev->phydev);
 
        free_skb_resources(priv);
 }
        priv->oldspeed = 0;
        priv->oldduplex = -1;
 
-       phy_start(priv->phydev);
+       phy_start(ndev->phydev);
 
        enable_napi(priv);
 
        stop_gfar(dev);
 
        /* Disconnect from the PHY */
-       phy_disconnect(priv->phydev);
-       priv->phydev = NULL;
+       phy_disconnect(dev->phydev);
 
        gfar_free_irq(priv);
 
 static void adjust_link(struct net_device *dev)
 {
        struct gfar_private *priv = netdev_priv(dev);
-       struct phy_device *phydev = priv->phydev;
+       struct phy_device *phydev = dev->phydev;
 
        if (unlikely(phydev->link != priv->oldlink ||
                     (phydev->link && (phydev->duplex != priv->oldduplex ||
 
 static u32 gfar_get_flowctrl_cfg(struct gfar_private *priv)
 {
-       struct phy_device *phydev = priv->phydev;
+       struct net_device *ndev = priv->ndev;
+       struct phy_device *phydev = ndev->phydev;
        u32 val = 0;
 
        if (!phydev->duplex)
 static noinline void gfar_update_link_state(struct gfar_private *priv)
 {
        struct gfar __iomem *regs = priv->gfargrp[0].regs;
-       struct phy_device *phydev = priv->phydev;
+       struct net_device *ndev = priv->ndev;
+       struct phy_device *phydev = ndev->phydev;
        struct gfar_priv_rx_q *rx_queue = NULL;
        int i;
 
 
 static int gfar_set_ksettings(struct net_device *dev,
                              const struct ethtool_link_ksettings *cmd)
 {
-       struct gfar_private *priv = netdev_priv(dev);
-       struct phy_device *phydev = priv->phydev;
+       struct phy_device *phydev = dev->phydev;
 
-       if (NULL == phydev)
+       if (!phydev)
                return -ENODEV;
 
        return phy_ethtool_ksettings_set(phydev, cmd);
 static int gfar_get_ksettings(struct net_device *dev,
                              struct ethtool_link_ksettings *cmd)
 {
-       struct gfar_private *priv = netdev_priv(dev);
-       struct phy_device *phydev = priv->phydev;
+       struct phy_device *phydev = dev->phydev;
 
-       if (NULL == phydev)
+       if (!phydev)
                return -ENODEV;
 
        return phy_ethtool_ksettings_get(phydev, cmd);
 static unsigned int gfar_usecs2ticks(struct gfar_private *priv,
                                     unsigned int usecs)
 {
+       struct net_device *ndev = priv->ndev;
+       struct phy_device *phydev = ndev->phydev;
        unsigned int count;
 
        /* The timer is different, depending on the interface speed */
-       switch (priv->phydev->speed) {
+       switch (phydev->speed) {
        case SPEED_1000:
                count = GFAR_GBIT_TIME;
                break;
 static unsigned int gfar_ticks2usecs(struct gfar_private *priv,
                                     unsigned int ticks)
 {
+       struct net_device *ndev = priv->ndev;
+       struct phy_device *phydev = ndev->phydev;
        unsigned int count;
 
        /* The timer is different, depending on the interface speed */
-       switch (priv->phydev->speed) {
+       switch (phydev->speed) {
        case SPEED_1000:
                count = GFAR_GBIT_TIME;
                break;
        if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_COALESCE))
                return -EOPNOTSUPP;
 
-       if (NULL == priv->phydev)
+       if (!dev->phydev)
                return -ENODEV;
 
        rx_queue = priv->rx_queue[0];
        if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_COALESCE))
                return -EOPNOTSUPP;
 
-       if (NULL == priv->phydev)
+       if (!dev->phydev)
                return -ENODEV;
 
        /* Check the bounds of the values */
                            struct ethtool_pauseparam *epause)
 {
        struct gfar_private *priv = netdev_priv(dev);
-       struct phy_device *phydev = priv->phydev;
+       struct phy_device *phydev = dev->phydev;
        struct gfar __iomem *regs = priv->gfargrp[0].regs;
        u32 oldadv, newadv;