I.MX6 PHY fixup 调用流程 hacking

Posted zengjf

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了I.MX6 PHY fixup 调用流程 hacking相关的知识,希望对你有一定的参考价值。

/**********************************************************************************
 *                      I.MX6 PHY fixup 调用流程 hacking
 * 说明:
 *     跟一下i.MX6中对PHY进行fixup的代码是如何被调用的。
 *              
 *                                          2017-4-14 深圳 龙华民治樟坑村 曾剑锋
 *********************************************************************************/
static struct platform_driver fec_driver = {  <-----+
    .driver    = {                                  |
        .name    = DRIVER_NAME,                     |
        .owner    = THIS_MODULE,                    |
        .pm    = &fec_pm_ops,                       |
        .of_match_table = fec_dt_ids,               |
    },                                              |
    .id_table = fec_devtype,               ---------*-+
    .probe    = fec_probe,                          | |
    .remove    = fec_drv_remove,                    | |
};                                                  | |
                                                    | |
module_platform_driver(fec_driver);        ---------+ |
                                                      |
MODULE_ALIAS("platform:"DRIVER_NAME);                 |
MODULE_LICENSE("GPL");                                |
                                                      |
static int                                            |
fec_probe(struct platform_device *pdev)    <----------+
{
    struct fec_enet_private *fep;
    struct fec_platform_data *pdata;
    struct net_device *ndev;
    int i, irq, ret = 0;
    struct resource *r;
    const struct of_device_id *of_id;
    static int dev_id;
    struct device_node *np = pdev->dev.of_node, *phy_node;
    int num_tx_qs;
    int num_rx_qs;

    fec_enet_get_queue_num(pdev, &num_tx_qs, &num_rx_qs);

    /* Init network device */
    ndev = alloc_etherdev_mqs(sizeof(struct fec_enet_private),
                  num_tx_qs, num_rx_qs);
    if (!ndev)
        return -ENOMEM;

    SET_NETDEV_DEV(ndev, &pdev->dev);

    /* setup board info structure */
    fep = netdev_priv(ndev);

    of_id = of_match_device(fec_dt_ids, &pdev->dev);
    if (of_id)
        pdev->id_entry = of_id->data;
    fep->quirks = pdev->id_entry->driver_data;

    fep->netdev = ndev;
    fep->num_rx_queues = num_rx_qs;
    fep->num_tx_queues = num_tx_qs;

#if !defined(CONFIG_M5272)
    /* default enable pause frame auto negotiation */
    if (fep->quirks & FEC_QUIRK_HAS_GBIT)
        fep->pause_flag |= FEC_PAUSE_FLAG_AUTONEG;
#endif

    /* Select default pin state */
    pinctrl_pm_select_default_state(&pdev->dev);

    r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    fep->hwp = devm_ioremap_resource(&pdev->dev, r);
    if (IS_ERR(fep->hwp)) {
        ret = PTR_ERR(fep->hwp);
        goto failed_ioremap;
    }

    fep->pdev = pdev;
    fep->dev_id = dev_id++;

    platform_set_drvdata(pdev, ndev);

    fec_enet_of_parse_stop_mode(pdev);

    if (of_get_property(np, "fsl,magic-packet", NULL))
        fep->wol_flag |= FEC_WOL_HAS_MAGIC_PACKET;

    phy_node = of_parse_phandle(np, "phy-handle", 0);
    if (!phy_node && of_phy_is_fixed_link(np)) {
        ret = of_phy_register_fixed_link(np);
        if (ret < 0) {
            dev_err(&pdev->dev,
                "broken fixed-link specification\n");
            goto failed_phy;
        }
        phy_node = of_node_get(np);
    }
    fep->phy_node = phy_node;

    ret = of_get_phy_mode(pdev->dev.of_node);
    if (ret < 0) {
        pdata = dev_get_platdata(&pdev->dev);
        if (pdata)
            fep->phy_interface = pdata->phy;
        else
            fep->phy_interface = PHY_INTERFACE_MODE_MII;
    } else {
        fep->phy_interface = ret;
    }

    fep->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
    if (IS_ERR(fep->clk_ipg)) {
        ret = PTR_ERR(fep->clk_ipg);
        goto failed_clk;
    }

    fep->clk_ahb = devm_clk_get(&pdev->dev, "ahb");
    if (IS_ERR(fep->clk_ahb)) {
        ret = PTR_ERR(fep->clk_ahb);
        goto failed_clk;
    }

    fep->itr_clk_rate = clk_get_rate(fep->clk_ahb);

    /* enet_out is optional, depends on board */
    fep->clk_enet_out = devm_clk_get(&pdev->dev, "enet_out");
    if (IS_ERR(fep->clk_enet_out))
        fep->clk_enet_out = NULL;

    fep->ptp_clk_on = false;
    mutex_init(&fep->ptp_clk_mutex);

    /* clk_ref is optional, depends on board */
    fep->clk_ref = devm_clk_get(&pdev->dev, "enet_clk_ref");
    if (IS_ERR(fep->clk_ref))
        fep->clk_ref = NULL;

    fep->bufdesc_ex = fep->quirks & FEC_QUIRK_HAS_BUFDESC_EX;
    fep->clk_ptp = devm_clk_get(&pdev->dev, "ptp");
    if (IS_ERR(fep->clk_ptp)) {
        fep->clk_ptp = NULL;
        fep->bufdesc_ex = false;
    }

    pm_runtime_enable(&pdev->dev);
    ret = fec_enet_clk_enable(ndev, true);
    if (ret)
        goto failed_clk;

    fep->reg_phy = devm_regulator_get(&pdev->dev, "phy");
    if (!IS_ERR(fep->reg_phy)) {
        ret = regulator_enable(fep->reg_phy);
        if (ret) {
            dev_err(&pdev->dev,
                "Failed to enable phy regulator: %d\n", ret);
            goto failed_regulator;
        }
    } else {
        fep->reg_phy = NULL;
    }

    fec_reset_phy(pdev);

    if (fep->bufdesc_ex)
        fec_ptp_init(pdev);

    ret = fec_enet_init(ndev);               ----------------------------+
    if (ret)                                                             |
        goto failed_init;                                                |
                                                                         |
    for (i = 0; i < FEC_IRQ_NUM; i++) {                                  |
        irq = platform_get_irq(pdev, i);                                 |
        if (irq < 0) {                                                   |
            if (i)                                                       |
                break;                                                   |
            ret = irq;                                                   |
            goto failed_irq;                                             |
        }                                                                |
        ret = devm_request_irq(&pdev->dev, irq, fec_enet_interrupt,      |
                       0, pdev->name, ndev);                             |
        if (ret)                                                         |
            goto failed_irq;                                             |
                                                                         |
        fep->irq[i] = irq;                                               |
    }                                                                    |
                                                                         |
    ret = of_property_read_u32(np, "fsl,wakeup_irq", &irq);              |
    if (!ret && irq < FEC_IRQ_NUM)                                       |
        fep->wake_irq = fep->irq[irq];                                   |
    else                                                                 |
        fep->wake_irq = fep->irq[0];                                     |
                                                                         |
    init_completion(&fep->mdio_done);                                    |
    ret = fec_enet_mii_init(pdev);                                       |
    if (ret)                                                             |
        goto failed_mii_init;                                            |
                                                                         |
    /* Carrier starts down, phylib will bring it up */                   |
    netif_carrier_off(ndev);                                             |
    fec_enet_clk_enable(ndev, false);                                    |
    pinctrl_pm_select_sleep_state(&pdev->dev);                           |
                                                                         |
    ret = register_netdev(ndev);                                         |
    if (ret)                                                             |
        goto failed_register;                                            |
                                                                         |
    device_init_wakeup(&ndev->dev, fep->wol_flag &                       |
               FEC_WOL_HAS_MAGIC_PACKET);                                |
                                                                         |
    if (fep->bufdesc_ex && fep->ptp_clock)                               |
        netdev_info(ndev, "registered PHC device %d\n", fep->dev_id);    |
                                                                         |
    fep->rx_copybreak = COPYBREAK_DEFAULT;                               |
    INIT_WORK(&fep->tx_timeout_work, fec_enet_timeout_work);             |
    return 0;                                                            |
                                                                         |
failed_register:                                                         |
    fec_enet_mii_remove(fep);                                            |
failed_mii_init:                                                         |
failed_irq:                                                              |
failed_init:                                                             |
    if (fep->reg_phy)                                                    |
        regulator_disable(fep->reg_phy);                                 |
failed_regulator:                                                        |
    fec_enet_clk_enable(ndev, false);                                    |
failed_clk:                                                              |
failed_phy:                                                              |
    of_node_put(phy_node);                                               |
failed_ioremap:                                                          |
    free_netdev(ndev);                                                   |
                                                                         |
    return ret;                                                          |
}                                                                        |
                                                                         |
 /*                                                                      |
  * XXX:  We need to clean up on failure exits here.                     |
  *                                                                      |
  */                                                                     |
