static struct at803x_platform_data eap120_ar8035_data = {
    .enable_rgmii_tx_delay = 1,
    .enable_rgmii_rx_delay = 1,
};

static struct mdio_board_info eap120_mdio0_info[] = {
    {
        .bus_id = "ag71xx-mdio.0",
        .phy_addr = 0,
        .platform_data = &eap120_ar8035_data,
    },
};

mdiobus_register_board_info(eap120_mdio0_info, ARRAY_SIZE(eap120_mdio0_info));

/*
 * OF helpers for the MDIO (Ethernet PHY) API
 *
 * Copyright (c) 2009 Secret Lab Technologies, Ltd.
 *
 * This file is released under the GPLv2
 *
 * This file provides helper functions for extracting PHY device information
 * out of the OpenFirmware device tree and using it to populate an mii_bus.
 */

#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/netdevice.h>
#include <linux/err.h>
#include <linux/phy.h>
#include <linux/phy_fixed.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/of_mdio.h>
#include <linux/module.h>

MODULE_AUTHOR("Grant Likely <grant.likely@secretlab.ca>");
MODULE_LICENSE("GPL");

/* Extract the clause 22 phy ID from the compatible string of the form
 * ethernet-phy-idAAAA.BBBB */
static int of_get_phy_id(struct device_node *device, u32 *phy_id)
{
    struct property *prop;
    const char *cp;
    unsigned int upper, lower;

    of_property_for_each_string(device, "compatible", prop, cp) {
        if (sscanf(cp, "ethernet-phy-id%4x.%4x", &upper, &lower) == 2) {
            *phy_id = ((upper & 0xFFFF) << 16) | (lower & 0xFFFF);
            return 0;
        }
    }
    return -EINVAL;
}

static int of_mdiobus_register_phy(struct mii_bus *mdio, struct device_node *child,
                   u32 addr)
{
    struct phy_device *phy;
    bool is_c45;
    int rc;
    u32 phy_id;

    is_c45 = of_device_is_compatible(child,
                     "ethernet-phy-ieee802.3-c45");

    if (!is_c45 && !of_get_phy_id(child, &phy_id))
        phy = phy_device_create(mdio, addr, phy_id, 0, NULL);
    else
        phy = get_phy_device(mdio, addr, is_c45);
    if (!phy || IS_ERR(phy))
        return 1;

    rc = irq_of_parse_and_map(child, 0);
    if (rc > 0) {
        phy->irq = rc;
        if (mdio->irq)
            mdio->irq[addr] = rc;
    } else {
        if (mdio->irq)
            phy->irq = mdio->irq[addr];
    }

    if (of_property_read_bool(child, "broken-turn-around"))
        mdio->phy_ignore_ta_mask |= 1 << addr;

    /* Associate the OF node with the device structure so it
     * can be looked up later */
    of_node_get(child);
    phy->dev.of_node = child;

    /* All data is now stored in the phy struct;
     * register it */
    rc = phy_device_register(phy);
    if (rc) {
        phy_device_free(phy);
        of_node_put(child);
        return 1;
    }

    dev_dbg(&mdio->dev, "registered phy %s at address %i\n",
        child->name, addr);

    return 0;
}

int of_mdio_parse_addr(struct device *dev, const struct device_node *np)
{
    u32 addr;
    int ret;

    ret = of_property_read_u32(np, "reg", &addr);
    if (ret < 0) {
        dev_err(dev, "%s has invalid PHY address\n", np->full_name);
        return ret;
    }

    /* A PHY must have a reg property in the range [0-31] */
    if (addr >= PHY_MAX_ADDR) {
        dev_err(dev, "%s PHY address %i is too large\n",
            np->full_name, addr);
        return -EINVAL;
    }

    return addr;
}
EXPORT_SYMBOL(of_mdio_parse_addr);

/**
 * of_mdiobus_register - Register mii_bus and create PHYs from the device tree
 * @mdio: pointer to mii_bus structure
 * @np: pointer to device_node of MDIO bus.
 *
 * This function registers the mii_bus structure and registers a phy_device
 * for each child node of @np.
 */
