基于335X的UBOOT网口驱动分析

一、软硬件平台资料

1、 开发板：创龙AM3359核心板，网口采用RMII形式

2、 UBOOT版本：U-Boot-2016.05，采用FDT和DM。

参考链接：

https://blog.csdn.net/hahachenchen789/article/details/53339181

二、网口相关代码位置

1、 网口的PINMUX设置

RMII接口的相关PINMUX在MLO中进行设置，具体的设置代码为
|-board_init_f

|-board_early_init_f

|-set_mux_conf_regs

|-enable_board_pin_mux

configure_module_pin_mux(rmii1_pin_mux);

2、 网口的初始化设置

（1）网口的初始化在UBOOT中进行，具体设置代码为

 |-board_init_r

   |-init_sequence_r

     |-initr_net

       |- eth_initialize   （eth-uclass.c）

三、有关网口的DM&FDT分析

1、 驱动实现方式

此版本的UBOOT中使用了FDT文件进行外设的相关配置，驱动模型使用了DM方式，有关FDT以及DM相关的知识请参考如下文章

https://blog.csdn.net/ooonebook/article/details/53206623

https://blog.csdn.net/ooonebook/article/details/53234020

2、 UBOOT中DM初始化

DM的初始化

.创建根设备root的udevice，存放在gd->dm_root中。

.根设备其实是一个虚拟设备，主要是为uboot的其他设备提供一个挂载点。

.初始化uclass链表gd->uclass_root

DM中udevice和uclass的解析

.udevice的创建和uclass的创建

.udevice和uclass的绑定

.uclass_driver和uclass的绑定

.driver和udevice的绑定

.部分driver函数的调用

（1）DM初始化调用过程

dm初始化的接口在dm_init_and_scan中。 可以发现在uboot relocate之前的initf_dm和之后的initr_dm都调用了这个函数。

static int initf_dm(void)

{

#if defined(CONFIG_DM) && defined(CONFIG_SYS_MALLOC_F_LEN)

int ret;

ret = dm_init_and_scan(true); // 调用dm_init_and_scan对DM进行初始化和设备的解析

if (ret)

    return ret;

#endif

return 0;

}

#ifdef CONFIG_DM

static int initr_dm(void)

{

int ret;

/* Save the pre-reloc driver model and start a new one */

gd->dm_root_f = gd->dm_root; // 存储relocate之前的根设备

gd->dm_root = NULL;

ret = dm_init_and_scan(false); // 调用dm_init_and_scan对DM进行初始化和设备的解析

if (ret)

    return ret;

return 0;

}

#endif

主要区别在于参数。

首先说明一下dts节点中的“u-boot,dm-pre-reloc”属性，当设置了这个属性时，则表示这个设备在relocate之前就需要使用。

当dm_init_and_scan的参数为true时，只会对带有“u-boot,dm-pre-reloc”属性的节点进行解析。而当参数为false的时候，则会对所有节点都进行解析。

由于“u-boot,dm-pre-reloc”的情况比较少，所以这里只学习参数为false的情况。也就是initr_dm里面的dm_init_and_scan(false);。

dm_init_and_scan（driver/core/root.c）说明

int dm_init_and_scan(bool pre_reloc_only)

{

int ret;

ret = dm_init();    // DM的初始化

if (ret) {

    debug("dm_init() failed: %d\n", ret);

    return ret;

}

ret = dm_scan_platdata(pre_reloc_only); //  从平台设备中解析udevice和uclass

if (ret) {

    debug("dm_scan_platdata() failed: %d\n", ret);

    return ret;

}

if (CONFIG_IS_ENABLED(OF_CONTROL)) {

    ret = dm_scan_fdt(gd->fdt_blob, pre_reloc_only); // 从dtb中解析udevice和uclass

    if (ret) {

        debug("dm_scan_fdt() failed: %d\n", ret);

        return ret;

    }

}

ret = dm_scan_other(pre_reloc_only);

if (ret)

    return ret;

return 0;

}

DM的初始化—dm_init（driver/core/root.c）

#define DM_ROOT_NON_CONST (((gd_t *)gd)->dm_root) // 宏定义根设备指针gd->dm_root

#define DM_UCLASS_ROOT_NON_CONST (((gd_t *)gd)->uclass_root) // 宏定义gd->uclass_root，uclass的链表

int dm_init(void)