static int fec_enet_init(struct net_device *ndev)      <-----------------+
{
    struct fec_enet_private *fep = netdev_priv(ndev);
    struct fec_enet_priv_tx_q *txq;
    struct fec_enet_priv_rx_q *rxq;
    struct bufdesc *cbd_base;
    dma_addr_t bd_dma;
    int bd_size;
    unsigned int i;

#if defined(CONFIG_ARM)
    fep->rx_align = 0xf;
    fep->tx_align = 0xf;
#else
    fep->rx_align = 0x3;
    fep->tx_align = 0x3;
#endif

    fec_enet_alloc_queue(ndev);

    if (fep->bufdesc_ex)
        fep->bufdesc_size = sizeof(struct bufdesc_ex);
    else
        fep->bufdesc_size = sizeof(struct bufdesc);
    bd_size = (fep->total_tx_ring_size + fep->total_rx_ring_size) *
            fep->bufdesc_size;

    /* Allocate memory for buffer descriptors. */
    cbd_base = dma_alloc_coherent(NULL, bd_size, &bd_dma,
                      GFP_KERNEL);
    if (!cbd_base) {
        return -ENOMEM;
    }

    memset(cbd_base, 0, bd_size);

    /* Get the Ethernet address */
    fec_get_mac(ndev);
    /* make sure MAC we just acquired is programmed into the hw */
    fec_set_mac_address(ndev, NULL);

    /* Set receive and transmit descriptor base. */
    for (i = 0; i < fep->num_rx_queues; i++) {
        rxq = fep->rx_queue[i];
        rxq->index = i;
        rxq->rx_bd_base = (struct bufdesc *)cbd_base;
        rxq->bd_dma = bd_dma;
        if (fep->bufdesc_ex) {
            bd_dma += sizeof(struct bufdesc_ex) * rxq->rx_ring_size;
            cbd_base = (struct bufdesc *)
                (((struct bufdesc_ex *)cbd_base) + rxq->rx_ring_size);
        } else {
            bd_dma += sizeof(struct bufdesc) * rxq->rx_ring_size;
            cbd_base += rxq->rx_ring_size;
        }
    }

    for (i = 0; i < fep->num_tx_queues; i++) {
        txq = fep->tx_queue[i];
        txq->index = i;
        txq->tx_bd_base = (struct bufdesc *)cbd_base;
        txq->bd_dma = bd_dma;
        if (fep->bufdesc_ex) {
            bd_dma += sizeof(struct bufdesc_ex) * txq->tx_ring_size;
            cbd_base = (struct bufdesc *)
             (((struct bufdesc_ex *)cbd_base) + txq->tx_ring_size);
        } else {
            bd_dma += sizeof(struct bufdesc) * txq->tx_ring_size;
            cbd_base += txq->tx_ring_size;
        }
    }


    /* The FEC Ethernet specific entries in the device structure */
    ndev->watchdog_timeo = TX_TIMEOUT;
    ndev->netdev_ops = &fec_netdev_ops;                --------------------+
    ndev->ethtool_ops = &fec_enet_ethtool_ops;                             |
                                                                           |
    writel(FEC_RX_DISABLED_IMASK, fep->hwp + FEC_IMASK);                   |
    netif_napi_add(ndev, &fep->napi, fec_enet_rx_napi, NAPI_POLL_WEIGHT);  |
                                                                           |
    if (fep->quirks & FEC_QUIRK_HAS_VLAN)                                  |
        /* enable hw VLAN support */                                       |
        ndev->features |= NETIF_F_HW_VLAN_CTAG_RX;                         |
                                                                           |
    if (fep->quirks & FEC_QUIRK_HAS_CSUM) {                                |
        ndev->gso_max_segs = FEC_MAX_TSO_SEGS;                             |
                                                                           |
        /* enable hw accelerator */                                        |
        ndev->features |= (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM             |
                | NETIF_F_RXCSUM | NETIF_F_SG | NETIF_F_TSO);              |
        fep->csum_flags |= FLAG_RX_CSUM_ENABLED;                           |
    }                                                                      |
                                                                           |
    if (fep->quirks & FEC_QUIRK_HAS_AVB) {                                 |
        fep->tx_align = 0;                                                 |
        fep->rx_align = 0x3f;                                              |
    }                                                                      |
                                                                           |
    ndev->hw_features = ndev->features;                                    |
                                                                           |
    fec_restart(ndev);                                                     |
                                                                           |
    return 0;                                                              |
}                                                                          |
                                                                           |
