I.MX6 千兆网卡设置跟踪

Posted zengjf

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了I.MX6 千兆网卡设置跟踪相关的知识,希望对你有一定的参考价值。

/************************************************************************************
 *                           I.MX6 千兆网卡设置跟踪
 * 说明:
 *     设备只能识别到百兆网卡,跟一下源代码,找一下原因,结果是默认被注释了。
 *                                                  2017-4-5 深圳  南山平山村 曾剑锋
 ***********************************************************************************/


DT_MACHINE_START(IMX6Q, "Freescale i.MX6 Quad/DualLite (Device Tree)")
    /*
     * i.MX6Q/DL maps system memory at 0x10000000 (offset 256MiB), and
     * GPU has a limit on physical address that it accesses, which must
     * be below 2GiB.
     */
    .dma_zone_size    = (SZ_2G - SZ_256M),
    .smp        = smp_ops(imx_smp_ops),
    .map_io        = imx6q_map_io,
    .init_irq    = imx6q_init_irq,
    .init_machine    = imx6q_init_machine,   ----------------+
    .init_late      = imx6q_init_late,                       |
    .dt_compat     = imx6q_dt_compat,                        |
    .reserve     = imx6q_reserve,                            |
    .restart    = mxc_restart,                               |
MACHINE_END                                                  |
                                                             |
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();                                  |
}                                                            |
                                                             |
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();                                                  |                   | |
}                                                                           |                   | |
                                                                            |                   | |
void __init imx6_enet_mac_init(const char *compatible)        <-------------+                   | |
{                                                                                               | |
    struct device_node *ocotp_np, *enet_np, *from = NULL;                                       | |
    void __iomem *base;                                                                         | |
    struct property *newmac;                                                                    | |
    u32 macaddr_low;                                                                            | |
    u32 macaddr_high = 0;                                                                       | |
    u32 macaddr1_high = 0;                                                                      | |
    u8 *macaddr;                                                                                | |
    int i;                                                                                      | |
                                                                                                | |
    for (i = 0; i < 2; i++) {                                                                   | |
        enet_np = of_find_compatible_node(from, NULL, compatible);                              | |
        if (!enet_np)                                                                           | |
            return;                                                                             | |
                                                                                                | |
        from = enet_np;                                                                         | |
                                                                                                | |
        if (of_get_mac_address(enet_np))                                                        | |
            goto put_enet_node;                                                                 | |
                                                                                                | |
        ocotp_np = of_find_compatible_node(NULL,              --------+                         | |
            NULL, "fsl,imx6q-ocotp");                                 |                         | |
        if (!ocotp_np) {                                              |                         | |
            pr_warn("failed to find ocotp node\n");                   |                         | |
            goto put_enet_node;                                       |                         | |
        }                                                             |                         | |
                                                                      |                         | |
        base = of_iomap(ocotp_np, 0);                                 |                         | |
        if (!base) {                                                  |                         | |
            pr_warn("failed to map ocotp\n");                         |                         | |
            goto put_ocotp_node;                                      |                         | |
        }                                                             |                         | |
                                                                      |                         | |
        macaddr_low = readl_relaxed(base + OCOTP_MACn(1));            |                         | |
        if (i)                                                        |                         | |
            macaddr1_high = readl_relaxed(base + OCOTP_MACn(2));      |                         | |
        else                                                          |                         | |
            macaddr_high = readl_relaxed(base + OCOTP_MACn(0));       |                         | |
                                                                      |                         | |
        newmac = kzalloc(sizeof(*newmac) + 6, GFP_KERNEL);            |                         | |
        if (!newmac)                                                  |                         | |
            goto put_ocotp_node;                                      |                         | |
                                                                      |                         | |
        newmac->value = newmac + 1;                                   |                         | |
        newmac->length = 6;                                           |                         | |
        newmac->name = kstrdup("local-mac-address", GFP_KERNEL);      |                         | |
        if (!newmac->name) {                                          |                         | |
            kfree(newmac);                                            |                         | |
            goto put_ocotp_node;                                      |                         | |
        }                                                             |                         | |
                                                                      |                         | |
        macaddr = newmac->value;                                      |                         | |
        if (i) {                                                      |                         | |
            macaddr[5] = (macaddr_low >> 16) & 0xff;                  |                         | |
            macaddr[4] = (macaddr_low >> 24) & 0xff;                  |                         | |
            macaddr[3] = macaddr1_high & 0xff;                        |                         | |
            macaddr[2] = (macaddr1_high >> 8) & 0xff;                 |                         | |
            macaddr[1] = (macaddr1_high >> 16) & 0xff;                |                         | |
            macaddr[0] = (macaddr1_high >> 24) & 0xff;                |                         | |
        } else {                                                      |                         | |
            macaddr[5] = macaddr_high & 0xff;                         |                         | |
            macaddr[4] = (macaddr_high >> 8) & 0xff;                  |                         | |
            macaddr[3] = (macaddr_high >> 16) & 0xff;                 |                         | |
            macaddr[2] = (macaddr_high >> 24) & 0xff;                 |                         | |
            macaddr[1] = macaddr_low & 0xff;                          |                         | |
            macaddr[0] = (macaddr_low >> 8) & 0xff;                   |                         | |
        }                                                             |                         | |
                                                                      |                         | |
        of_update_property(enet_np, newmac);                          |                         | |
                                                                      |                         | |
put_ocotp_node:                                                       |                         | |
    of_node_put(ocotp_np);                                            |                         | |
put_enet_node:                                                        |                         | |
    of_node_put(enet_np);                                             |                         | |
    }                                                                 |                         | |
}                             +---------------------------------------+                         | |
                              V                                                                 | |