int of_mdiobus_register(struct mii_bus *mdio, struct device_node *np)
{
    struct device_node *child;
    const __be32 *paddr;
    bool scanphys = false;
    int addr, rc, i;

    /* Mask out all PHYs from auto probing.  Instead the PHYs listed in
     * the device tree are populated after the bus has been registered */
    mdio->phy_mask = ~0;

    /* Clear all the IRQ properties */
    if (mdio->irq)
        for (i=0; i<PHY_MAX_ADDR; i++)
            mdio->irq[i] = PHY_POLL;

    mdio->dev.of_node = np;

    /* Register the MDIO bus */
    rc = mdiobus_register(mdio);
    if (rc)
        return rc;

    /* Loop over the child nodes and register a phy_device for each one */
    for_each_available_child_of_node(np, child) {
        addr = of_mdio_parse_addr(&mdio->dev, child);
        if (addr < 0) {
            scanphys = true;
            continue;
        }

        rc = of_mdiobus_register_phy(mdio, child, addr);
        if (rc)
            continue;
    }

    if (!scanphys)
        return 0;

    /* auto scan for PHYs with empty reg property */
    for_each_available_child_of_node(np, child) {
        /* Skip PHYs with reg property set */
        paddr = of_get_property(child, "reg", NULL);
        if (paddr)
            continue;

        for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
            /* skip already registered PHYs */
            if (mdio->phy_map[addr])
                continue;

            /* be noisy to encourage people to set reg property */
            dev_info(&mdio->dev, "scan phy %s at address %i\n",
                 child->name, addr);

            rc = of_mdiobus_register_phy(mdio, child, addr);
            if (rc)
                continue;
        }
    }

    return 0;
}
EXPORT_SYMBOL(of_mdiobus_register);

/* Helper function for of_phy_find_device */
static int of_phy_match(struct device *dev, void *phy_np)
{
    return dev->of_node == phy_np;
}

/**
 * of_phy_find_device - Give a PHY node, find the phy_device
 * @phy_np: Pointer to the phy's device tree node
 *
 * If successful, returns a pointer to the phy_device with the embedded
 * struct device refcount incremented by one, or NULL on failure.
 */
struct phy_device *of_phy_find_device(struct device_node *phy_np)
{
    struct device *d;
    if (!phy_np)
        return NULL;

    d = bus_find_device(&mdio_bus_type, NULL, phy_np, of_phy_match);
    return d ? to_phy_device(d) : NULL;
}
EXPORT_SYMBOL(of_phy_find_device);

/**
 * of_phy_connect - Connect to the phy described in the device tree
 * @dev: pointer to net_device claiming the phy
 * @phy_np: Pointer to device tree node for the PHY
 * @hndlr: Link state callback for the network device
 * @iface: PHY data interface type
 *
 * If successful, returns a pointer to the phy_device with the embedded
 * struct device refcount incremented by one, or NULL on failure. The
 * refcount must be dropped by calling phy_disconnect() or phy_detach().
 */
struct phy_device *of_phy_connect(struct net_device *dev,
                  struct device_node *phy_np,
                  void (*hndlr)(struct net_device *), u32 flags,
                  phy_interface_t iface)
{
    struct phy_device *phy = of_phy_find_device(phy_np);
    int ret;

    if (!phy)
        return NULL;

    phy->dev_flags = flags;

    ret = phy_connect_direct(dev, phy, hndlr, iface);

    /* refcount is held by phy_connect_direct() on success */
    put_device(&phy->dev);

    return ret ? NULL : phy;
}
EXPORT_SYMBOL(of_phy_connect);

/**
 * of_phy_attach - Attach to a PHY without starting the state machine
 * @dev: pointer to net_device claiming the phy
 * @phy_np: Node pointer for the PHY
 * @flags: flags to pass to the PHY
 * @iface: PHY data interface type
 *
 * If successful, returns a pointer to the phy_device with the embedded
 * struct device refcount incremented by one, or NULL on failure. The
 * refcount must be dropped by calling phy_disconnect() or phy_detach().
 */
struct phy_device *of_phy_attach(struct net_device *dev,
                 struct device_node *phy_np, u32 flags,
                 phy_interface_t iface)
{
    struct phy_device *phy = of_phy_find_device(phy_np);
    int ret;

    if (!phy)
        return NULL;

    ret = phy_attach_direct(dev, phy, flags, iface);

    /* refcount is held by phy_attach_direct() on success */
    put_device(&phy->dev);

    return ret ? NULL : phy;
}
EXPORT_SYMBOL(of_phy_attach);

