enetc_port_wr(hw, ENETC_PSIVLANFMR, ENETC_PSIVLANFMR_VS);
 }
 
-static void enetc_configure_port_mac(struct enetc_hw *hw)
+static void enetc_configure_port_mac(struct enetc_hw *hw,
+                                    phy_interface_t phy_mode)
 {
        enetc_port_wr(hw, ENETC_PM0_MAXFRM,
                      ENETC_SET_MAXFRM(ENETC_RX_MAXFRM_SIZE));
                      ENETC_PM0_CMD_TXP | ENETC_PM0_PROMISC |
                      ENETC_PM0_TX_EN | ENETC_PM0_RX_EN);
        /* set auto-speed for RGMII */
-       if (enetc_port_rd(hw, ENETC_PM0_IF_MODE) & ENETC_PMO_IFM_RG)
+       if (enetc_port_rd(hw, ENETC_PM0_IF_MODE) & ENETC_PMO_IFM_RG ||
+           phy_interface_mode_is_rgmii(phy_mode))
                enetc_port_wr(hw, ENETC_PM0_IF_MODE, ENETC_PM0_IFM_RGAUTO);
-       if (enetc_global_rd(hw, ENETC_G_EPFBLPR(1)) == ENETC_G_EPFBLPR1_XGMII)
+
+       if (phy_mode == PHY_INTERFACE_MODE_USXGMII)
                enetc_port_wr(hw, ENETC_PM0_IF_MODE, ENETC_PM0_IFM_XGMII);
 }
 
 
        enetc_configure_port_pmac(hw);
 
-       enetc_configure_port_mac(hw);
+       enetc_configure_port_mac(hw, pf->if_mode);
 
        enetc_port_si_configure(pf->si);
 
                mdiobus_unregister(pf->mdio);
 }
 
-static int enetc_of_get_phy(struct enetc_ndev_priv *priv)
+static int enetc_of_get_phy(struct enetc_pf *pf)
 {
-       struct enetc_pf *pf = enetc_si_priv(priv->si);
-       struct device_node *np = priv->dev->of_node;
+       struct device *dev = &pf->si->pdev->dev;
+       struct device_node *np = dev->of_node;
        struct device_node *mdio_np;
        int err;
 
-       priv->phy_node = of_parse_phandle(np, "phy-handle", 0);
-       if (!priv->phy_node) {
+       pf->phy_node = of_parse_phandle(np, "phy-handle", 0);
+       if (!pf->phy_node) {
                if (!of_phy_is_fixed_link(np)) {
-                       dev_err(priv->dev, "PHY not specified\n");
+                       dev_err(dev, "PHY not specified\n");
                        return -ENODEV;
                }
 
                err = of_phy_register_fixed_link(np);
                if (err < 0) {
-                       dev_err(priv->dev, "fixed link registration failed\n");
+                       dev_err(dev, "fixed link registration failed\n");
                        return err;
                }
 
-               priv->phy_node = of_node_get(np);
+               pf->phy_node = of_node_get(np);
        }
 
        mdio_np = of_get_child_by_name(np, "mdio");
                of_node_put(mdio_np);
                err = enetc_mdio_probe(pf);
                if (err) {
-                       of_node_put(priv->phy_node);
+                       of_node_put(pf->phy_node);
                        return err;
                }
        }
 
-       err = of_get_phy_mode(np, &priv->if_mode);
+       err = of_get_phy_mode(np, &pf->if_mode);
        if (err) {
-               dev_err(priv->dev, "missing phy type\n");
-               of_node_put(priv->phy_node);
+               dev_err(dev, "missing phy type\n");
+               of_node_put(pf->phy_node);
                if (of_phy_is_fixed_link(np))
                        of_phy_deregister_fixed_link(np);
                else
        return 0;
 }
 
-static void enetc_of_put_phy(struct enetc_ndev_priv *priv)
+static void enetc_of_put_phy(struct enetc_pf *pf)
 {
-       struct device_node *np = priv->dev->of_node;
+       struct device_node *np = pf->si->pdev->dev.of_node;
 
        if (np && of_phy_is_fixed_link(np))
                of_phy_deregister_fixed_link(np);
-       if (priv->phy_node)
-               of_node_put(priv->phy_node);
+       if (pf->phy_node)
+               of_node_put(pf->phy_node);
 }
 
 static int enetc_imdio_init(struct enetc_pf *pf, bool is_c45)
        pf->si = si;
        pf->total_vfs = pci_sriov_get_totalvfs(pdev);
 
+       err = enetc_of_get_phy(pf);
+       if (err)
+               dev_warn(&pdev->dev, "Fallback to PHY-less operation\n");
+
        enetc_configure_port(pf);
 
        enetc_get_si_caps(si);
        enetc_pf_netdev_setup(si, ndev, &enetc_ndev_ops);
 
        priv = netdev_priv(ndev);
+       priv->phy_node = pf->phy_node;
+       priv->if_mode = pf->if_mode;
 
        enetc_init_si_rings_params(priv);
 
                goto err_alloc_msix;
        }
 
-       err = enetc_of_get_phy(priv);
-       if (err)
-               dev_warn(&pdev->dev, "Fallback to PHY-less operation\n");
-
        err = enetc_configure_serdes(priv);
        if (err)
                dev_warn(&pdev->dev, "Attempted SerDes config but failed\n");
        return 0;
 
 err_reg_netdev:
-       enetc_of_put_phy(priv);
        enetc_free_msix(priv);
 err_alloc_msix:
        enetc_free_si_resources(priv);
        si->ndev = NULL;
        free_netdev(ndev);
 err_alloc_netdev:
+       enetc_of_put_phy(pf);
 err_map_pf_space:
        enetc_pci_remove(pdev);
 
 
        enetc_imdio_remove(pf);
        enetc_mdio_remove(pf);
-       enetc_of_put_phy(priv);
+       enetc_of_put_phy(pf);
 
        enetc_free_msix(priv);