7 files changed, 360 insertions, 160 deletions

diff --git a/drivers/net/phy/Kconfig b/drivers/net/phy/Kconfig
index 3090dc65a6f1..983bbf4d5ef6 100644
--- a/drivers/net/phy/Kconfig
+++ b/drivers/net/phy/Kconfig
@@ -159,6 +159,19 @@ config MDIO_BUS_MUX_GPIO
           several child MDIO busses to a parent bus.  Child bus
           selection is under the control of GPIO lines.
 
+config MDIO_BUS_MUX_MMIOREG
+        tristate "Support for MMIO device-controlled MDIO bus multiplexers"
+        depends on OF_MDIO
+        select MDIO_BUS_MUX
+        help
+          This module provides a driver for MDIO bus multiplexers that
+          are controlled via a simple memory-mapped device, like an FPGA.
+          The multiplexer connects one of several child MDIO busses to a
+          parent bus.  Child bus selection is under the control of one of
+          the FPGA's registers.
+
+          Currently, only 8-bit registers are supported.
+
 endif # PHYLIB
 
 config MICREL_KS8995MA
diff --git a/drivers/net/phy/Makefile b/drivers/net/phy/Makefile
index 6d2dc6c94f2e..426674debae4 100644
--- a/drivers/net/phy/Makefile
+++ b/drivers/net/phy/Makefile
@@ -28,3 +28,4 @@ obj-$(CONFIG_MICREL_KS8995MA)	+= spi_ks8995.o
 obj-$(CONFIG_AMD_PHY)           += amd.o
 obj-$(CONFIG_MDIO_BUS_MUX)      += mdio-mux.o
 obj-$(CONFIG_MDIO_BUS_MUX_GPIO) += mdio-mux-gpio.o