{

int ret;

if (gd->dm_root) {

// 根设备已经存在，说明DM已经初始化过了

    dm_warn("Virtual root driver already exists!\n");

    return -EINVAL;

}

INIT_LIST_HEAD(&DM_UCLASS_ROOT_NON_CONST);

    // 初始化uclass链表

ret = device_bind_by_name(NULL, false, &root_info, &DM_ROOT_NON_CONST);

    // DM_ROOT_NON_CONST是指根设备udevice，root_info是表示根设备的设备信息

    // device_bind_by_name会查找和设备信息匹配的driver，然后创建对应的udevice和uclass并进行绑定，最后放在DM_ROOT_NON_CONST中。

    // device_bind_by_name后续我们会进行说明，这里我们暂时只需要了解root根设备的udevice以及对应的uclass都已经创建完成。

if (ret)

    return ret;

#if CONFIG_IS_ENABLED(OF_CONTROL)

DM_ROOT_NON_CONST->of_offset = 0;

#endif

ret = device_probe(DM_ROOT_NON_CONST);

    // 对根设备执行probe操作，

    // device_probe后续再进行说明

if (ret)

    return ret;

return 0;

}

这里就完成的DM的初始化了

1）创建根设备root的udevice，存放在gd->dm_root中。

2）初始化uclass链表gd->uclass_root

（2）从平台设备中解析udevice和uclass—dm_scan_platdata（不涉及）

（3）从dtb中解析udevice和uclass——dm_scan_fdt

对应代码如下driver/core/root.c

int dm_scan_fdt(const void *blob, bool pre_reloc_only)

// 此时传进来的参数blob=gd->fdt_blob， pre_reloc_only=0

{

return dm_scan_fdt_node(gd->dm_root, blob, 0, pre_reloc_only);

// 直接调用dm_scan_fdt_node

}

int dm_scan_fdt_node(struct udevice parent, const void blob, int offset,

         bool pre_reloc_only)

// 此时传进来的参数

// parent=gd->dm_root，表示以root设备作为父设备开始解析

// blob=gd->fdt_blob，指定了对应的dtb

// offset=0，从偏移0的节点开始扫描

// pre_reloc_only=0，不只是解析relotion之前的设备

{

int ret = 0, err;

    /*  以下步骤相当于是遍历每一个dts节点并且调用lists_bind_fdt对其进行解析 */

for (offset = fdt_first_subnode(blob, offset);

    // 获得blob设备树的offset偏移下的节点的第一个子节点

     offset > 0;

     offset = fdt_next_subnode(blob, offset)) {

           // 循环查找下一个子节点

    if (!fdtdec_get_is_enabled(blob, offset)) {

                    // 判断节点状态是否是disable，如果是的话直接忽略

        dm_dbg("   - ignoring disabled device\n");

        continue;

    }

    err = lists_bind_fdt(parent, blob, offset, NULL);

            // 解析绑定这个节点，dm_scan_fdt的核心，下面具体分析

    if (err && !ret) {

        ret = err;

        debug("%s: ret=%d\n", fdt_get_name(blob, offset, NULL),

              ret);

    }

}

return ret;

}

lists_bind_fdt是从dtb中解析udevice和uclass的核心。

其具体实现如下： driver/core/lists.c

int lists_bind_fdt(struct udevice parent, const void blob, int offset,

       struct udevice **devp)

// parent指定了父设备，通过blob和offset可以获得对应的设备的dts节点，对应udevice结构通过devp返回

{

struct driver *driver = ll_entry_start(struct driver, driver);

// 获取driver table地址

const int n_ents = ll_entry_count(struct driver, driver);

// 获取driver table长度

const struct udevice_id *id;

struct driver *entry;

struct udevice *dev;

bool found = false;

const char *name;

int result = 0;

int ret = 0;

dm_dbg("bind node %s\n", fdt_get_name(blob, offset, NULL));

// 打印当前解析的节点的名称

if (devp)

    *devp = NULL;

for (entry = driver; entry != driver + n_ents; entry++) {

// 遍历driver table中的所有driver，具体参考三、4一节

    ret = driver_check_compatible(blob, offset, entry->of_match,

                      &id);

// 判断driver中的compatibile字段和dts节点是否匹配

    name = fdt_get_name(blob, offset, NULL);

// 获取节点名称

    if (ret == -ENOENT) {

        continue;

    } else if (ret == -ENODEV) {

        dm_dbg("Device '%s' has no compatible string\n", name);

        break;

    } else if (ret) {

        dm_warn("Device tree error at offset %d\n", offset);

        result = ret;

        break;

    }

    dm_dbg("   - found match at '%s'\n", entry->name);

    ret = device_bind(parent, entry, name, NULL, offset, &dev);

// 找到对应的driver，调用device_bind进行绑定，会在这个函数中创建对应udevice和uclass并切进行绑定，后面继续说明

    if (ret) {

        dm_warn("Error binding driver '%s': %d\n", entry->name,

            ret);

        return ret;

    } else {

        dev->driver_data = id->data;

        found = true;

        if (devp)

            *devp = dev;

// 将udevice设置到devp指向的地方中，进行返回

    }

    break;

}

if (!found && !result && ret != -ENODEV) {

    dm_dbg("No match for node '%s'\n",

           fdt_get_name(blob, offset, NULL));

}

return result;

}