#if defined(CONFIG_FIXED_PHY)
/*
 * of_phy_is_fixed_link() and of_phy_register_fixed_link() must
 * support two DT bindings:
 * - the old DT binding, where 'fixed-link' was a property with 5
 *   cells encoding various informations about the fixed PHY
 * - the new DT binding, where 'fixed-link' is a sub-node of the
 *   Ethernet device.
 */
bool of_phy_is_fixed_link(struct device_node *np)
{
    struct device_node *dn;
    int len, err;
    const char *managed;

    /* New binding */
    dn = of_get_child_by_name(np, "fixed-link");
    if (dn) {
        of_node_put(dn);
        return true;
    }

    err = of_property_read_string(np, "managed", &managed);
    if (err == 0 && strcmp(managed, "auto") != 0)
        return true;

    /* Old binding */
    if (of_get_property(np, "fixed-link", &len) &&
        len == (5 * sizeof(__be32)))
        return true;

    return false;
}
EXPORT_SYMBOL(of_phy_is_fixed_link);

int of_phy_register_fixed_link(struct device_node *np)
{
    struct fixed_phy_status status = {};
    struct device_node *fixed_link_node;
    const __be32 *fixed_link_prop;
    int link_gpio;
    int len, err;
    struct phy_device *phy;
    const char *managed;

    err = of_property_read_string(np, "managed", &managed);
    if (err == 0) {
        if (strcmp(managed, "in-band-status") == 0) {
            /* status is zeroed, namely its .link member */
            phy = fixed_phy_register(PHY_POLL, &status, -1, np);
            return IS_ERR(phy) ? PTR_ERR(phy) : 0;
        }
    }

    /* New binding */
    fixed_link_node = of_get_child_by_name(np, "fixed-link");
    if (fixed_link_node) {
        status.link = 1;
        status.duplex = of_property_read_bool(fixed_link_node,
                              "full-duplex");
        if (of_property_read_u32(fixed_link_node, "speed", &status.speed))
            return -EINVAL;
        status.pause = of_property_read_bool(fixed_link_node, "pause");
        status.asym_pause = of_property_read_bool(fixed_link_node,
                              "asym-pause");
        link_gpio = of_get_named_gpio_flags(fixed_link_node,
                            "link-gpios", 0, NULL);
        of_node_put(fixed_link_node);
        if (link_gpio == -EPROBE_DEFER)
            return -EPROBE_DEFER;

        phy = fixed_phy_register(PHY_POLL, &status, link_gpio, np);
        return IS_ERR(phy) ? PTR_ERR(phy) : 0;
    }

    /* Old binding */
    fixed_link_prop = of_get_property(np, "fixed-link", &len);
    if (fixed_link_prop && len == (5 * sizeof(__be32))) {
        status.link = 1;
        status.duplex = be32_to_cpu(fixed_link_prop[1]);
        status.speed = be32_to_cpu(fixed_link_prop[2]);
        status.pause = be32_to_cpu(fixed_link_prop[3]);
        status.asym_pause = be32_to_cpu(fixed_link_prop[4]);
        phy = fixed_phy_register(PHY_POLL, &status, -1, np);
        return IS_ERR(phy) ? PTR_ERR(phy) : 0;
    }

    return -ENODEV;
}
EXPORT_SYMBOL(of_phy_register_fixed_link);
#endif

[    0.644090] libphy: GPIO Bitbanged MDIO: probed
[    1.312556] ag71xx ag71xx.0: connected to PHY at gpio-0:04 [uid=004dd072, driver=Atheros 8035 ethernet]
[    1.322850] eth0: Atheros AG71xx at 0xb9000000, irq 4, mode:RGMII

[  388.682669] eth0: link down
[  388.685896] br-lan: port 1(eth0) entered disabled state
[  393.683840] eth0: link up (1000Mbps/Full duplex)
[  393.688715] br-lan: port 1(eth0) entered forwarding state
[  393.694304] br-lan: port 1(eth0) entered forwarding state
[  395.692057] br-lan: port 1(eth0) entered forwarding state

root@(none):/# cat /etc/config/network

config interface 'loopback'
        option ifname 'lo'
        option proto 'static'
        option ipaddr '127.0.0.1'
        option netmask '255.0.0.0'

config globals 'globals'
        option ula_prefix 'fd5e:3b17:1fe7::/48'