static const struct net_device_ops fec_netdev_ops = {          <-----------+
    .ndo_open        = fec_enet_open,               ---------+
    .ndo_stop        = fec_enet_close,                       |
    .ndo_start_xmit        = fec_enet_start_xmit,            |
    .ndo_select_queue       = fec_enet_select_queue,         |
    .ndo_set_rx_mode    = set_multicast_list,                |
    .ndo_change_mtu        = eth_change_mtu,                 |
    .ndo_validate_addr    = eth_validate_addr,               |
    .ndo_tx_timeout        = fec_timeout,                    |
    .ndo_set_mac_address    = fec_set_mac_address,           |
    .ndo_do_ioctl        = fec_enet_ioctl,                   |
#ifdef CONFIG_NET_POLL_CONTROLLER                            |
    .ndo_poll_controller    = fec_poll_controller,           |
#endif                                                       |
    .ndo_set_features    = fec_set_features,                 |
};                                                           |
                                                             |
static int                                                   |
fec_enet_open(struct net_device *ndev)              <--------+
{
    struct fec_enet_private *fep = netdev_priv(ndev);
    const struct platform_device_id *id_entry =
                platform_get_device_id(fep->pdev);
    int ret;

    pinctrl_pm_select_default_state(&fep->pdev->dev);
    ret = fec_enet_clk_enable(ndev, true);
    if (ret)
        return ret;

    /* I should reset the ring buffers here, but I don‘t yet know
     * a simple way to do that.
     */

    ret = fec_enet_alloc_buffers(ndev);
    if (ret)
        goto err_enet_alloc;

    /* Init MAC firstly for suspend/resume with megafix off case */
    fec_restart(ndev);

    /* Probe and connect to PHY when open the interface */
    ret = fec_enet_mii_probe(ndev);                          -----+
    if (ret)                                                      |
        goto err_enet_mii_probe;                                  |
                                                                  |
    napi_enable(&fep->napi);                                      |
    phy_start(fep->phy_dev);                                      |
    netif_tx_start_all_queues(ndev);                              |
                                                                  |
    pm_runtime_get_sync(ndev->dev.parent);                        |
    if ((id_entry->driver_data & FEC_QUIRK_BUG_WAITMODE) &&       |
        !fec_enet_irq_workaround(fep))                            |
        pm_qos_add_request(&ndev->pm_qos_req,                     |
                   PM_QOS_CPU_DMA_LATENCY,                        |
                   0);                                            |
    else                                                          |
        pm_qos_add_request(&ndev->pm_qos_req,                     |
                   PM_QOS_CPU_DMA_LATENCY,                        |
                   PM_QOS_DEFAULT_VALUE);                         |
                                                                  |
    device_set_wakeup_enable(&ndev->dev, fep->wol_flag &          |
                 FEC_WOL_FLAG_ENABLE);                            |
    fep->miibus_up_failed = false;                                |
                                                                  |
    return 0;                                                     |
                                                                  |
err_enet_mii_probe:                                               |
    fec_enet_free_buffers(ndev);                                  |
err_enet_alloc:                                                   |
    fep->miibus_up_failed = true;                                 |
    if (!fep->mii_bus_share)                                      |
        pinctrl_pm_select_sleep_state(&fep->pdev->dev);           |
    return ret;                                                   |
}                                                                 |
                                                                  |