在device_bind中实现了udevice和uclass的创建和绑定以及一些初始化操作，这里专门学习一下device_bind。

device_bind的实现如下(去除部分代码)

driver/core/device.c

int device_bind(struct udevice parent, const struct driver drv,

    const char *name, void *platdata, int of_offset,

    struct udevice **devp)

// parent:父设备

// drv：设备对应的driver

// name：设备名称

// platdata：设备的平台数据指针

// of_offset：在dtb中的偏移，即代表了其dts节点

// devp：所创建的udevice的指针，用于返回

{

struct udevice *dev;

struct uclass *uc;

int size, ret = 0;

ret = uclass_get(drv->id, &uc);

    // 获取driver id对应的uclass，如果uclass原先并不存在，那么会在这里创建uclass并其uclass_driver进行绑定

dev = calloc(1, sizeof(struct udevice));

    // 分配一个udevice

dev->platdata = platdata; // 设置udevice的平台数据指针

dev->name = name; // 设置udevice的name

dev->of_offset = of_offset; // 设置udevice的dts节点偏移

dev->parent = parent; // 设置udevice的父设备

dev->driver = drv;    // 设置udevice的对应的driver，相当于driver和udevice的绑定

dev->uclass = uc;    // 设置udevice的所属uclass

dev->seq = -1;

dev->req_seq = -1;

if (CONFIG_IS_ENABLED(OF_CONTROL) && CONFIG_IS_ENABLED(DM_SEQ_ALIAS)) {

    /*

     * Some devices, such as a SPI bus, I2C bus and serial ports

     * are numbered using aliases.

     *

     * This is just a 'requested' sequence, and will be

     * resolved (and ->seq updated) when the device is probed.

     */

    if (uc->uc_drv->flags & DM_UC_FLAG_SEQ_ALIAS) {

        if (uc->uc_drv->name && of_offset != -1) {

            fdtdec_get_alias_seq(gd->fdt_blob,

                    uc->uc_drv->name, of_offset,

                    &dev->req_seq);

        }

                // 设置udevice的alias请求序号

    }

}

if (!dev->platdata && drv->platdata_auto_alloc_size) {

    dev->flags |= DM_FLAG_ALLOC_PDATA;

    dev->platdata = calloc(1, drv->platdata_auto_alloc_size);

            // 为udevice分配平台数据的空间，由driver中的platdata_auto_alloc_size决定

}

size = uc->uc_drv->per_device_platdata_auto_alloc_size;

if (size) {

    dev->flags |= DM_FLAG_ALLOC_UCLASS_PDATA;

    dev->uclass_platdata = calloc(1, size);

            // 为udevice分配给其所属uclass使用的平台数据的空间，由所属uclass的driver中的per_device_platdata_auto_alloc_size决定

}

/* put dev into parent's successor list */

if (parent)

    list_add_tail(&dev->sibling_node, &parent->child_head);

    // 添加到父设备的子设备链表中

ret = uclass_bind_device(dev);

    // uclass和udevice进行绑定，主要是实现了将udevice链接到uclass的设备链表中

/* if we fail to bind we remove device from successors and free it */

if (drv->bind) {

    ret = drv->bind(dev);

    // 执行udevice对应driver的bind函数

}

if (parent && parent->driver->child_post_bind) {

    ret = parent->driver->child_post_bind(dev);

    // 执行父设备的driver的child_post_bind函数

}

if (uc->uc_drv->post_bind) {

    ret = uc->uc_drv->post_bind(dev);

    if (ret)

        goto fail_uclass_post_bind;

    // 执行所属uclass的post_bind函数

}

if (devp)

    *devp = dev;

    // 将udevice进行返回

dev->flags |= DM_FLAG_BOUND;

    // 设置已经绑定的标志

    // 后续可以通过dev->flags & DM_FLAG_ACTIVATED或者device_active宏来判断设备是否已经被激活

return 0;

在init_sequence_r中的initr_dm中，完成了FDT的解析，解析了所有的外设node,并针对各个节点进行了 udevice和uclass的创建，以及各个组成部分的绑定关系。

注意，这里只是绑定，即调用了driver的bind函数，但是设备还没有真正激活，也就是还没有执行设备的probe函数。

将在网口初始化阶段进行相关driver的bind操作。

四、网口的初始化过程分析

1、 eth_initialize函数

网口初始化，其中最主要的工作是调用uclass_first_device(UCLASS_ETH, &dev)函数，从uclass的设备链表中获取第一个udevice，并且进行probe。最终，是通过调用device_probe(dev)进行网口设备的激活和驱动的注册。下面分析device_probe(dev)的实现的部分过程。

int device_probe(struct udevice *dev)

{

const struct driver *drv;

int size = 0;

int ret;

int seq;

if (dev->flags & DM_FLAG_ACTIVATED)

    return 0;

// 表示这个设备已经被激活了

drv = dev->driver;

assert(drv);

// 获取这个设备对应的driver

/* Allocate private data if requested and not reentered */

if (drv->priv_auto_alloc_size && !dev->priv) {

    dev->priv = alloc_priv(drv->priv_auto_alloc_size, drv->flags);

// 为设备分配私有数据

}

/* Allocate private data if requested and not reentered */

size = dev->uclass->uc_drv->per_device_auto_alloc_size;

if (size && !dev->uclass_priv) {

    dev->uclass_priv = calloc(1, size);

// 为设备所属uclass分配私有数据

}

// 这里过滤父设备的probe

seq = uclass_resolve_seq(dev);

if (seq < 0) {

    ret = seq;

    goto fail;

}

dev->seq = seq;

dev->flags |= DM_FLAG_ACTIVATED;

// 设置udevice的激活标志

ret = uclass_pre_probe_device(dev);

// uclass在probe device之前的一些函数的调用

if (drv->ofdata_to_platdata && dev->of_offset >= 0) {

    ret = drv->ofdata_to_platdata(dev);

// 调用driver中的ofdata_to_platdata将dts信息转化为设备的平台数据

}

if (drv->probe) {

    ret = drv->probe(dev);

// 调用driver的probe函数，到这里设备才真正激活了

}

ret = uclass_post_probe_device(dev);

return ret;

}

主要工作归纳如下：

.分配设备的私有数据

.对父设备进行probe

.执行probe device之前uclass需要调用的一些函数

.调用driver的ofdata_to_platdata，将dts信息转化为设备的平台数据（重要）

.调用driver的probe函数（重要）

.执行probe device之后uclass需要调用的一些函数

在CPSW.c中有相关定义：

U_BOOT_DRIVER(eth_cpsw) = {

     .name       = "eth_cpsw",

     .id     = UCLASS_ETH,

     .of_match = cpsw_eth_ids,

     .ofdata_to_platdata = cpsw_eth_ofdata_to_platdata,

     .probe      = cpsw_eth_probe,

     .ops = &cpsw_eth_ops,

     .priv_auto_alloc_size = sizeof(struct cpsw_priv),

     .platdata_auto_alloc_size = sizeof(struct eth_pdata),

     .flags = DM_FLAG_ALLOC_PRIV_DMA,

};

2、有关DTS配置信息转化的函数（drv->ofdata_to_platdata）

static int cpsw_eth_ofdata_to_platdata(struct udevice *dev)

{

     struct eth_pdata *pdata = dev_get_platdata(dev);

     struct cpsw_priv *priv = dev_get_priv(dev);

     const char *phy_mode;

     const char *phy_sel_compat = NULL;

     const void *fdt = gd->fdt_blob;

     int node = dev->of_offset;

     int subnode;

     int slave_index = 0;

     int active_slave;

     int ret;

     pdata->iobase = dev_get_addr(dev);

     priv->data.version = CPSW_CTRL_VERSION_2;

     priv->data.bd_ram_ofs = CPSW_BD_OFFSET;

     priv->data.ale_reg_ofs = CPSW_ALE_OFFSET;

     priv->data.cpdma_reg_ofs = CPSW_CPDMA_OFFSET;

     priv->data.mdio_div = CPSW_MDIO_DIV;

     priv->data.host_port_reg_ofs = CPSW_HOST_PORT_OFFSET,

     pdata->phy_interface = -1;

     priv->data.cpsw_base = pdata->iobase;

     priv->data.channels = fdtdec_get_int(fdt, node, "cpdma_channels", -1);

     if (priv->data.channels <= 0) {

               printf("error: cpdma_channels not found in dt\n");

               return -ENOENT;

     }

     priv->data.slaves = fdtdec_get_int(fdt, node, "slaves", -1);

     if (priv->data.slaves <= 0) {

               printf("error: slaves not found in dt\n");

               return -ENOENT;

     }

     priv->data.slave_data = malloc(sizeof(struct cpsw_slave_data) *

                                        priv->data.slaves);

     priv->data.ale_entries = fdtdec_get_int(fdt, node, "ale_entries", -1);

     if (priv->data.ale_entries <= 0) {

               printf("error: ale_entries not found in dt\n");

               return -ENOENT;

     }

     priv->data.bd_ram_ofs = fdtdec_get_int(fdt, node, "bd_ram_size", -1);

     if (priv->data.bd_ram_ofs <= 0) {

               printf("error: bd_ram_size not found in dt\n");

               return -ENOENT;

     }

     priv->data.mac_control = fdtdec_get_int(fdt, node, "mac_control", -1);

     if (priv->data.mac_control <= 0) {

               printf("error: ale_entries not found in dt\n");

               return -ENOENT;

     }

     active_slave = fdtdec_get_int(fdt, node, "active_slave", 0);

     priv->data.active_slave = active_slave;

     fdt_for_each_subnode(fdt, subnode, node) {

               int len;

               const char *name;

               name = fdt_get_name(fdt, subnode, &len);

               if (!strncmp(name, "mdio", 4)) {

                        u32 mdio_base;

                        mdio_base = cpsw_get_addr_by_node(fdt, subnode);

                        if (mdio_base == FDT_ADDR_T_NONE) {

                                 error("Not able to get MDIO address space\n");

                                 return -ENOENT;

                        }

                        priv->data.mdio_base = mdio_base;

               }

               if (!strncmp(name, "slave", 5)) {

                        u32 phy_id[2];

                        if (slave_index >= priv->data.slaves)

                                 continue;

                        phy_mode = fdt_getprop(fdt, subnode, "phy-mode", NULL);

                        if (phy_mode)

                                 priv->data.slave_data[slave_index].phy_if =

                                           phy_get_interface_by_name(phy_mode);

                        priv->data.slave_data[slave_index].phy_of_handle =

                                 fdtdec_lookup_phandle(fdt, subnode, "phy-handle");

                        if (priv->data.slave_data[slave_index].phy_of_handle >= 0) {

                                 priv->data.slave_data[slave_index].phy_addr =

                                           fdtdec_get_int(gd->fdt_blob,

                                                    priv->data.slave_data[slave_index].phy_of_handle,

                                                    "reg", -1);

                        } else {

                                 fdtdec_get_int_array(fdt, subnode, "phy_id", phy_id, 2);

                                 priv->data.slave_data[slave_index].phy_addr = phy_id[1];

                        }

                        slave_index++;

               }

               if (!strncmp(name, "cpsw-phy-sel", 12)) {

                        priv->data.gmii_sel = cpsw_get_addr_by_node(fdt,

                                                                           subnode);

                        if (priv->data.gmii_sel == FDT_ADDR_T_NONE) {

                                 error("Not able to get gmii_sel reg address\n");

                                 return -ENOENT;

                        }

                        if (fdt_get_property(fdt, subnode, "rmii-clock-ext",

                                                NULL))

                                 {

                                      priv->data.rmii_clock_external = true;

                                      printf("data.rmii_clock_external is true\n"); 

                                 }

                        phy_sel_compat = fdt_getprop(fdt, subnode, "compatible",

                                                         NULL);

                        if (!phy_sel_compat) {

                                 printf("Not able to get gmii_sel compatible\n");

                                 return -ENOENT;

                        }

               }

     }

     priv->data.slave_data[0].slave_reg_ofs = CPSW_SLAVE0_OFFSET;

     priv->data.slave_data[0].sliver_reg_ofs = CPSW_SLIVER0_OFFSET;

     if (priv->data.slaves == 2) {

               priv->data.slave_data[1].slave_reg_ofs = CPSW_SLAVE1_OFFSET;

               priv->data.slave_data[1].sliver_reg_ofs = CPSW_SLIVER1_OFFSET;

     }

     ret = ti_cm_get_macid(dev, active_slave, pdata->enetaddr);

     if (ret < 0) {

               error("cpsw read efuse mac failed\n");

               return ret;

     }

     pdata->phy_interface = priv->data.slave_data[active_slave].phy_if;

     if (pdata->phy_interface == -1) {

               debug("%s: Invalid PHY interface '%s'\n", __func__, phy_mode);

               return -EINVAL;

     }

     /* Select phy interface in control module */

     cpsw_phy_sel(priv, phy_sel_compat, pdata->phy_interface);

     return 0;

}

可以看到，在cpsw_eth_ofdata_to_platdata函数中将各种与CPSW有关的平台数据宏定义以及DTS中的配置信息（包含个子节点）转化为了平台数据存储在了priv->data的相关部分中。主要涉及priv->data的相关设置，此部分重要的信息是MAC的接口形式，比如RMII的设置，RMII时钟的使能，phy_addr的设置。

3、有关驱动注册的函数（drv->probe(dev)）

static int cpsw_eth_probe(struct udevice *dev)

{

     struct cpsw_priv *priv = dev_get_priv(dev);

   printf("cpsw_eth_probe now\n");

     priv->dev = dev;

     return _cpsw_register(priv);

}

TI对于网卡设备的通用管理是CPSW方式，通过cpsw_priv结构体来进行相关的管理，cpsw_priv结构体中包含有CPSW平台数据、cpsw_slave的信息、priv->bus（MII接口管理）、phy_device设备的配置及管理等。

cpsw_register(priv)函数主要进行以下工作

（1）、首先是声明几个结构体变量，其中包括cpsw的主：cpsw_priv和从：cpsw_slave，然后是设置cpsw的基础寄存器的地址cpsw_base，然后调用calloc函数为这些结构体分配空间。

struct cpsw_slave *slave;

struct cpsw_platform_data *data = &priv->data;

void regs = (void )data->cpsw_base;

priv->slaves = malloc(sizeof(struct cpsw_slave) * data->slaves);

（2）、分配好后对priv结构体中的成员进行初始化，host_port=0表示主机端口号是0，然后成员的寄存器的偏移地址进行初始化。

Priv->host_port = data->host_port_num;

     priv->regs                  = regs;

     priv->host_port_regs       = regs + data->host_port_reg_ofs;

     priv->dma_regs                 = regs + data->cpdma_reg_ofs;

     priv->ale_regs          = regs + data->ale_reg_ofs;

     priv->descs                = (void *)regs + data->bd_ram_ofs;

（3）、对每个salve进行初始化，这里采用for循环的意义在于可能有多个网卡，am335支持双网卡。

for_each_slave(slave, priv) {

               cpsw_slave_setup(slave, idx, priv);

               idx = idx + 1;

                        } 

（4）、对MDIO接口的操作集进行初始化配置

cpsw_mdio_init(priv->dev->name, data->mdio_base, data->mdio_div);

.进行了mii_dev设备的创建

.进行了mdio_regs寄存器的配置（set enable and clock divider）

.进行了cpsw_mdio_read/ cpsw_mdio_write的定义（用此函数对PHY进行读写）

.mii_dev设备注册（加到mii_devs链表，并指定为current_mii）

(4)指定priv->bus为上一步创建的设备

priv->bus = miiphy_get_dev_by_name(priv->dev->name);

(5) phydev初始化/配置（重点）

cpsw_phy_init函数定义：

static int cpsw_phy_init(struct eth_device dev, struct cpsw_slave slave)

{

     struct cpsw_priv *priv = (struct cpsw_priv *)dev->priv;

     struct phy_device *phydev;

     u32 supported = PHY_GBIT_FEATURES;

printf("cpsw_phy_init \n");

printf("phy_addr:%d \n",slave->data->phy_addr);

     phydev = phy_connect(priv->bus,

                        slave->data->phy_addr,

                        dev,

                        slave->data->phy_if);

     if (!phydev)

               return -1;

     phydev->supported &= supported;

     phydev->advertising = phydev->supported;

     priv->phydev = phydev;

     phy_config(phydev);

     return 1;

}

该函数调用phy_connect函数连接网卡，返回的值如果合理就调用phy_config函数对该网卡进行配置，主要是配置网卡的速率和半双工，自动协商等，此部分需要再进一步调试熟悉。

首先分析phy_connect函数：

struct phy_device phy_connect(struct mii_dev bus, int addr,

               struct eth_device *dev, phy_interface_t interface)

#endif

{

     struct phy_device *phydev;

     phydev = phy_find_by_mask(bus, 1 << addr, interface);

     if (phydev)

               phy_connect_dev(phydev, dev);

     else

               printf("Could not get PHY for %s: addr %d\n", bus->name, addr);

     return phydev;

}

该函数首先调用phy_find_by_mask函数查询网卡设备，如果存在则调用phy_connect_dev函数连接，否则就打印出错信息

struct phy_device phy_find_by_mask(struct mii_dev bus, unsigned phy_mask,

               phy_interface_t interface)

{

     /* Reset the bus */

     if (bus->reset) {

               bus->reset(bus);

               /* Wait 15ms to make sure the PHY has come out of hard reset */

               udelay(15000);

     }

     return get_phy_device_by_mask(bus, phy_mask, interface);

}

该函数主要是调用get_phy_device_by_mask函数进行设备的查找，get_phy_device_by_mask函数的实现至关重要，包含了对于网卡的主要mdio通信。

static struct phy_device get_phy_device_by_mask(struct mii_dev bus,

               unsigned phy_mask, phy_interface_t interface)

{

     int i;

     struct phy_device *phydev;

     phydev = search_for_existing_phy(bus, phy_mask, interface);

     if (phydev)

               return phydev;

     /* Try Standard (ie Clause 22) access */

     /* Otherwise we have to try Clause 45 */

     for (i = 0; i < 5; i++) {

               phydev = create_phy_by_mask(bus, phy_mask,

                                 i ? i : MDIO_DEVAD_NONE, interface);

               if (IS_ERR(phydev))

                        return NULL;

               if (phydev)

                        return phydev;

     }

     printf("Phy %d not found\n", ffs(phy_mask) - 1);

     return phy_device_create(bus, ffs(phy_mask) - 1, 0xffffffff, interface);

}

该函数首先调用search_for_existing_phy函数查找当前存在的设备，如果存在则将该设备返回，不存在则调用create_phy_by_mask函数进行创建。重点看下create_phy_by_mask函数

static struct phy_device create_phy_by_mask(struct mii_dev bus,

               unsigned phy_mask, int devad, phy_interface_t interface)

{

     u32 phy_id = 0xffffffff;

     while (phy_mask) {

               int addr = ffs(phy_mask) - 1;

              int r = get_phy_id(bus, addr, devad, &phy_id);

               /* If the PHY ID is mostly f's, we didn't find anything */

               if (r == 0 && (phy_id & 0x1fffffff) != 0x1fffffff)

                        return phy_device_create(bus, addr, phy_id, interface);

               phy_mask &= ~(1 << addr);

     }

     return NULL;

}

该函数调用get_phy_id函数让处理器通过mdio总线查看网卡寄存器存储的ID，如果ID都是f，说明没有ID，就返回空，否则返回phy_device_create函数进行创建一个网卡设备。

get_phy_id函数实现：

int __weak get_phy_id(struct mii_dev bus, int addr, int devad, u32 phy_id)

{

     int phy_reg;

     /* Grab the bits from PHYIR1, and put them

      * in the upper half */

     phy_reg = bus->read(bus, addr, devad, MII_PHYSID1);

     if (phy_reg < 0)

               return -EIO;

     *phy_id = (phy_reg & 0xffff) << 16;

     /* Grab the bits from PHYIR2, and put them in the lower half */

     phy_reg = bus->read(bus, addr, devad, MII_PHYSID2);

     if (phy_reg < 0)

               return -EIO;

     *phy_id |= (phy_reg & 0xffff);

     return 0;

}

该函数就调用了bus->read总线读函数，来读取网卡寄存器的值，这里是读取寄存器存储的网卡ID，bus->read函数定义为cpsw_mdio_read

之后的phy_device_create函数为新创建一个phy_device及相关参数，以及相对应的phy_driver。

static struct phy_device phy_device_create(struct mii_dev bus, int addr,

                                               u32 phy_id,

                                               phy_interface_t interface)

{

     struct phy_device *dev;

     /* We allocate the device, and initialize the

      * default values */

     dev = malloc(sizeof(*dev));

     if (!dev) {

               printf("Failed to allocate PHY device for %s:%d\n",

                        bus->name, addr);

               return NULL;

     }

     memset(dev, 0, sizeof(*dev));

     dev->duplex = -1;

     dev->link = 0;

     dev->interface = interface;

     dev->autoneg = AUTONEG_ENABLE;

     dev->addr = addr;

     dev->phy_id = phy_id;

     dev->bus = bus;

     dev->drv = get_phy_driver(dev, interface);

     phy_probe(dev);

     bus->phymap[addr] = dev;

     return dev;

}

其中get_phy_driver会根据phy_id进行phy_driver的查找，若没有找到，则分配一个"Generic PHY"。

综上：cpsw_eth_probe的最终结果，是初始化了cpsw_priv各个部分，包括各个参数及mii_dev及phy_dev.

其中phy_dev非常重要，从后面的逻辑看出，phy_dev存在的情况下会根据LINK状态下的mac_control值对slave->sliver->mac_control寄存器进行配置。这决定了RMII接口的正确配置。

所以，必须有一个phy_dev？或者有一个mac_control值对slave->sliver->mac_control寄存器进行配置？

驱动的初始化及调用
eth_init->eth_get_ops(current)->start(current)来进行网口通信的底层配置

static int cpsw_eth_start(struct udevice *dev)

{

struct eth_pdata *pdata = dev_get_platdata(dev);

struct cpsw_priv *priv = dev_get_priv(dev);

   printf("cpsw_eth_start_now\n");

return _cpsw_init(priv, pdata->enetaddr);

}

static int _cpsw_init(struct cpsw_priv priv, u8 enetaddr)

{

     struct cpsw_slave   *slave;

     int i, ret;

     printf("_cpsw_init now\n");

     /* soft reset the controller and initialize priv */

     setbit_and_wait_for_clear32(&priv->regs->soft_reset);

     /* initialize and reset the address lookup engine */

     cpsw_ale_enable(priv, 1);

     cpsw_ale_clear(priv, 1);

     cpsw_ale_vlan_aware(priv, 0); /* vlan unaware mode */

     /* setup host port priority mapping */

     __raw_writel(0x76543210, &priv->host_port_regs->cpdma_tx_pri_map);

     __raw_writel(0, &priv->host_port_regs->cpdma_rx_chan_map);

     /* disable priority elevation and enable statistics on all ports */

     __raw_writel(0, &priv->regs->ptype);

     /* enable statistics collection only on the host port */

     __raw_writel(BIT(priv->host_port), &priv->regs->stat_port_en);

     __raw_writel(0x7, &priv->regs->stat_port_en);

     cpsw_ale_port_state(priv, priv->host_port, ALE_PORT_STATE_FORWARD);

     cpsw_ale_add_ucast(priv, enetaddr, priv->host_port, ALE_SECURE);

     cpsw_ale_add_mcast(priv, net_bcast_ethaddr, 1 << priv->host_port);

     for_active_slave(slave, priv)

     cpsw_slave_init(slave, priv);

     cpsw_update_link(priv);

     /* init descriptor pool */

     for (i = 0; i < NUM_DESCS; i++) {

               desc_write(&priv->descs[i], hw_next,

                           (i == (NUM_DESCS - 1)) ? 0 : &priv->descs[i+1]);

     }

     priv->desc_free = &priv->descs[0];

     /* initialize channels */

     if (priv->data.version == CPSW_CTRL_VERSION_2) {

               memset(&priv->rx_chan, 0, sizeof(struct cpdma_chan));

               priv->rx_chan.hdp       = priv->dma_regs + CPDMA_RXHDP_VER2;

               priv->rx_chan.cp        = priv->dma_regs + CPDMA_RXCP_VER2;

               priv->rx_chan.rxfree    = priv->dma_regs + CPDMA_RXFREE;

沈阳哪家医院治胃治 www.sdgc024.com

               memset(&priv->tx_chan, 0, sizeof(struct cpdma_chan));

               priv->tx_chan.hdp       = priv->dma_regs + CPDMA_TXHDP_VER2;

               priv->tx_chan.cp        = priv->dma_regs + CPDMA_TXCP_VER2;

     } else {

               memset(&priv->rx_chan, 0, sizeof(struct cpdma_chan));

               priv->rx_chan.hdp       = priv->dma_regs + CPDMA_RXHDP_VER1;

               priv->rx_chan.cp        = priv->dma_regs + CPDMA_RXCP_VER1;

               priv->rx_chan.rxfree    = priv->dma_regs + CPDMA_RXFREE;

               memset(&priv->tx_chan, 0, sizeof(struct cpdma_chan));

               priv->tx_chan.hdp       = priv->dma_regs + CPDMA_TXHDP_VER1;

               priv->tx_chan.cp        = priv->dma_regs + CPDMA_TXCP_VER1;

     }

     /* clear dma state */

     setbit_and_wait_for_clear32(priv->dma_regs + CPDMA_SOFTRESET);

     if (priv->data.version == CPSW_CTRL_VERSION_2) {

               for (i = 0; i < priv->data.channels; i++) {

                        __raw_writel(0, priv->dma_regs + CPDMA_RXHDP_VER2 + 4

                                           * i);

                        __raw_writel(0, priv->dma_regs + CPDMA_RXFREE + 4

                                           * i);

                        __raw_writel(0, priv->dma_regs + CPDMA_RXCP_VER2 + 4

                                           * i);

                        __raw_writel(0, priv->dma_regs + CPDMA_TXHDP_VER2 + 4

                                           * i);

                        __raw_writel(0, priv->dma_regs + CPDMA_TXCP_VER2 + 4

                                          * i);

               }

     } else {

               for (i = 0; i < priv->data.channels; i++) {

                        __raw_writel(0, priv->dma_regs + CPDMA_RXHDP_VER1 + 4

                                           * i);

                        __raw_writel(0, priv->dma_regs + CPDMA_RXFREE + 4

                                           * i);

                        __raw_writel(0, priv->dma_regs + CPDMA_RXCP_VER1 + 4

                                          * i);

                        __raw_writel(0, priv->dma_regs + CPDMA_TXHDP_VER1 + 4

                                           * i);

                        __raw_writel(0, priv->dma_regs + CPDMA_TXCP_VER1 + 4

                                           * i);

               }

     }

     __raw_writel(1, priv->dma_regs + CPDMA_TXCONTROL);

     __raw_writel(1, priv->dma_regs + CPDMA_RXCONTROL);

     /* submit rx descs */

     for (i = 0; i < PKTBUFSRX; i++) {

               ret = cpdma_submit(priv, &priv->rx_chan, net_rx_packets[i],

                                    PKTSIZE);

               if (ret < 0) {

                        printf("error %d submitting rx desc\n", ret);

                        break;

               }

     }

     return 0;

}

其中重点关注下cpsw_update_link(priv)-> cpsw_slave_update_link(slave, priv, &link),这个函数会根据根据现有的priv->phydev设备发起phy_startup（在LINK的状态下解析phydev->speed、phydev->duplex等状态），之后根据phy_startupde 的结果更新mac_control，最终通过此函数_raw_writel(mac_control, &slave->sliver->mac_control)将mac_control写入到相关cpsw_priv 的slave->sliver->mac_control寄存器。只有在link状态下正确配置了slave->sliver->mac_control寄存器,才能与phy正常进行通信。

以上配置好后，就可以在后续使用PING命令进行测试，PING命令使用之前，还需要配置好IP地址，可使用环境变量进行配置，如setenv ipaddr 192.168.1.30。