+obj-$(CONFIG_MDIO_BUS_MUX_MMIOREG) += mdio-mux-mmioreg.o
diff --git a/drivers/net/phy/dp83640.c b/drivers/net/phy/dp83640.c
index b0da0226661f..24e05c43bff8 100644
--- a/drivers/net/phy/dp83640.c
+++ b/drivers/net/phy/dp83640.c
@@ -980,7 +980,7 @@ static int dp83640_probe(struct phy_device *phydev)
 
         if (choose_this_phy(clock, phydev)) {
                 clock->chosen = dp83640;
-                clock->ptp_clock = ptp_clock_register(&clock->caps);
+                clock->ptp_clock = ptp_clock_register(&clock->caps, &phydev->dev);
                 if (IS_ERR(clock->ptp_clock)) {
                         err = PTR_ERR(clock->ptp_clock);
                         goto no_register;
diff --git a/drivers/net/phy/lxt.c b/drivers/net/phy/lxt.c
index 6d1e3fcc43e2..ec40ba882f61 100644
--- a/drivers/net/phy/lxt.c
+++ b/drivers/net/phy/lxt.c
@@ -122,6 +122,123 @@ static int lxt971_config_intr(struct phy_device *phydev)
         return err;
 }
 
+/*
+ * A2 version of LXT973 chip has an ERRATA: it randomly return the contents
+ * of the previous even register when you read a odd register regularly
+ */
+
+static int lxt973a2_update_link(struct phy_device *phydev)
+{
+        int status;
+        int control;
+        int retry = 8; /* we try 8 times */
+
+        /* Do a fake read */
+        status = phy_read(phydev, MII_BMSR);
+
+        if (status < 0)
+                return status;
+
+        control = phy_read(phydev, MII_BMCR);
+        if (control < 0)
+                return control;
+
+        do {
+                /* Read link and autonegotiation status */
+                status = phy_read(phydev, MII_BMSR);
+        } while (status >= 0 && retry-- && status == control);
+
+        if (status < 0)
+                return status;
+
+        if ((status & BMSR_LSTATUS) == 0)
+                phydev->link = 0;
+        else
+                phydev->link = 1;
+
+        return 0;
+}
+
+int lxt973a2_read_status(struct phy_device *phydev)
+{
+        int adv;
+        int err;
+        int lpa;
+        int lpagb = 0;
+
+        /* Update the link, but return if there was an error */
+        err = lxt973a2_update_link(phydev);
+        if (err)
+                return err;
+
+        if (AUTONEG_ENABLE == phydev->autoneg) {
+                int retry = 1;
+
+                adv = phy_read(phydev, MII_ADVERTISE);
+
+                if (adv < 0)
+                        return adv;
+
+                do {
+                        lpa = phy_read(phydev, MII_LPA);
+
+                        if (lpa < 0)
+                                return lpa;
+
+                        /* If both registers are equal, it is suspect but not
+                        * impossible, hence a new try
+                        */
+                } while (lpa == adv && retry--);
+
+                lpa &= adv;
+
+                phydev->speed = SPEED_10;
+                phydev->duplex = DUPLEX_HALF;
+                phydev->pause = phydev->asym_pause = 0;
+
+                if (lpagb & (LPA_1000FULL | LPA_1000HALF)) {
+                        phydev->speed = SPEED_1000;
+
+                        if (lpagb & LPA_1000FULL)
+                                phydev->duplex = DUPLEX_FULL;
+                } else if (lpa & (LPA_100FULL | LPA_100HALF)) {
+                        phydev->speed = SPEED_100;
+
+                        if (lpa & LPA_100FULL)
+                                phydev->duplex = DUPLEX_FULL;
+                } else {
+                        if (lpa & LPA_10FULL)
+                                phydev->duplex = DUPLEX_FULL;
+                }
+
+                if (phydev->duplex == DUPLEX_FULL) {
+                        phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0;
+                        phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0;
+                }
+        } else {
+                int bmcr = phy_read(phydev, MII_BMCR);
+
+                if (bmcr < 0)
+                        return bmcr;
+
+                if (bmcr & BMCR_FULLDPLX)
+                        phydev->duplex = DUPLEX_FULL;
+                else
+                        phydev->duplex = DUPLEX_HALF;
+
+                if (bmcr & BMCR_SPEED1000)
+                        phydev->speed = SPEED_1000;
+                else if (bmcr & BMCR_SPEED100)
+                        phydev->speed = SPEED_100;
+                else
+                        phydev->speed = SPEED_10;
+
+                phydev->pause = phydev->asym_pause = 0;
+        }
+
+        return 0;
+}
+
 static int lxt973_probe(struct phy_device *phydev)
 {
         int val = phy_read(phydev, MII_LXT973_PCR);
@@ -175,6 +292,16 @@ static struct phy_driver lxt97x_driver[] = {
         .driver         = { .owner = THIS_MODULE,},
 }, {
         .phy_id         = 0x00137a10,
+        .name           = "LXT973-A2",
+        .phy_id_mask    = 0xffffffff,
+        .features       = PHY_BASIC_FEATURES,
+        .flags          = 0,
+        .probe          = lxt973_probe,
+        .config_aneg    = lxt973_config_aneg,
+        .read_status    = lxt973a2_read_status,
+        .driver         = { .owner = THIS_MODULE,},
+}, {
+        .phy_id         = 0x00137a10,
         .name           = "LXT973",
         .phy_id_mask    = 0xfffffff0,
         .features       = PHY_BASIC_FEATURES,
diff --git a/drivers/net/phy/mdio-gpio.c b/drivers/net/phy/mdio-gpio.c
index 7189adf54bd1..899274f2f9b1 100644
--- a/drivers/net/phy/mdio-gpio.c
+++ b/drivers/net/phy/mdio-gpio.c
@@ -28,17 +28,38 @@
 #include <linux/gpio.h>
 #include <linux/mdio-gpio.h>
 
-#ifdef CONFIG_OF_GPIO
 #include <linux/of_gpio.h>
 #include <linux/of_mdio.h>
-#include <linux/of_platform.h>
-#endif
 
 struct mdio_gpio_info {
         struct mdiobb_ctrl ctrl;
         int mdc, mdio;
 };
 
+static void *mdio_gpio_of_get_data(struct platform_device *pdev)
+{
+        struct device_node *np = pdev->dev.of_node;
+        struct mdio_gpio_platform_data *pdata;
+        int ret;
+
+        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return NULL;
+
+        ret = of_get_gpio(np, 0);
+        if (ret < 0)
+                return NULL;
+
+        pdata->mdc = ret;
+
+        ret = of_get_gpio(np, 1);
+        if (ret < 0)
+                return NULL;
+        pdata->mdio = ret;
+
+        return pdata;
+}
+
 static void mdio_dir(struct mdiobb_ctrl *ctrl, int dir)
 {
         struct mdio_gpio_info *bitbang =
@@ -162,10 +183,15 @@ static void __devexit mdio_gpio_bus_destroy(struct device *dev)
 
 static int __devinit mdio_gpio_probe(struct platform_device *pdev)
 {
-        struct mdio_gpio_platform_data *pdata = pdev->dev.platform_data;
+        struct mdio_gpio_platform_data *pdata;
         struct mii_bus *new_bus;
         int ret;
 
+        if (pdev->dev.of_node)
+                pdata = mdio_gpio_of_get_data(pdev);
+        else
+                pdata = pdev->dev.platform_data;
+
         if (!pdata)
                 return -ENODEV;
 
@@ -173,7 +199,11 @@ static int __devinit mdio_gpio_probe(struct platform_device *pdev)
         if (!new_bus)
                 return -ENODEV;
 
-        ret = mdiobus_register(new_bus);
+        if (pdev->dev.of_node)
+                ret = of_mdiobus_register(new_bus, pdev->dev.of_node);
+        else
+                ret = mdiobus_register(new_bus);
+
         if (ret)
                 mdio_gpio_bus_deinit(&pdev->dev);
 
@@ -187,112 +217,30 @@ static int __devexit mdio_gpio_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_OF_GPIO
-
-static int __devinit mdio_ofgpio_probe(struct platform_device *ofdev)
-{
-        struct mdio_gpio_platform_data *pdata;
-        struct mii_bus *new_bus;
-        int ret;
-
-        pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
-        if (!pdata)
-                return -ENOMEM;
-
-        ret = of_get_gpio(ofdev->dev.of_node, 0);
-        if (ret < 0)
-                goto out_free;
-        pdata->mdc = ret;
-
-        ret = of_get_gpio(ofdev->dev.of_node, 1);
-        if (ret < 0)
-                goto out_free;
-        pdata->mdio = ret;
-
-        new_bus = mdio_gpio_bus_init(&ofdev->dev, pdata, pdata->mdc);
-        if (!new_bus)
-                goto out_free;
-
-        ret = of_mdiobus_register(new_bus, ofdev->dev.of_node);
-        if (ret)
-                mdio_gpio_bus_deinit(&ofdev->dev);
-
-        return ret;
-
-out_free:
-        kfree(pdata);
-        return -ENODEV;
-}
-
-static int __devexit mdio_ofgpio_remove(struct platform_device *ofdev)
-{
-        mdio_gpio_bus_destroy(&ofdev->dev);
-        kfree(ofdev->dev.platform_data);
-
-        return 0;
-}
-
-static struct of_device_id mdio_ofgpio_match[] = {
-        {
-                .compatible = "virtual,mdio-gpio",
-        },
-        {},
-};
-MODULE_DEVICE_TABLE(of, mdio_ofgpio_match);
-
-static struct platform_driver mdio_ofgpio_driver = {
-        .driver = {
-                .name = "mdio-ofgpio",
-                .owner = THIS_MODULE,
-                .of_match_table = mdio_ofgpio_match,
-        },
-        .probe = mdio_ofgpio_probe,
-        .remove = __devexit_p(mdio_ofgpio_remove),
+static struct of_device_id mdio_gpio_of_match[] = {
+        { .compatible = "virtual,mdio-gpio", },
+        { /* sentinel */ }
 };
 
-static inline int __init mdio_ofgpio_init(void)
-{
-        return platform_driver_register(&mdio_ofgpio_driver);
-}
-
-static inline void mdio_ofgpio_exit(void)
-{
-        platform_driver_unregister(&mdio_ofgpio_driver);
-}
-#else
-static inline int __init mdio_ofgpio_init(void) { return 0; }
-static inline void mdio_ofgpio_exit(void) { }
-#endif /* CONFIG_OF_GPIO */
-
 static struct platform_driver mdio_gpio_driver = {
         .probe = mdio_gpio_probe,
         .remove = __devexit_p(mdio_gpio_remove),
         .driver         = {
                 .name   = "mdio-gpio",
                 .owner  = THIS_MODULE,
+                .of_match_table = mdio_gpio_of_match,
         },
 };
 
 static int __init mdio_gpio_init(void)
 {
-        int ret;
-
-        ret = mdio_ofgpio_init();
-        if (ret)
-                return ret;
-
-        ret = platform_driver_register(&mdio_gpio_driver);
-        if (ret)
-                mdio_ofgpio_exit();
-
-        return ret;
+        return platform_driver_register(&mdio_gpio_driver);
 }
 module_init(mdio_gpio_init);
 
 static void __exit mdio_gpio_exit(void)
 {
         platform_driver_unregister(&mdio_gpio_driver);
-        mdio_ofgpio_exit();
 }
 module_exit(mdio_gpio_exit);
 
diff --git a/drivers/net/phy/mdio-mux-mmioreg.c b/drivers/net/phy/mdio-mux-mmioreg.c
new file mode 100644
index 000000000000..9061ba622ac4
--- /dev/null
+++ b/drivers/net/phy/mdio-mux-mmioreg.c
@@ -0,0 +1,171 @@
+/*
+ * Simple memory-mapped device MDIO MUX driver
+ *
+ * Author: Timur Tabi <timur@freescale.com>
+ *
+ * Copyright 2012 Freescale Semiconductor, Inc.
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2.  This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/device.h>
+#include <linux/of_address.h>
+#include <linux/of_mdio.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/phy.h>
+#include <linux/mdio-mux.h>
+
+struct mdio_mux_mmioreg_state {
+        void *mux_handle;
+        phys_addr_t phys;
+        uint8_t mask;
+};
+
+/*
+ * MDIO multiplexing switch function
+ *
+ * This function is called by the mdio-mux layer when it thinks the mdio bus
+ * multiplexer needs to switch.
+ *
+ * 'current_child' is the current value of the mux register (masked via
+ * s->mask).
+ *
+ * 'desired_child' is the value of the 'reg' property of the target child MDIO
+ * node.
+ *
+ * The first time this function is called, current_child == -1.
+ *
+ * If current_child == desired_child, then the mux is already set to the
+ * correct bus.
+ */
+static int mdio_mux_mmioreg_switch_fn(int current_child, int desired_child,
+                                      void *data)
+{
+        struct mdio_mux_mmioreg_state *s = data;
+
+        if (current_child ^ desired_child) {
+                void *p = ioremap(s->phys, 1);
+                uint8_t x, y;
+
+                if (!p)
+                        return -ENOMEM;
+
+                x = ioread8(p);
+                y = (x & ~s->mask) | desired_child;
+                if (x != y) {
+                        iowrite8((x & ~s->mask) | desired_child, p);
+                        pr_debug("%s: %02x -> %02x\n", __func__, x, y);
+                }
+
+                iounmap(p);
+        }
+
+        return 0;
+}
+
+static int __devinit mdio_mux_mmioreg_probe(struct platform_device *pdev)
+{
+        struct device_node *np2, *np = pdev->dev.of_node;
+        struct mdio_mux_mmioreg_state *s;
+        struct resource res;
+        const __be32 *iprop;
+        int len, ret;
+
+        dev_dbg(&pdev->dev, "probing node %s\n", np->full_name);
+
+        s = devm_kzalloc(&pdev->dev, sizeof(*s), GFP_KERNEL);
+        if (!s)
+                return -ENOMEM;
+
+        ret = of_address_to_resource(np, 0, &res);
+        if (ret) {
+                dev_err(&pdev->dev, "could not obtain memory map for node %s\n",
+                        np->full_name);
+                return ret;
+        }
+        s->phys = res.start;
+
+        if (resource_size(&res) != sizeof(uint8_t)) {
+                dev_err(&pdev->dev, "only 8-bit registers are supported\n");
+                return -EINVAL;
+        }
+
+        iprop = of_get_property(np, "mux-mask", &len);
+        if (!iprop || len != sizeof(uint32_t)) {
+                dev_err(&pdev->dev, "missing or invalid mux-mask property\n");
+                return -ENODEV;
+        }
+        if (be32_to_cpup(iprop) > 255) {
+                dev_err(&pdev->dev, "only 8-bit registers are supported\n");
+                return -EINVAL;
+        }
+        s->mask = be32_to_cpup(iprop);
+
+        /*
+         * Verify that the 'reg' property of each child MDIO bus does not
+         * set any bits outside of the 'mask'.
+         */
+        for_each_available_child_of_node(np, np2) {
+                iprop = of_get_property(np2, "reg", &len);
+                if (!iprop || len != sizeof(uint32_t)) {
+                        dev_err(&pdev->dev, "mdio-mux child node %s is "
+                                "missing a 'reg' property\n", np2->full_name);
+                        return -ENODEV;
+                }
+                if (be32_to_cpup(iprop) & ~s->mask) {
+                        dev_err(&pdev->dev, "mdio-mux child node %s has "
+                                "a 'reg' value with unmasked bits\n",
+                                np2->full_name);
+                        return -ENODEV;
+                }
+        }
+
+        ret = mdio_mux_init(&pdev->dev, mdio_mux_mmioreg_switch_fn,
+                            &s->mux_handle, s);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register mdio-mux bus %s\n",
+                        np->full_name);
+                return ret;
+        }
+
+        pdev->dev.platform_data = s;
+
+        return 0;
+}
+
+static int __devexit mdio_mux_mmioreg_remove(struct platform_device *pdev)
+{
+        struct mdio_mux_mmioreg_state *s = dev_get_platdata(&pdev->dev);
+
+        mdio_mux_uninit(s->mux_handle);
+
+        return 0;
+}
+
+static struct of_device_id mdio_mux_mmioreg_match[] = {
+        {
+                .compatible = "mdio-mux-mmioreg",
+        },
+        {},
+};
+MODULE_DEVICE_TABLE(of, mdio_mux_mmioreg_match);
+
+static struct platform_driver mdio_mux_mmioreg_driver = {
+        .driver = {
+                .name           = "mdio-mux-mmioreg",
+                .owner          = THIS_MODULE,
+                .of_match_table = mdio_mux_mmioreg_match,
+        },
+        .probe          = mdio_mux_mmioreg_probe,
+        .remove         = __devexit_p(mdio_mux_mmioreg_remove),
+};
+
+module_platform_driver(mdio_mux_mmioreg_driver);
+
+MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
+MODULE_DESCRIPTION("Memory-mapped device MDIO MUX driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c
index 7ca2ff97c368..ef9ea9248223 100644
--- a/drivers/net/phy/phy.c
+++ b/drivers/net/phy/phy.c
@@ -1035,66 +1035,6 @@ static void phy_write_mmd_indirect(struct mii_bus *bus, int prtad, int devad,
         bus->write(bus, addr, MII_MMD_DATA, data);
 }
 
-static u32 phy_eee_to_adv(u16 eee_adv)
-{
-        u32 adv = 0;
-
-        if (eee_adv & MDIO_EEE_100TX)
-                adv |= ADVERTISED_100baseT_Full;
-        if (eee_adv & MDIO_EEE_1000T)
-                adv |= ADVERTISED_1000baseT_Full;
-        if (eee_adv & MDIO_EEE_10GT)
-                adv |= ADVERTISED_10000baseT_Full;
-        if (eee_adv & MDIO_EEE_1000KX)
-                adv |= ADVERTISED_1000baseKX_Full;
-        if (eee_adv & MDIO_EEE_10GKX4)
-                adv |= ADVERTISED_10000baseKX4_Full;
-        if (eee_adv & MDIO_EEE_10GKR)
-                adv |= ADVERTISED_10000baseKR_Full;
-
-        return adv;
-}
-
-static u32 phy_eee_to_supported(u16 eee_caported)
-{
-        u32 supported = 0;
-
-        if (eee_caported & MDIO_EEE_100TX)
-                supported |= SUPPORTED_100baseT_Full;
-        if (eee_caported & MDIO_EEE_1000T)
-                supported |= SUPPORTED_1000baseT_Full;
-        if (eee_caported & MDIO_EEE_10GT)
-                supported |= SUPPORTED_10000baseT_Full;
-        if (eee_caported & MDIO_EEE_1000KX)
-                supported |= SUPPORTED_1000baseKX_Full;
-        if (eee_caported & MDIO_EEE_10GKX4)
-                supported |= SUPPORTED_10000baseKX4_Full;
-        if (eee_caported & MDIO_EEE_10GKR)
-                supported |= SUPPORTED_10000baseKR_Full;
-
-        return supported;
-}
-
-static u16 phy_adv_to_eee(u32 adv)
-{
-        u16 reg = 0;
-
-        if (adv & ADVERTISED_100baseT_Full)
-                reg |= MDIO_EEE_100TX;
-        if (adv & ADVERTISED_1000baseT_Full)
-                reg |= MDIO_EEE_1000T;
-        if (adv & ADVERTISED_10000baseT_Full)
-                reg |= MDIO_EEE_10GT;
-        if (adv & ADVERTISED_1000baseKX_Full)
-                reg |= MDIO_EEE_1000KX;
-        if (adv & ADVERTISED_10000baseKX4_Full)
-                reg |= MDIO_EEE_10GKX4;
-        if (adv & ADVERTISED_10000baseKR_Full)
-                reg |= MDIO_EEE_10GKR;
-
-        return reg;
-}
-
 /**
  * phy_init_eee - init and check the EEE feature
  * @phydev: target phy_device struct
@@ -1132,7 +1072,7 @@ int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
                 if (eee_cap < 0)
                         return eee_cap;
 
-                cap = phy_eee_to_supported(eee_cap);
+                cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap);
                 if (!cap)
                         goto eee_exit;
 
@@ -1149,8 +1089,8 @@ int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
                 if (eee_adv < 0)
                         return eee_adv;
 
-                adv = phy_eee_to_adv(eee_adv);
-                lp = phy_eee_to_adv(eee_lp);
+                adv = mmd_eee_adv_to_ethtool_adv_t(eee_adv);
+                lp = mmd_eee_adv_to_ethtool_adv_t(eee_lp);
                 idx = phy_find_setting(phydev->speed, phydev->duplex);
                 if ((lp & adv & settings[idx].setting))
                         goto eee_exit;
@@ -1210,21 +1150,21 @@ int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data)
                                     MDIO_MMD_PCS, phydev->addr);
         if (val < 0)
                 return val;
-        data->supported = phy_eee_to_supported(val);
+        data->supported = mmd_eee_cap_to_ethtool_sup_t(val);
 
         /* Get advertisement EEE */
         val = phy_read_mmd_indirect(phydev->bus, MDIO_AN_EEE_ADV,
                                     MDIO_MMD_AN, phydev->addr);
         if (val < 0)
                 return val;
-        data->advertised = phy_eee_to_adv(val);
+        data->advertised = mmd_eee_adv_to_ethtool_adv_t(val);
 
         /* Get LP advertisement EEE */
         val = phy_read_mmd_indirect(phydev->bus, MDIO_AN_EEE_LPABLE,
                                     MDIO_MMD_AN, phydev->addr);
         if (val < 0)
                 return val;
-        data->lp_advertised = phy_eee_to_adv(val);
+        data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val);
 
         return 0;
 }
@@ -1241,7 +1181,7 @@ int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data)
 {
         int val;
 
-        val = phy_adv_to_eee(data->advertised);
+        val = ethtool_adv_to_mmd_eee_adv_t(data->advertised);
         phy_write_mmd_indirect(phydev->bus, MDIO_AN_EEE_ADV, MDIO_MMD_AN,
                                phydev->addr, val);