static int fec_enet_mii_probe(struct net_device *ndev)       <----+
{
    struct fec_enet_private *fep = netdev_priv(ndev);
    struct phy_device *phy_dev = NULL;
    char mdio_bus_id[MII_BUS_ID_SIZE];
    char phy_name[MII_BUS_ID_SIZE + 3];
    int phy_id;
    int dev_id = fep->dev_id;

    fep->phy_dev = NULL;

    if (fep->phy_node) {
        phy_dev = of_phy_connect(ndev, fep->phy_node,
                     &fec_enet_adjust_link, 0,
                     fep->phy_interface);
        if (!phy_dev)
            return -ENODEV;
    } else {
        /* check for attached phy */
        for (phy_id = 0; (phy_id < PHY_MAX_ADDR); phy_id++) {
            if ((fep->mii_bus->phy_mask & (1 << phy_id)))
                continue;
            if (fep->mii_bus->phy_map[phy_id] == NULL)
                continue;
            if (fep->mii_bus->phy_map[phy_id]->phy_id == 0)
                continue;
            if (dev_id--)
                continue;
            strlcpy(mdio_bus_id, fep->mii_bus->id, MII_BUS_ID_SIZE);
            break;
        }

        if (phy_id >= PHY_MAX_ADDR) {
            netdev_info(ndev, "no PHY, assuming direct connection to switch\n");
            strlcpy(mdio_bus_id, "fixed-0", MII_BUS_ID_SIZE);
            phy_id = 0;
        }

        snprintf(phy_name, sizeof(phy_name),
             PHY_ID_FMT, mdio_bus_id, phy_id);
        phy_dev = phy_connect(ndev, phy_name, &fec_enet_adjust_link,      ---------------+
                      fep->phy_interface);                                               |
    }                                                                                    |
                                                                                         |
    if (IS_ERR(phy_dev)) {                                                               |
        netdev_err(ndev, "could not attach to PHY\n");                                   |
        return PTR_ERR(phy_dev);                                                         |
    }                                                                                    |
                                                                                         |
    /* mask with MAC supported features */                                               |
    if (fep->quirks & FEC_QUIRK_HAS_GBIT) {                                              |
        phy_dev->supported &= PHY_GBIT_FEATURES;                                         |
        // phy_dev->supported &= ~SUPPORTED_1000baseT_Half;                              |
        phy_dev->supported |= SUPPORTED_Pause;                                           |
        // phy_dev->supported |= SUPPORTED_1000baseT_Half;                               |
        printk("FEC_QUIRK_HAS_GBIT\n");                                                  |
#if !defined(CONFIG_M5272)                                                               |
        phy_dev->supported |= SUPPORTED_Pause;                                           |
#endif                                                                                   |
        phy_dev->advertising = phy_dev->supported;                                       |
    }                                                                                    |
    else                                                                                 |
    {                                                                                    |
        printk("PHY_BASIC_FEATURES\n");                                                  |
        // phy_dev->supported &= PHY_BASIC_FEATURES;                                     |
        phy_dev->advertising = phy_dev->supported & PHY_BASIC_FEATURES;                  |
    }                                                                                    |
    // phy_dev->advertising = phy_dev->supported;                                        |
                                                                                         |
    fep->phy_dev = phy_dev;                                                              |
    fep->link = 0;                                                                       |
    fep->full_duplex = 0;                                                                |
                                                                                         |
    netdev_info(ndev, "Freescale FEC PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n",   |
            fep->phy_dev->drv->name, dev_name(&fep->phy_dev->dev),                       |
            fep->phy_dev->irq);                                                          |
                                                                                         |
    return 0;                                                                            |
}                                                                                        |
                                                                                         |
struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,      <--------+
                   void (*handler)(struct net_device *),
                   phy_interface_t interface)
{
    struct phy_device *phydev;
    struct device *d;
    int rc;

    /* Search the list of PHY devices on the mdio bus for the
     * PHY with the requested name
     */
    d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
    if (!d) {
        pr_err("PHY %s not found\n", bus_id);
        return ERR_PTR(-ENODEV);
    }
    phydev = to_phy_device(d);

    rc = phy_connect_direct(dev, phydev, handler, interface);      --------------+
    if (rc)                                                                      |
        return ERR_PTR(rc);                                                      |
                                                                                 |
    return phydev;                                                               |
}                                                                                |
EXPORT_SYMBOL(phy_connect);                                                      |
                                                                                 |
int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,   <----+
               void (*handler)(struct net_device *),
               phy_interface_t interface)
{
    int rc;

    rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);    --------+
    if (rc)                                                                       |
        return rc;                                                                |
                                                                                  |
    phy_prepare_link(phydev, handler);                                            |
    phy_start_machine(phydev);                                                    |
    if (phydev->irq > 0)                                                          |
        phy_start_interrupts(phydev);                                             |
                                                                                  |
    return 0;                                                                     |
}                                                                                 |
EXPORT_SYMBOL(phy_connect_direct);                                                |
                                                                                  |
