struct imx_priv_data *dwmac = plat_dat->bsp_priv;
        int val;
 
-       switch (plat_dat->interface) {
+       switch (plat_dat->mac_interface) {
        case PHY_INTERFACE_MODE_MII:
                val = GPR_ENET_QOS_INTF_SEL_MII;
                break;
                break;
        default:
                pr_debug("imx dwmac doesn't support %d interface\n",
-                        plat_dat->interface);
+                        plat_dat->mac_interface);
                return -EINVAL;
        }
 
        struct imx_priv_data *dwmac = plat_dat->bsp_priv;
        int val;
 
-       switch (plat_dat->interface) {
+       switch (plat_dat->mac_interface) {
        case PHY_INTERFACE_MODE_MII:
                val = MX93_GPR_ENET_QOS_INTF_SEL_MII;
                break;
                break;
        default:
                dev_dbg(dwmac->dev, "imx dwmac doesn't support %d interface\n",
-                        plat_dat->interface);
+                        plat_dat->mac_interface);
                return -EINVAL;
        }
 
        plat_dat = dwmac->plat_dat;
 
        if (dwmac->ops->mac_rgmii_txclk_auto_adj ||
-           (plat_dat->interface == PHY_INTERFACE_MODE_RMII) ||
-           (plat_dat->interface == PHY_INTERFACE_MODE_MII))
+           (plat_dat->mac_interface == PHY_INTERFACE_MODE_RMII) ||
+           (plat_dat->mac_interface == PHY_INTERFACE_MODE_MII))
                return;
 
        switch (speed) {
        value |= DMA_BUS_MODE_SFT_RESET;
        writel(value, ioaddr + DMA_BUS_MODE);
 
-       if (plat_dat->interface == PHY_INTERFACE_MODE_RMII) {
+       if (plat_dat->mac_interface == PHY_INTERFACE_MODE_RMII) {
                usleep_range(100, 200);
                writel(RMII_RESET_SPEED, ioaddr + MAC_CTRL_REG);
        }
 
        struct ingenic_mac *mac = plat_dat->bsp_priv;
        unsigned int val;
 
-       switch (plat_dat->interface) {
+       switch (plat_dat->mac_interface) {
        case PHY_INTERFACE_MODE_MII:
                val = FIELD_PREP(MACPHYC_TXCLK_SEL_MASK, MACPHYC_TXCLK_SEL_INPUT) |
                          FIELD_PREP(MACPHYC_PHY_INFT_MASK, MACPHYC_PHY_INFT_MII);
                break;
 
        default:
-               dev_err(mac->dev, "Unsupported interface %d", plat_dat->interface);
+               dev_err(mac->dev, "Unsupported interface %d", plat_dat->mac_interface);
                return -EINVAL;
        }
 
 {
        struct ingenic_mac *mac = plat_dat->bsp_priv;
 
-       switch (plat_dat->interface) {
+       switch (plat_dat->mac_interface) {
        case PHY_INTERFACE_MODE_RMII:
                dev_dbg(mac->dev, "MAC PHY Control Register: PHY_INTERFACE_MODE_RMII\n");
                break;
 
        default:
-               dev_err(mac->dev, "Unsupported interface %d", plat_dat->interface);
+               dev_err(mac->dev, "Unsupported interface %d", plat_dat->mac_interface);
                return -EINVAL;
        }
 
        struct ingenic_mac *mac = plat_dat->bsp_priv;
        unsigned int val;
 
-       switch (plat_dat->interface) {
+       switch (plat_dat->mac_interface) {
        case PHY_INTERFACE_MODE_RMII:
                val = FIELD_PREP(MACPHYC_PHY_INFT_MASK, MACPHYC_PHY_INFT_RMII);
                dev_dbg(mac->dev, "MAC PHY Control Register: PHY_INTERFACE_MODE_RMII\n");
                break;
 
        default:
-               dev_err(mac->dev, "Unsupported interface %d", plat_dat->interface);
+               dev_err(mac->dev, "Unsupported interface %d", plat_dat->mac_interface);
                return -EINVAL;
        }
 
        struct ingenic_mac *mac = plat_dat->bsp_priv;
        unsigned int val;
 
-       switch (plat_dat->interface) {
+       switch (plat_dat->mac_interface) {
        case PHY_INTERFACE_MODE_RMII:
                val = FIELD_PREP(MACPHYC_MODE_SEL_MASK, MACPHYC_MODE_SEL_RMII) |
                          FIELD_PREP(MACPHYC_PHY_INFT_MASK, MACPHYC_PHY_INFT_RMII);
                break;
 
        default:
-               dev_err(mac->dev, "Unsupported interface %d", plat_dat->interface);
+               dev_err(mac->dev, "Unsupported interface %d", plat_dat->mac_interface);
                return -EINVAL;
        }
 
        struct ingenic_mac *mac = plat_dat->bsp_priv;
        unsigned int val;
 
-       switch (plat_dat->interface) {
+       switch (plat_dat->mac_interface) {
        case PHY_INTERFACE_MODE_RMII:
                val = FIELD_PREP(MACPHYC_TX_SEL_MASK, MACPHYC_TX_SEL_ORIGIN) |
                          FIELD_PREP(MACPHYC_RX_SEL_MASK, MACPHYC_RX_SEL_ORIGIN) |
                break;
 
        default:
-               dev_err(mac->dev, "Unsupported interface %d", plat_dat->interface);
+               dev_err(mac->dev, "Unsupported interface %d", plat_dat->mac_interface);
                return -EINVAL;
        }
 
 
        }
 
        plat->phy_interface = phy_mode;
-       plat->interface = PHY_INTERFACE_MODE_GMII;
+       plat->mac_interface = PHY_INTERFACE_MODE_GMII;
 
        pci_set_master(pdev);
 
 
                goto err_remove_config_dt;
        }
 
-       if (plat_dat->interface == PHY_INTERFACE_MODE_MII) {
+       if (plat_dat->mac_interface == PHY_INTERFACE_MODE_MII) {
                ethmode = LPC18XX_CREG_CREG6_ETHMODE_MII;
-       } else if (plat_dat->interface == PHY_INTERFACE_MODE_RMII) {
+       } else if (plat_dat->mac_interface == PHY_INTERFACE_MODE_RMII) {
                ethmode = LPC18XX_CREG_CREG6_ETHMODE_RMII;
        } else {
                dev_err(&pdev->dev, "Only MII and RMII mode supported\n");
 
 {
        int i;
 
-       plat->interface = priv_plat->phy_mode;
+       plat->mac_interface = priv_plat->phy_mode;
        if (priv_plat->mac_wol)
                plat->flags |= STMMAC_FLAG_USE_PHY_WOL;
        else
 
        struct net_device *ndev = dev_get_drvdata(dwmac->dev);
        struct stmmac_priv *priv = netdev_priv(ndev);
 
-       return priv->plat->interface;
+       return priv->plat->mac_interface;
 }
 
 static void socfpga_sgmii_config(struct socfpga_dwmac *dwmac, bool enable)
 
        unsigned int mode;
        int err;
 
-       switch (plat_dat->interface) {
+       switch (plat_dat->mac_interface) {
        case PHY_INTERFACE_MODE_RMII:
                mode = STARFIVE_DWMAC_PHY_INFT_RMII;
                break;
 
        default:
                dev_err(dwmac->dev, "unsupported interface %d\n",
-                       plat_dat->interface);
+                       plat_dat->mac_interface);
                return -EINVAL;
        }
 
 
 
        clk_rate = clk_get_rate(dwmac->clk_eth_ck);
        dwmac->enable_eth_ck = false;
-       switch (plat_dat->interface) {
+       switch (plat_dat->mac_interface) {
        case PHY_INTERFACE_MODE_MII:
                if (clk_rate == ETH_CK_F_25M && dwmac->ext_phyclk)
                        dwmac->enable_eth_ck = true;
                break;
        default:
                pr_debug("SYSCFG init :  Do not manage %d interface\n",
-                        plat_dat->interface);
+                        plat_dat->mac_interface);
                /* Do not manage others interfaces */
                return -EINVAL;
        }
        u32 reg = dwmac->mode_reg;
        int val;
 
-       switch (plat_dat->interface) {
+       switch (plat_dat->mac_interface) {
        case PHY_INTERFACE_MODE_MII:
                val = SYSCFG_MCU_ETH_SEL_MII;
                pr_debug("SYSCFG init : PHY_INTERFACE_MODE_MII\n");
                break;
        default:
                pr_debug("SYSCFG init :  Do not manage %d interface\n",
-                        plat_dat->interface);
+                        plat_dat->mac_interface);
                /* Do not manage others interfaces */
                return -EINVAL;
        }
 
        if (gmac->variant->support_rmii)
                reg &= ~SYSCON_RMII_EN;
 
-       switch (plat->interface) {
+       switch (plat->mac_interface) {
        case PHY_INTERFACE_MODE_MII:
                /* default */
                break;
                break;
        default:
                dev_err(dev, "Unsupported interface mode: %s",
-                       phy_modes(plat->interface));
+                       phy_modes(plat->mac_interface));
                return -EINVAL;
        }
 
        /* platform data specifying hardware features and callbacks.
         * hardware features were copied from Allwinner drivers.
         */
-       plat_dat->interface = interface;
+       plat_dat->mac_interface = interface;
        plat_dat->rx_coe = STMMAC_RX_COE_TYPE2;
        plat_dat->tx_coe = 1;
        plat_dat->flags |= STMMAC_FLAG_HAS_SUN8I;
 
  */
 static void stmmac_check_pcs_mode(struct stmmac_priv *priv)
 {
-       int interface = priv->plat->interface;
+       int interface = priv->plat->mac_interface;
 
        if (priv->dma_cap.pcs) {
                if ((interface == PHY_INTERFACE_MODE_RGMII) ||
                priv->phylink_config.ovr_an_inband =
                        mdio_bus_data->xpcs_an_inband;
 
-       /* Set the platform/firmware specified interface mode */
+       /* Set the platform/firmware specified interface mode. Note, phylink
+        * deals with the PHY interface mode, not the MAC interface mode.
+        */
        __set_bit(mode, priv->phylink_config.supported_interfaces);
 
        /* If we have an xpcs, it defines which PHY interfaces are supported. */
 
                return ERR_PTR(phy_mode);
 
        plat->phy_interface = phy_mode;
-       plat->interface = stmmac_of_get_mac_mode(np);
-       if (plat->interface < 0)
-               plat->interface = plat->phy_interface;
+       plat->mac_interface = stmmac_of_get_mac_mode(np);
+       if (plat->mac_interface < 0)
+               plat->mac_interface = plat->phy_interface;
 
        /* Some wrapper drivers still rely on phy_node. Let's save it while
         * they are not converted to phylink. */
 
 struct plat_stmmacenet_data {
        int bus_id;
        int phy_addr;
-       int interface;
+       /* MAC ----- optional PCS ----- SerDes ----- optional PHY ----- Media
+        *       ^                               ^
+        * mac_interface                   phy_interface
+        *
+        * mac_interface is the MAC-side interface, which may be the same
+        * as phy_interface if there is no intervening PCS. If there is a
+        * PCS, then mac_interface describes the interface mode between the
+        * MAC and PCS, and phy_interface describes the interface mode
+        * between the PCS and PHY.
+        */
+       phy_interface_t mac_interface;
+       /* phy_interface is the PHY-side interface - the interface used by
+        * an attached PHY.
+        */
        phy_interface_t phy_interface;
        struct stmmac_mdio_bus_data *mdio_bus_data;
        struct device_node *phy_node;