struct device_node *of_find_compatible_node(struct device_node *from,                           | |
    const char *type, const char *compatible)                                                   | |
{                                                                                               | |
    struct device_node *np;                                                                     | |
    unsigned long flags;                                                                        | |
                                                                                                | |
    raw_spin_lock_irqsave(&devtree_lock, flags);                                                | |
    np = from ? from->allnext : of_allnodes;        -------------------+                        | |
    for (; np; np = np->allnext) {                                     |                        | |
        if (__of_device_is_compatible(np, compatible, type, NULL) &&   |                        | |
            of_node_get(np))                                           |                        | |
            break;                                                     |                        | |
    }                                                                  |                        | |
    of_node_put(from);                                                 |                        | |
    raw_spin_unlock_irqrestore(&devtree_lock, flags);                  |                        | |
    return np;                                                         |                        | |
}                                                                      |                        | |
EXPORT_SYMBOL(of_find_compatible_node);                                |                        | |
                                                                       |                        | |
struct device_node *of_allnodes;           <---------------------------+                        | |
EXPORT_SYMBOL(of_allnodes);                ------------+                                        | |
                                                       |                                        | |
void __init unflatten_device_tree(void)                |                                        | |
{                                                      V                                        | |
    __unflatten_device_tree(initial_boot_params, &of_allnodes,    ---------+                    | |
                early_init_dt_alloc_memory_arch);                 ---------*-+                  | |
                                                                           | |                  | |
    /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */ | |                  | |
    of_alias_scan(early_init_dt_alloc_memory_arch);               ---------*-*-+                | |
}                                                                          | | |                | |
                                                                           | | |                | |