int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,  <-------+
              u32 flags, phy_interface_t interface)
{
    struct device *d = &phydev->dev;
    int err;

    /* Assume that if there is no driver, that it doesn‘t
     * exist, and we should use the genphy driver.
     */
    if (NULL == d->driver) {
        if (phydev->is_c45)
            d->driver = &genphy_driver[GENPHY_DRV_10G].driver;
        else
            d->driver = &genphy_driver[GENPHY_DRV_1G].driver;

        err = d->driver->probe(d);
        if (err >= 0)
            err = device_bind_driver(d);

        if (err)
            return err;
    }

    if (phydev->attached_dev) {
        dev_err(&dev->dev, "PHY already attached\n");
        return -EBUSY;
    }

    phydev->attached_dev = dev;
    dev->phydev = phydev;

    phydev->dev_flags = flags;

    phydev->interface = interface;

    phydev->state = PHY_READY;

    /* Do initial configuration here, now that
     * we have certain key parameters
     * (dev_flags and interface)
     */
    err = phy_init_hw(phydev);          --------------------+
    if (err)                                                |
        phy_detach(phydev);                                 |
    else                                                    |
        phy_resume(phydev);                                 |
                                                            |
    return err;                                             |
}                                                           |
EXPORT_SYMBOL(phy_attach_direct);                           |
                                                            |
