struct ethtool_cmd *cmd)
 {
        struct stmmac_priv *priv = netdev_priv(dev);
-       struct phy_device *phy = priv->phydev;
+       struct phy_device *phy = dev->phydev;
        int rc;
 
        if (priv->hw->pcs & STMMAC_PCS_RGMII ||
                                      struct ethtool_cmd *cmd)
 {
        struct stmmac_priv *priv = netdev_priv(dev);
-       struct phy_device *phy = priv->phydev;
+       struct phy_device *phy = dev->phydev;
        int rc;
 
        if (priv->hw->pcs & STMMAC_PCS_RGMII ||
                if (!adv_lp.pause)
                        return;
        } else {
-               if (!(priv->phydev->supported & SUPPORTED_Pause) ||
-                   !(priv->phydev->supported & SUPPORTED_Asym_Pause))
+               if (!(netdev->phydev->supported & SUPPORTED_Pause) ||
+                   !(netdev->phydev->supported & SUPPORTED_Asym_Pause))
                        return;
        }
 
-       pause->autoneg = priv->phydev->autoneg;
+       pause->autoneg = netdev->phydev->autoneg;
 
        if (priv->flow_ctrl & FLOW_RX)
                pause->rx_pause = 1;
                      struct ethtool_pauseparam *pause)
 {
        struct stmmac_priv *priv = netdev_priv(netdev);
-       struct phy_device *phy = priv->phydev;
+       struct phy_device *phy = netdev->phydev;
        int new_pause = FLOW_OFF;
 
        if (priv->hw->pcs && priv->hw->mac->pcs_get_adv_lp) {
                        }
                }
                if (priv->eee_enabled) {
-                       int val = phy_get_eee_err(priv->phydev);
+                       int val = phy_get_eee_err(dev->phydev);
                        if (val)
                                priv->xstats.phy_eee_wakeup_error_n = val;
                }
        edata->eee_active = priv->eee_active;
        edata->tx_lpi_timer = priv->tx_lpi_timer;
 
-       return phy_ethtool_get_eee(priv->phydev, edata);
+       return phy_ethtool_get_eee(dev->phydev, edata);
 }
 
 static int stmmac_ethtool_op_set_eee(struct net_device *dev,
                priv->tx_lpi_timer = edata->tx_lpi_timer;
        }
 
-       return phy_ethtool_set_eee(priv->phydev, edata);
+       return phy_ethtool_set_eee(dev->phydev, edata);
 }
 
 static u32 stmmac_usec2riwt(u32 usec, struct stmmac_priv *priv)
 
  */
 static inline void stmmac_hw_fix_mac_speed(struct stmmac_priv *priv)
 {
-       struct phy_device *phydev = priv->phydev;
+       struct net_device *ndev = priv->dev;
+       struct phy_device *phydev = ndev->phydev;
 
        if (likely(priv->plat->fix_mac_speed))
                priv->plat->fix_mac_speed(priv->plat->bsp_priv, phydev->speed);
  */
 bool stmmac_eee_init(struct stmmac_priv *priv)
 {
+       struct net_device *ndev = priv->dev;
        unsigned long flags;
        bool ret = false;
 
                int tx_lpi_timer = priv->tx_lpi_timer;
 
                /* Check if the PHY supports EEE */
-               if (phy_init_eee(priv->phydev, 1)) {
+               if (phy_init_eee(ndev->phydev, 1)) {
                        /* To manage at run-time if the EEE cannot be supported
                         * anymore (for example because the lp caps have been
                         * changed).
                                                     tx_lpi_timer);
                }
                /* Set HW EEE according to the speed */
-               priv->hw->mac->set_eee_pls(priv->hw, priv->phydev->link);
+               priv->hw->mac->set_eee_pls(priv->hw, ndev->phydev->link);
 
                ret = true;
                spin_unlock_irqrestore(&priv->lock, flags);
 static void stmmac_adjust_link(struct net_device *dev)
 {
        struct stmmac_priv *priv = netdev_priv(dev);
-       struct phy_device *phydev = priv->phydev;
+       struct phy_device *phydev = dev->phydev;
        unsigned long flags;
        int new_state = 0;
        unsigned int fc = priv->flow_ctrl, pause_time = priv->pause;
        pr_debug("stmmac_init_phy:  %s: attached to PHY (UID 0x%x)"
                 " Link = %d\n", dev->name, phydev->phy_id, phydev->link);
 
-       priv->phydev = phydev;
-
        return 0;
 }
 
 
        stmmac_init_tx_coalesce(priv);
 
-       if (priv->phydev)
-               phy_start(priv->phydev);
+       if (dev->phydev)
+               phy_start(dev->phydev);
 
        /* Request the IRQ lines */
        ret = request_irq(dev->irq, stmmac_interrupt,
 init_error:
        free_dma_desc_resources(priv);
 dma_desc_error:
-       if (priv->phydev)
-               phy_disconnect(priv->phydev);
+       if (dev->phydev)
+               phy_disconnect(dev->phydev);
 
        return ret;
 }
                del_timer_sync(&priv->eee_ctrl_timer);
 
        /* Stop and disconnect the PHY */
-       if (priv->phydev) {
-               phy_stop(priv->phydev);
-               phy_disconnect(priv->phydev);
-               priv->phydev = NULL;
+       if (dev->phydev) {
+               phy_stop(dev->phydev);
+               phy_disconnect(dev->phydev);
        }
 
        netif_stop_queue(dev);
  */
 static int stmmac_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 {
-       struct stmmac_priv *priv = netdev_priv(dev);
        int ret = -EOPNOTSUPP;
 
        if (!netif_running(dev))
        case SIOCGMIIPHY:
        case SIOCGMIIREG:
        case SIOCSMIIREG:
-               if (!priv->phydev)
+               if (!dev->phydev)
                        return -EINVAL;
-               ret = phy_mii_ioctl(priv->phydev, rq, cmd);
+               ret = phy_mii_ioctl(dev->phydev, rq, cmd);
                break;
        case SIOCSHWTSTAMP:
                ret = stmmac_hwtstamp_ioctl(dev, rq);
        if (!ndev || !netif_running(ndev))
                return 0;
 
-       if (priv->phydev)
-               phy_stop(priv->phydev);
+       if (ndev->phydev)
+               phy_stop(ndev->phydev);
 
        spin_lock_irqsave(&priv->lock, flags);
 
 
        spin_unlock_irqrestore(&priv->lock, flags);
 
-       if (priv->phydev)
-               phy_start(priv->phydev);
+       if (ndev->phydev)
+               phy_start(ndev->phydev);
 
        return 0;
 }