static void __unflatten_device_tree(struct boot_param_header *blob,  <-----+ | |                | |
                 struct device_node **mynodes,                               | |                | |
                 void * (*dt_alloc)(u64 size, u64 align))                    | |                | |
{                                                                            | |                | |
    unsigned long size;                                                      | |                | |
    int start;                                                               | |                | |
    void *mem;                                                               | |                | |
    struct device_node **allnextp = mynodes;                                 | |                | |
                                                                             | |                | |
    pr_debug(" -> unflatten_device_tree()\n");                               | |                | |
                                                                             | |                | |
    if (!blob) {                                                             | |                | |
        pr_debug("No device tree pointer\n");                                | |                | |
        return;                                                              | |                | |
    }                                                                        | |                | |
                                                                             | |                | |
    pr_debug("Unflattening device tree:\n");                                 | |                | |
    pr_debug("magic: %08x\n", be32_to_cpu(blob->magic));                     | |                | |
    pr_debug("size: %08x\n", be32_to_cpu(blob->totalsize));                  | |                | |
    pr_debug("version: %08x\n", be32_to_cpu(blob->version));                 | |                | |
                                                                             | |                | |
    if (be32_to_cpu(blob->magic) != OF_DT_HEADER) {                          | |                | |
        pr_err("Invalid device tree blob header\n");                         | |                | |
        return;                                                              | |                | |
    }                                                                        | |                | |
                                                                             | |                | |
    /* First pass, scan for size */                                          | |                | |
    start = 0;                                                               | |                | |
    size = (unsigned long)unflatten_dt_node(blob, 0, &start, NULL, NULL, 0); | |                | |
    size = ALIGN(size, 4);                                                   | |                | |
                                                                             | |                | |
    pr_debug("  size is %lx, allocating...\n", size);                        | |                | |
                                                                             | |                | |
    /* Allocate memory for the expanded device tree */                       | |                | |
    mem = dt_alloc(size + 4, __alignof__(struct device_node));               | |                | |
    memset(mem, 0, size);                                                    | |                | |
                                                                             | |                | |
    *(__be32 *)(mem + size) = cpu_to_be32(0xdeadbeef);                       | |                | |
                                                                             | |                | |
    pr_debug("  unflattening %p...\n", mem);                                 | |                | |
                                                                             | |                | |
    /* Second pass, do actual unflattening */                                | |                | |
    start = 0;                                                               | |                | |
    unflatten_dt_node(blob, mem, &start, NULL, &allnextp, 0);                | |                | |
    if (be32_to_cpup(mem + size) != 0xdeadbeef)                              | |                | |
        pr_warning("End of tree marker overwritten: %08x\n",                 | |                | |
               be32_to_cpup(mem + size));                                    | |                | |
    *allnextp = NULL;                                                        | |                | |
                                                                             | |                | |
    pr_debug(" <- unflatten_device_tree()\n");                               | |                | |
}                                                                            | |                | |
                                                                             | |                | |
void * __init early_init_dt_alloc_memory_arch(u64 size, u64 align)  <--------+ |                | |
{                                                                              |                | |
    return memblock_virt_alloc(size, align);                                   |                | |
}                                                                              |                | |
                                                                               |                | |
static inline void * __init memblock_virt_alloc(               <---------------+                | |
                    phys_addr_t size,  phys_addr_t align)                                       | |
{                                                                                               | |
    return memblock_virt_alloc_try_nid(size, align, BOOTMEM_LOW_LIMIT, -----+                   | |
                        BOOTMEM_ALLOC_ACCESSIBLE,                           |                   | |
                        NUMA_NO_NODE);                                      |                   | |
}                                                                           |                   | |
                                                                            |                   | |
void * __init memblock_virt_alloc_try_nid(                      <-----------+                   | |
            phys_addr_t size, phys_addr_t align,                                                | |
            phys_addr_t min_addr, phys_addr_t max_addr,                                         | |
            int nid)                                                                            | |
{                                                                                               | |
    void *ptr;                                                                                  | |
                                                                                                | |
    memblock_dbg("%s: %llu bytes align=0x%llx nid=%d from=0x%llx max_addr=0x%llx %pF\n",        | |
             __func__, (u64)size, (u64)align, nid, (u64)min_addr,                               | |
             (u64)max_addr, (void *)_RET_IP_);                                                  | |
    ptr = memblock_virt_alloc_internal(size, align,                                             | |
                       min_addr, max_addr, nid);                                                | |
    if (ptr)                                                                                    | |
        return ptr;                                                                             | |
                                                                                                | |
    panic("%s: Failed to allocate %llu bytes align=0x%llx nid=%d from=0x%llx max_addr=0x%llx\n",| |
          __func__, (u64)size, (u64)align, nid, (u64)min_addr,                                  | |
          (u64)max_addr);                                                                       | |
    return NULL;                                                                                | |
}                                                                                               | |
                                                                                                | |
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 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);                        |                  |                   |
                                                           |                  |                   |