int phy_init_hw(struct phy_device *phydev)     <------------+
{
    int ret;

    if (!phydev->drv || !phydev->drv->config_init)
        return 0;

    ret = phy_write(phydev, MII_BMCR, BMCR_RESET);
    if (ret < 0)
        return ret;

    ret = phy_poll_reset(phydev);
    if (ret < 0)
        return ret;

    ret = phy_scan_fixups(phydev);             -------------+
    if (ret < 0)                                            |
        return ret;                                         |
                                                            |
    return phydev->drv->config_init(phydev);                |
}                                                           |
EXPORT_SYMBOL(phy_init_hw);                                 |
                                                            |
/* Runs any matching fixups for this phydev */              |
int phy_scan_fixups(struct phy_device *phydev)     <--------+
{
    struct phy_fixup *fixup;

    mutex_lock(&phy_fixup_lock);
    list_for_each_entry(fixup, &phy_fixup_list, list) {      ------------------+
        if (phy_needs_fixup(phydev, fixup)) {      --------+                   |
            int err = fixup->run(phydev);                  |                   |
                                                           |                   |
            if (err < 0) {                                 |                   |
                mutex_unlock(&phy_fixup_lock);             |                   |
                return err;                                |                   |
            }                                              |                   |
        }                                                  |                   |
    }                                                      |                   |
    mutex_unlock(&phy_fixup_lock);                         |                   |
                                                           |                   |
    return 0;                                              |                   |
}                                                          |                   |
EXPORT_SYMBOL(phy_scan_fixups);                            |                   |
                    v--------------------------------------+                   |
static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup) |
{                                                                              |
    if (strcmp(fixup->bus_id, dev_name(&phydev->dev)) != 0)                    |
        if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)                            |
            return 0;                                                          |
                                                                               |
    if ((fixup->phy_uid & fixup->phy_uid_mask) !=                              |
        (phydev->phy_id & fixup->phy_uid_mask))                                |
        if (fixup->phy_uid != PHY_ANY_UID)                                     |
            return 0;                                                          |
                                                                               |
    return 1;                                                                  |
}                                                                              |
                                                                               |
static LIST_HEAD(phy_fixup_list);                            <-----------------+
                                                                               |
int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,  ----*-+
               int (*run)(struct phy_device *))                                | |
{                                                                              | |
    struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL);             | |
                                                                               | |
    if (!fixup)                                                                | |
        return -ENOMEM;                                                        | |
                                                                               | |
    strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));                     | |
    fixup->phy_uid = phy_uid;                                                  | |
    fixup->phy_uid_mask = phy_uid_mask;                                        | |
    fixup->run = run;                                                          | |
                                                                               | |
    mutex_lock(&phy_fixup_lock);                                               | |
    list_add_tail(&fixup->list, &phy_fixup_list);            <-----------------+ |
    mutex_unlock(&phy_fixup_lock);                                               |
                                                                                 |
    return 0;                                                                    |
}                                                                                |
EXPORT_SYMBOL(phy_register_fixup);                                               |
                                                                                 |
static void __init imx6q_enet_phy_init(void)                  -------------------*-+
{                                                                                | |
    if (IS_BUILTIN(CONFIG_PHYLIB)) {                                             | |
        phy_register_fixup_for_uid(PHY_ID_KSZ9021, MICREL_PHY_ID_MASK,           | |
                ksz9021rn_phy_fixup);                                            | |
        phy_register_fixup_for_uid(PHY_ID_KSZ9031, MICREL_PHY_ID_MASK,           | |
                ksz9031rn_phy_fixup);                                            | |
        phy_register_fixup_for_uid(PHY_ID_AR8031, 0xffffffff,      <-------------+ |
                ar8031_phy_fixup);                                 --------------+ |
        phy_register_fixup_for_uid(PHY_ID_AR8035, 0xffffffef,                    | |
                ar8035_phy_fixup);                                               | |
    }                                                                            | |
}                                                                                | |
                                                                                 | |
