基于335X的UBOOT网口驱动分析
基于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、DTS文件中的CPSW的配置
&cpsw_emac0 {
phy_id = <&davinci_mdio>, <0x12>; //phy_id【1】為初始的phy_addr,為SW的PORT2口的ADDR。
phy-mode = "rmii"; //RMII 模式
};
&mac { //未使用此處配置
slaves = <1>;
pinctrl-names = "default", "sleep";
pinctrl-0 = <&cpsw_default>;
pinctrl-1 = <&cpsw_sleep>;
status = "okay";
};
&phy_sel {
rmii-clock-ext; //RMII模式的時鐘為外部時鐘
};
&davinci_mdio { //未使用此處配置
pinctrl-names = "default", "sleep";
pinctrl-0 = <&davinci_mdio_default>;
pinctrl-1 = <&davinci_mdio_sleep>;
status = "okay";
reset-gpios = <&gpio2 5 GPIO_ACTIVE_LOW>;
reset-delay-us = <2>; /* PHY datasheet states 1uS min */
};
3、 網口的初始化設置
網口的初始化在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
", ret);
return ret;
}
ret = dm_scan_platdata(pre_reloc_only); // 從平臺設備中解析udevice和uclass
if (ret) {
debug("dm_scan_platdata() failed: %d
", 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
", 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!
");
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
");
continue;
}
err = lists_bind_fdt(parent, blob, offset, NULL);
// 解析綁定這個節點，dm_scan_fdt的核心，下面具體分析
if (err && !ret) {
ret = err;
debug("%s: ret=%d
", 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
", 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
", name);
break;
} else if (ret) {
dm_warn("Device tree error at offset %d
", offset);
result = ret;
break;
}
dm_dbg(" - found match at
'%s'
", 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
", 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'
",
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
");
return
-ENOENT;
}
priv->data.slaves
= fdtdec_get_int(fdt, node, "slaves", -1);
if
(priv->data.slaves <= 0) {
printf("error:
slaves not found in dt
");
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
");
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
");
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
");
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
");
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
");
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
");
}
phy_sel_compat
= fdt_getprop(fdt, subnode, "compatible",
NULL);
if
(!phy_sel_compat) {
printf("Not
able to get gmii_sel compatible
");
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
");
return
ret;
}
pdata->phy_interface
= priv->data.slave_data[active_slave].phy_if;
if
(pdata->phy_interface == -1) {
debug("%s:
Invalid PHY interface '%s'
", __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
");
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
");
printf("phy_addr:%d
",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
", 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
", 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
",
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
");
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
");
/*
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;
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
", 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。
總結
以上是生活随笔為你收集整理的基于335X的UBOOT网口驱动分析的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 设计模式之合成/聚合利用原则（CARP）
- 下一篇： 情侣礼物（情侣必收藏）