static struct platform_device_id fec_devtype[] = {  <------+                  |                   |
    {                                                                         |                   |
        /* keep it for coldfire */                                            |                   |
        .name = DRIVER_NAME,                                                  |                   |
        .driver_data = 0,                                                     |                   |
    }, {                                                                      |                   |
        .name = "imx25-fec",                                                  |                   |
        .driver_data = FEC_QUIRK_USE_GASKET,                                  |                   |
    }, {                                                                      |                   |
        .name = "imx27-fec",                                                  |                   |
        .driver_data = 0,                                                     |                   |
    }, {                                                                      |                   |
        .name = "imx28-fec",                                                  |                   |
        .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_SWAP_FRAME,             |                   |
    }, {                                                                      |                   |
        .name = "imx6q-fec",                                       <----------*-------------------+
        .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT |   -----------*------+
                FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM |               |      |
                FEC_QUIRK_HAS_VLAN | FEC_QUIRK_ERR006358 |                    |      |
                FEC_QUIRK_BUG_WAITMODE,                                       |      |
    }, {                                                                      |      |
        .name = "mvf600-fec",                                                 |      |
        .driver_data = FEC_QUIRK_ENET_MAC,                                    |      |
    }, {                                                                      |      |
        .name = "imx6sx-fec",                                                 |      |
        .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT |              |      |
                FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM |               |      |
                FEC_QUIRK_HAS_VLAN | FEC_QUIRK_HAS_AVB |                      |      |
                FEC_QUIRK_ERR007885 | FEC_QUIRK_TKT210590,                    |      |
    }, {                                                                      |      |
        .name = "imx6ul-fec",                                                 |      |
        .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT |              |      |
                FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM |               |      |
                FEC_QUIRK_HAS_VLAN,                                           |      |
    }, {                                                                      |      |
        /* sentinel */                                                        |      |
    }                                                                         |      |
};                                                                            |      |
MODULE_DEVICE_TABLE(platform, fec_devtype);                                   |      |
                                                                              |      |
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;                                                        |             |     |
}                                                                      |             |     |
                                                                       |             |     |
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;                                 |
        //printk("FEC_QUIRK_HAS_GBIT\n");                                                  |
#if !defined(CONFIG_M5272)                                                                 |
        //phy_dev->supported |= SUPPORTED_Pause;                                           |
#endif                                                                                     |
    //}                                                                                    |
    //else                                                                                 |
    {                                                                                      |
        printk("PHY_BASIC_FEATURES\n");                                                    |
        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;                                                                              |
}                                                                                          |
                                                                                           |