static int ar8031_phy_fixup(struct phy_device *dev)                <-------------+ |
{                                                                                  |
    u16 val;                                                                       |
                                                                                   |
    /* Set RGMII IO voltage to 1.8V */                                             |
    phy_write(dev, 0x1d, 0x1f);                                                    |
    phy_write(dev, 0x1e, 0x8);                                                     |
                                                                                   |
    /* disable phy AR8031 SmartEEE function. */                                    |
    phy_write(dev, 0xd, 0x3);                                                      |
    phy_write(dev, 0xe, 0x805d);                                                   |
    phy_write(dev, 0xd, 0x4003);                                                   |
    val = phy_read(dev, 0xe);                                                      |
    val &= ~(0x1 << 8);                                                            |
    phy_write(dev, 0xe, val);                                                      |
                                                                                   |
    /* To enable AR8031 output a 125MHz clk from CLK_25M */                        |
    phy_write(dev, 0xd, 0x7);                                                      |
    phy_write(dev, 0xe, 0x8016);                                                   |
    phy_write(dev, 0xd, 0x4007);                                                   |
                                                                                   |
    val = phy_read(dev, 0xe);                                                      |
    val &= 0xffe3;                                                                 |
    val |= 0x18;                                                                   |
    phy_write(dev, 0xe, val);                                                      |
                                                                                   |
    /* introduce tx clock delay */                                                 |
    phy_write(dev, 0x1d, 0x5);                                                     |
    val = phy_read(dev, 0x1e);                                                     |
    val |= 0x0100;                                                                 |
    phy_write(dev, 0x1e, val);                                                     |
                                                                                   |
    return 0;                                                                      |
}                                                                                  |
                                                                                   |
static inline void imx6q_enet_init(void)        -----------------------------------*-+
{                                                                                  | |
    imx6_enet_mac_init("fsl,imx6q-fec");                                           | |
    imx6q_enet_phy_init();                     <-----------------------------------+ |
    imx6q_1588_init();                                                               |
    if (cpu_is_imx6q() && imx_get_soc_revision() == IMX_CHIP_REVISION_2_0)           |
        imx6q_enet_clk_sel();                                                        |
    imx6q_enet_plt_init();                                                           |
}                                                                                    |
                                                                                     |
static void __init imx6q_init_machine(void)                                          |
{                                                                                    |
    struct device *parent;                                                           |
                                                                                     |
    if (cpu_is_imx6q() && imx_get_soc_revision() == IMX_CHIP_REVISION_2_0)           |
        imx_print_silicon_rev("i.MX6QP", IMX_CHIP_REVISION_1_0);                     |
    else                                                                             |
        imx_print_silicon_rev(cpu_is_imx6dl() ? "i.MX6DL" : "i.MX6Q",                |
                 imx_get_soc_revision());                                            |
                                                                                     |
    mxc_arch_reset_init_dt();                                                        |
                                                                                     |
    parent = imx_soc_device_init();                                                  |
    if (parent == NULL)                                                              |
        pr_warn("failed to initialize soc device\n");                                |
                                                                                     |
    of_platform_populate(NULL, of_default_bus_match_table,                           |
                    imx6q_auxdata_lookup, parent);                                   |
                                                                                     |
    imx6q_enet_init();                                   <---------------------------+
    imx_anatop_init();
    imx6q_csi_mux_init();
    cpu_is_imx6q() ?  imx6q_pm_init() : imx6dl_pm_init();
    imx6q_mini_pcie_init();
}

 

以上是关于I.MX6 PHY fixup 调用流程 hacking的主要内容,如果未能解决你的问题,请参考以下文章

I.MX6 recovery mode hacking

I.MX6 android BatteryService jni hacking

i.MX6ULL驱动开发 | 33 - NXP原厂网络设备驱动浅读(LAN8720 PHY)

I.MX6 AR8031 寄存器操作

i.MX6ULL驱动开发 | 33 - NXP原厂网络设备驱动浅读(LAN8720 PHY)

I.MX6 mfgtool2-android-mx6q-sabresd-emmc.vbs hacking