config interface 'lan'
        option type 'bridge'
        option ifname 'eth0'
        option proto 'static'
        option ipaddr '192.168.1.1'
        option netmask '255.255.255.0'
        option ip6assign '60'

root@lede:/# ifconfig
br-lan    Link encap:Ethernet  HWaddr 14:CC:20:2D:57:91
          inet addr:192.168.1.1  Bcast:192.168.1.255  Mask:255.255.255.0
          inet6 addr: fd05:8c87:cb72::1/60 Scope:Global
          inet6 addr: fe80::16cc:20ff:fe2d:5791/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:968 errors:0 dropped:0 overruns:0 frame:0
          TX packets:459 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:70410 (68.7 KiB)  TX bytes:39667 (38.7 KiB)

eth0      Link encap:Ethernet  HWaddr 14:CC:20:2D:57:91
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:355 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:0 (0.0 B)  TX bytes:29837 (29.1 KiB)
          Interrupt:4

lo        Link encap:Local Loopback
          inet addr:127.0.0.1  Mask:255.0.0.0
          inet6 addr: ::1/128 Scope:Host
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:288 errors:0 dropped:0 overruns:0 frame:0
          TX packets:288 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1
          RX bytes:18720 (18.2 KiB)  TX bytes:18720 (18.2 KiB)

wlan0     Link encap:Ethernet  HWaddr 14:CC:20:2D:57:91
          inet6 addr: fe80::16cc:20ff:fe2d:5791/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:1166 errors:0 dropped:0 overruns:0 frame:0
          TX packets:1005 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:134215 (131.0 KiB)  TX bytes:108416 (105.8 KiB)

File name              : /home/hyniu/Pulpit/Archer MR200v1_0.9.1_0.0_update_1041_1021_2009.bin
File size              : 0x03486273 / 55075443 bytes
Version 2 Header size  : 0x00000200 /      512 bytes
Unknown value 1        : 0x01000000 / 16777216 bytes
Header MD5Sum1         : bb c0 50 dc c2 34 0f e2 fa 17 9c f6 47 20 b2 a3 (*ERROR*)
          --> expected : 72 f7 b1 a3 b2 72 3f 2a 24 d1 07 56 ab 9c 21 8f 
Header MD5Sum2         : ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff (purpose yet unknown, unchecked here)

Firmware version       : ver. 2.0
Hardware ID            : 0xd7500001 (ArcherMR200)
Hardware Revision      : 0x0000004a (ok)
Software version       : 0.9.1-0.0

Kernel data offset     : 0x00000200 /      512 bytes
Kernel data length     : 0x00136338 /  1270584 bytes
Kernel load address    : 0x00000080                  (OpenWrt default: 0x80000000)
Kernel entry point     : 0x50c10080                  (OpenWrt default: 0x80000000)
Rootfs data offset     : 0x00140000 /  1310720 bytes (== OpenWrt default)
Rootfs data length     : 0x00483000 /  4730880 bytes
Boot loader data offset: 0x00000000 /        0 bytes
Boot loader data length: 0x0001d6ac /   120492 bytes
Total firmware length  : 0x007d0200 /  8192512 bytes

File size              : 0x0348871b / 55084827 bytes
Version 2 Header size  : 0x00000200 /      512 bytes
Header MD5Sum1         : ce cd 33 a1 a5 62 08 e2 03 7c 2f 47 d1 61 d5 37 (*ERROR*)
          --> expected : 8d 9b b8 d7 67 66 5e 76 5d d9 51 f2 ac bc 16 28 
Header MD5Sum2         : ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff (purpose yet unknown, unchecked here)

Firmware version       : ver. 2.0
Hardware ID            : 0xd7500001 (ArcherMR200)
Hardware Revision      : 0x0000004a (ok)
Software version       : 0.9.1-0.0

Kernel data offset     : 0x00000200 /      512 bytes
Kernel data length     : 0x001361ec /  1270252 bytes
Kernel load address    : 0x00000080                  (OpenWrt default: 0x80000000)
Kernel entry point     : 0x50c10080                  (OpenWrt default: 0x80000000)
Rootfs data offset     : 0x00140000 /  1310720 bytes (== OpenWrt default)
Rootfs data length     : 0x00481000 /  4722688 bytes
Boot loader data offset: 0x00000000 /        0 bytes
Boot loader data length: 0x0001d74c /   120652 bytes
Total firmware length  : 0x007d0200 /  8192512 bytes