static int fec_enet_mii_init(struct platform_device *pdev)              <------------------+
{
    static struct mii_bus *fec0_mii_bus;
    static int *fec_mii_bus_share;
    struct net_device *ndev = platform_get_drvdata(pdev);
    struct fec_enet_private *fep = netdev_priv(ndev);
    struct device_node *node;
    int err = -ENXIO, i;
    u32 mii_speed, holdtime;

    /*
     * The dual fec interfaces are not equivalent with enet-mac.
     * Here are the differences:
     *
     *  - fec0 supports MII & RMII modes while fec1 only supports RMII
     *  - fec0 acts as the 1588 time master while fec1 is slave
     *  - external phys can only be configured by fec0
     *
     * That is to say fec1 can not work independently. It only works
     * when fec0 is working. The reason behind this design is that the
     * second interface is added primarily for Switch mode.
     *
     * Because of the last point above, both phys are attached on fec0
     * mdio interface in board design, and need to be configured by
     * fec0 mii_bus.
     */
    if ((fep->quirks & FEC_QUIRK_ENET_MAC) && fep->dev_id > 0) {
        /* fec1 uses fec0 mii_bus */
        if (mii_cnt && fec0_mii_bus) {
            fep->mii_bus = fec0_mii_bus;
            *fec_mii_bus_share = FEC0_MII_BUS_SHARE_TRUE;
            mii_cnt++;
            return 0;
        }
        return -ENOENT;
    }

    fep->mii_timeout = 0;

    /*
     * Set MII speed to 2.5 MHz (= clk_get_rate() / 2 * phy_speed)
     *
     * The formula for FEC MDC is ‘ref_freq / (MII_SPEED x 2)‘ while
     * for ENET-MAC is ‘ref_freq / ((MII_SPEED + 1) x 2)‘.  The i.MX28
     * Reference Manual has an error on this, and gets fixed on i.MX6Q
     * document.
     */
    mii_speed = DIV_ROUND_UP(clk_get_rate(fep->clk_ipg), 5000000);
    if (fep->quirks & FEC_QUIRK_ENET_MAC)
        mii_speed--;
    if (mii_speed > 63) {
        dev_err(&pdev->dev,
            "fec clock (%lu) to fast to get right mii speed\n",
            clk_get_rate(fep->clk_ipg));
        err = -EINVAL;
        goto err_out;
    }

    /*
     * The i.MX28 and i.MX6 types have another filed in the MSCR (aka
     * MII_SPEED) register that defines the MDIO output hold time. Earlier
     * versions are RAZ there, so just ignore the difference and write the
     * register always.
     * The minimal hold time according to IEE802.3 (clause 22) is 10 ns.
     * HOLDTIME + 1 is the number of clk cycles the fec is holding the
     * output.
     * The HOLDTIME bitfield takes values between 0 and 7 (inclusive).
     * Given that ceil(clkrate / 5000000) <= 64, the calculation for
     * holdtime cannot result in a value greater than 3.
     */
    holdtime = DIV_ROUND_UP(clk_get_rate(fep->clk_ipg), 100000000) - 1;

    fep->phy_speed = mii_speed << 1 | holdtime << 8;

    writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);

    fep->mii_bus = mdiobus_alloc();
    if (fep->mii_bus == NULL) {
        err = -ENOMEM;
        goto err_out;
    }

    fep->mii_bus->name = "fec_enet_mii_bus";
    fep->mii_bus->read = fec_enet_mdio_read;
    fep->mii_bus->write = fec_enet_mdio_write;
    snprintf(fep->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
        pdev->name, fep->dev_id + 1);
    fep->mii_bus->priv = fep;
    fep->mii_bus->parent = &pdev->dev;

    fep->mii_bus->irq = kmalloc(sizeof(int) * PHY_MAX_ADDR, GFP_KERNEL);
    if (!fep->mii_bus->irq) {
        err = -ENOMEM;
        goto err_out_free_mdiobus;
    }

    for (i = 0; i < PHY_MAX_ADDR; i++)
        fep->mii_bus->irq[i] = PHY_POLL;

    node = of_get_child_by_name(pdev->dev.of_node, "mdio");
    if (node) {
        err = of_mdiobus_register(fep->mii_bus, node);
        of_node_put(node);
    } else {
        err = mdiobus_register(fep->mii_bus);
    }

    if (err)
        goto err_out_free_mdio_irq;

    mii_cnt++;

    /* save fec0 mii_bus */
    if (fep->quirks & FEC_QUIRK_ENET_MAC) {
        fec0_mii_bus = fep->mii_bus;
        fec_mii_bus_share = &fep->mii_bus_share;
    }

    return 0;

err_out_free_mdio_irq:
    kfree(fep->mii_bus->irq);
err_out_free_mdiobus:
    mdiobus_free(fep->mii_bus);
err_out:
    return err;
}

 

以上是关于I.MX6 千兆网卡设置跟踪的主要内容,如果未能解决你的问题,请参考以下文章

I.MX6 网卡能收不能发

千兆网卡安装以后只有4百兆,与啥有关

i.MX6ULL驱动开发 | 32 - 手动编写一个虚拟网卡设备

i.MX6ULL驱动开发 | 32 - 手动编写一个虚拟网卡设备

服务器标配万兆网口,没有千兆网口怎么办

i.MX6ULL驱动开发 | 29 - 使用USB WIFI网卡(RTL8188EU)