基于335X的UBOOT网口驱动分析
基于335X的UBOOT網(wǎng)口驅(qū)動分析
一、軟硬件平臺資料
1、 開發(fā)板：創(chuàng)龍AM3359核心板，網(wǎng)口采用RMII形式
2、 UBOOT版本：U-Boot-2016.05，采用FDT和DM。
參考鏈接：
https://blog.csdn.net/hahachenchen789/article/details/53339181
二、網(wǎng)口相關(guān)代碼位置
1、 網(wǎng)口的PINMUX設(shè)置
RMII接口的相關(guān)PINMUX在MLO中進行設(shè)置，具體的設(shè)置代碼為
|-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、 網(wǎng)口的初始化設(shè)置
網(wǎng)口的初始化在UBOOT中進行，具體設(shè)置代碼為
|-board_init_r
|-init_sequence_r
|-initr_net
|- eth_initialize （eth-uclass.c）
三、有關(guān)網(wǎng)口的DM&FDT分析
1、 驅(qū)動實現(xiàn)方式
此版本的UBOOT中使用了FDT文件進行外設(shè)的相關(guān)配置，驅(qū)動模型使用了DM方式，有關(guān)FDT以及DM相關(guān)的知識請參考如下文章
https://blog.csdn.net/ooonebook/article/details/53206623
https://blog.csdn.net/ooonebook/article/details/53234020
2、 UBOOT中DM初始化
DM的初始化
.創(chuàng)建根設(shè)備root的udevice，存放在gd->dm_root中。
.根設(shè)備其實是一個虛擬設(shè)備，主要是為uboot的其他設(shè)備提供一個掛載點。
.初始化uclass鏈表gd->uclass_root
DM中udevice和uclass的解析
.udevice的創(chuàng)建和uclass的創(chuàng)建
.udevice和uclass的綁定
.uclass_driver和uclass的綁定
.driver和udevice的綁定
.部分driver函數(shù)的調(diào)用
（1）DM初始化調(diào)用過程
dm初始化的接口在dm_init_and_scan中。
可以發(fā)現(xiàn)在uboot relocate之前的initf_dm和之后的initr_dm都調(diào)用了這個函數(shù)。
static int initf_dm(void)
{
#if defined(CONFIG_DM) &&
defined(CONFIG_SYS_MALLOC_F_LEN)
int ret;
ret = dm_init_and_scan(true); // 調(diào)用dm_init_and_scan對DM進行初始化和設(shè)備的解析
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之前的根設(shè)備
gd->dm_root = NULL;
ret = dm_init_and_scan(false); // 調(diào)用dm_init_and_scan對DM進行初始化和設(shè)備的解析
if (ret)
return ret;
return 0;
}
#endif
主要區(qū)別在于參數(shù)。
首先說明一下dts節(jié)點中的“u-boot,dm-pre-reloc”屬性，當(dāng)設(shè)置了這個屬性時，則表示這個設(shè)備在relocate之前就需要使用。
當(dāng)dm_init_and_scan的參數(shù)為true時，只會對帶有“u-boot,dm-pre-reloc”屬性的節(jié)點進行解析。而當(dāng)參數(shù)為false的時候，則會對所有節(jié)點都進行解析。
由于“u-boot,dm-pre-reloc”的情況比較少，所以這里只學(xué)習(xí)參數(shù)為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); // 從平臺設(shè)備中解析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) // 宏定義根設(shè)備指針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) {
// 根設(shè)備已經(jīng)存在，說明DM已經(jīng)初始化過了
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是指根設(shè)備udevice，root_info是表示根設(shè)備的設(shè)備信息
// device_bind_by_name會查找和設(shè)備信息匹配的driver，然后創(chuàng)建對應(yīng)的udevice和uclass并進行綁定，最后放在DM_ROOT_NON_CONST中。
// device_bind_by_name后續(xù)我們會進行說明，這里我們暫時只需要了解root根設(shè)備的udevice以及對應(yīng)的uclass都已經(jīng)創(chuàng)建完成。
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);
// 對根設(shè)備執(zhí)行probe操作，
// device_probe后續(xù)再進行說明
if (ret)
return ret;
return 0;
}
這里就完成的DM的初始化了
1）創(chuàng)建根設(shè)備root的udevice，存放在gd->dm_root中。
2）初始化uclass鏈表gd->uclass_root
（2）從平臺設(shè)備中解析udevice和uclass—dm_scan_platdata（不涉及）
（3）從dtb中解析udevice和uclass——dm_scan_fdt
對應(yīng)代碼如下driver/core/root.c
int dm_scan_fdt(const void *blob, bool
pre_reloc_only)
// 此時傳進來的參數(shù)blob=gd->fdt_blob，
pre_reloc_only=0
{
return dm_scan_fdt_node(gd->dm_root, blob, 0, pre_reloc_only);
// 直接調(diào)用dm_scan_fdt_node
}
int dm_scan_fdt_node(struct udevice
*parent, const void *blob, int offset,
bool pre_reloc_only)
// 此時傳進來的參數(shù)
// parent=gd->dm_root，表示以root設(shè)備作為父設(shè)備開始解析
// blob=gd->fdt_blob，指定了對應(yīng)的dtb
// offset=0，從偏移0的節(jié)點開始掃描
// pre_reloc_only=0，不只是解析relotion之前的設(shè)備
{
int ret = 0, err;
/* 以下步驟相當(dāng)于是遍歷每一個dts節(jié)點并且調(diào)用lists_bind_fdt對其進行解析 */
for (offset = fdt_first_subnode(blob, offset);
// 獲得blob設(shè)備樹的offset偏移下的節(jié)點的第一個子節(jié)點
offset > 0;
offset = fdt_next_subnode(blob, offset)) {
// 循環(huán)查找下一個子節(jié)點
if (!fdtdec_get_is_enabled(blob, offset)) {
// 判斷節(jié)點狀態(tài)是否是disable，如果是的話直接忽略
dm_dbg(" - ignoring
disabled device
");
continue;
}
err = lists_bind_fdt(parent, blob, offset, NULL);
// 解析綁定這個節(jié)點，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的核心。
其具體實現(xiàn)如下：
driver/core/lists.c
int lists_bind_fdt(struct udevice *parent,
const void *blob, int offset,
struct udevice **devp)
// parent指定了父設(shè)備，通過blob和offset可以獲得對應(yīng)的設(shè)備的dts節(jié)點，對應(yīng)udevice結(jié)構(gòu)通過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));
// 打印當(dāng)前解析的節(jié)點的名稱
if (devp)
*devp = NULL;
for (entry = driver; entry != driver + n_ents; entry++) {
// 遍歷driver table中的所有driver，具體參考三、4一節(jié)
ret = driver_check_compatible(blob, offset, entry->of_match,
&id);
// 判斷driver中的compatibile字段和dts節(jié)點是否匹配
name = fdt_get_name(blob, offset, NULL);
// 獲取節(jié)點名稱
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);
// 找到對應(yīng)的driver，調(diào)用device_bind進行綁定，會在這個函數(shù)中創(chuàng)建對應(yīng)udevice和uclass并切進行綁定，后面繼續(xù)說明
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設(shè)置到devp指向的地方中，進行返回
}
break;
}
if
(!found && !result && ret != -ENODEV) {
dm_dbg("No match for node '%s'
",
fdt_get_name(blob, offset,
NULL));
}
return result;
}
在device_bind中實現(xiàn)了udevice和uclass的創(chuàng)建和綁定以及一些初始化操作，這里專門學(xué)習(xí)一下device_bind。
device_bind的實現(xiàn)如下(去除部分代碼)
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:父設(shè)備
// drv：設(shè)備對應(yīng)的driver
// name：設(shè)備名稱
// platdata：設(shè)備的平臺數(shù)據(jù)指針
// of_offset：在dtb中的偏移，即代表了其dts節(jié)點
// devp：所創(chuàng)建的udevice的指針，用于返回
{
struct udevice *dev;
struct uclass *uc;
int size, ret = 0;
ret = uclass_get(drv->id, &uc);
// 獲取driver id對應(yīng)的uclass，如果uclass原先并不存在，那么會在這里創(chuàng)建uclass并其uclass_driver進行綁定
dev = calloc(1, sizeof(struct udevice));
// 分配一個udevice
dev->platdata = platdata; // 設(shè)置udevice的平臺數(shù)據(jù)指針
dev->name = name; // 設(shè)置udevice的name
dev->of_offset = of_offset; // 設(shè)置udevice的dts節(jié)點偏移
dev->parent = parent; // 設(shè)置udevice的父設(shè)備
dev->driver = drv; // 設(shè)置udevice的對應(yīng)的driver，相當(dāng)于driver和udevice的綁定
dev->uclass = uc; // 設(shè)置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);
}
// 設(shè)置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分配平臺數(shù)據(jù)的空間，由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使用的平臺數(shù)據(jù)的空間，由所屬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);
// 添加到父設(shè)備的子設(shè)備鏈表中
ret = uclass_bind_device(dev);
// uclass和udevice進行綁定，主要是實現(xiàn)了將udevice鏈接到uclass的設(shè)備鏈表中
/* if we fail to bind we remove device from successors and free it */
if (drv->bind) {
ret = drv->bind(dev);
// 執(zhí)行udevice對應(yīng)driver的bind函數(shù)
}
if (parent && parent->driver->child_post_bind) {
ret = parent->driver->child_post_bind(dev);
// 執(zhí)行父設(shè)備的driver的child_post_bind函數(shù)
}
if (uc->uc_drv->post_bind) {
ret = uc->uc_drv->post_bind(dev);
if (ret)
goto fail_uclass_post_bind;
// 執(zhí)行所屬uclass的post_bind函數(shù)
}
if (devp)
*devp = dev;
// 將udevice進行返回
dev->flags |= DM_FLAG_BOUND;
// 設(shè)置已經(jīng)綁定的標(biāo)志
// 后續(xù)可以通過dev->flags & DM_FLAG_ACTIVATED或者device_active宏來判斷設(shè)備是否已經(jīng)被激活
return 0;
在init_sequence_r中的initr_dm中，完成了FDT的解析，解析了所有的外設(shè)node,并針對各個節(jié)點進行了 udevice和uclass的創(chuàng)建，以及各個組成部分的綁定關(guān)系。
注意，這里只是綁定，即調(diào)用了driver的bind函數(shù)，但是設(shè)備還沒有真正激活，也就是還沒有執(zhí)行設(shè)備的probe函數(shù)。
將在網(wǎng)口初始化階段進行相關(guān)driver的bind操作。
四、網(wǎng)口的初始化過程分析
1、 eth_initialize函數(shù)
網(wǎng)口初始化，其中最主要的工作是調(diào)用uclass_first_device(UCLASS_ETH,
&dev)函數(shù)，從uclass的設(shè)備鏈表中獲取第一個udevice，并且進行probe。最終，是通過調(diào)用device_probe(dev)進行網(wǎng)口設(shè)備的激活和驅(qū)動的注冊。下面分析device_probe(dev)的實現(xiàn)的部分過程。
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;
// 表示這個設(shè)備已經(jīng)被激活了
drv = dev->driver;
assert(drv);
// 獲取這個設(shè)備對應(yīng)的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);
// 為設(shè)備分配私有數(shù)據(jù)
}
/* 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);
// 為設(shè)備所屬uclass分配私有數(shù)據(jù)
}
// 這里過濾父設(shè)備的probe
seq = uclass_resolve_seq(dev);
if (seq < 0) {
ret = seq;
goto fail;
}
dev->seq = seq;
dev->flags |= DM_FLAG_ACTIVATED;
// 設(shè)置udevice的激活標(biāo)志
ret = uclass_pre_probe_device(dev);
// uclass在probe device之前的一些函數(shù)的調(diào)用
if (drv->ofdata_to_platdata && dev->of_offset >= 0) {
ret =
drv->ofdata_to_platdata(dev);
// 調(diào)用driver中的ofdata_to_platdata將dts信息轉(zhuǎn)化為設(shè)備的平臺數(shù)據(jù)
}
if (drv->probe) {
ret = drv->probe(dev);
// 調(diào)用driver的probe函數(shù)，到這里設(shè)備才真正激活了
}
ret = uclass_post_probe_device(dev);
return ret;
}
主要工作歸納如下：
.分配設(shè)備的私有數(shù)據(jù)
.對父設(shè)備進行probe
.執(zhí)行probe device之前uclass需要調(diào)用的一些函數(shù)
.調(diào)用driver的ofdata_to_platdata，將dts信息轉(zhuǎn)化為設(shè)備的平臺數(shù)據(jù)（重要）
.調(diào)用driver的probe函數(shù)（重要）
.執(zhí)行probe device之后uclass需要調(diào)用的一些函數(shù)
在CPSW.c中有相關(guān)定義：
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、有關(guān)DTS配置信息轉(zhuǎn)化的函數(shù)（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函數(shù)中將各種與CPSW有關(guān)的平臺數(shù)據(jù)宏定義以及DTS中的配置信息（包含個子節(jié)點）轉(zhuǎn)化為了平臺數(shù)據(jù)存儲在了priv->data的相關(guān)部分中。主要涉及priv->data的相關(guān)設(shè)置，此部分重要的信息是MAC的接口形式，比如RMII的設(shè)置，RMII時鐘的使能，phy_addr的設(shè)置。
3、有關(guān)驅(qū)動注冊的函數(shù)（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對于網(wǎng)卡設(shè)備的通用管理是CPSW方式，通過cpsw_priv結(jié)構(gòu)體來進行相關(guān)的管理，cpsw_priv結(jié)構(gòu)體中包含有CPSW平臺數(shù)據(jù)、cpsw_slave的信息、priv->bus（MII接口管理）、phy_device設(shè)備的配置及管理等。
cpsw_register(priv)函數(shù)主要進行以下工作
（1）、首先是聲明幾個結(jié)構(gòu)體變量，其中包括cpsw的主：cpsw_priv和從：cpsw_slave，然后是設(shè)置cpsw的基礎(chǔ)寄存器的地址cpsw_base，然后調(diào)用calloc函數(shù)為這些結(jié)構(gòu)體分配空間。
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結(jié)構(gòu)體中的成員進行初始化，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循環(huán)的意義在于可能有多個網(wǎng)卡，am335支持雙網(wǎng)卡。
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設(shè)備的創(chuàng)建
.進行了mdio_regs寄存器的配置（set
enable and clock divider）
.進行了cpsw_mdio_read/
cpsw_mdio_write的定義（用此函數(shù)對PHY進行讀寫）
.mii_dev設(shè)備注冊（加到mii_devs鏈表，并指定為current_mii）
(4)指定priv->bus為上一步創(chuàng)建的設(shè)備
priv->bus = miiphy_get_dev_by_name(priv->dev->name);
(5) phydev初始化/配置（重點）
cpsw_phy_init函數(shù)定義：
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;
}
該函數(shù)調(diào)用phy_connect函數(shù)連接網(wǎng)卡，返回的值如果合理就調(diào)用phy_config函數(shù)對該網(wǎng)卡進行配置，主要是配置網(wǎng)卡的速率和半雙工，自動協(xié)商等，此部分需要再進一步調(diào)試熟悉。
首先分析phy_connect函數(shù)：
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;
}
該函數(shù)首先調(diào)用phy_find_by_mask函數(shù)查詢網(wǎng)卡設(shè)備，如果存在則調(diào)用phy_connect_dev函數(shù)連接，否則就打印出錯信息
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);
}
該函數(shù)主要是調(diào)用get_phy_device_by_mask函數(shù)進行設(shè)備的查找，get_phy_device_by_mask函數(shù)的實現(xiàn)至關(guān)重要，包含了對于網(wǎng)卡的主要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);
}
該函數(shù)首先調(diào)用search_for_existing_phy函數(shù)查找當(dāng)前存在的設(shè)備，如果存在則將該設(shè)備返回，不存在則調(diào)用create_phy_by_mask函數(shù)進行創(chuàng)建。重點看下create_phy_by_mask函數(shù)
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;
}
該函數(shù)調(diào)用get_phy_id函數(shù)讓處理器通過mdio總線查看網(wǎng)卡寄存器存儲的ID，如果ID都是f，說明沒有ID，就返回空，否則返回phy_device_create函數(shù)進行創(chuàng)建一個網(wǎng)卡設(shè)備。
get_phy_id函數(shù)實現(xiàn)：
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;
}
該函數(shù)就調(diào)用了bus->read總線讀函數(shù)，來讀取網(wǎng)卡寄存器的值，這里是讀取寄存器存儲的網(wǎng)卡ID，bus->read函數(shù)定義為cpsw_mdio_read
之后的phy_device_create函數(shù)為新創(chuàng)建一個phy_device及相關(guān)參數(shù)，以及相對應(yīng)的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;
}
其中g(shù)et_phy_driver會根據(jù)phy_id進行phy_driver的查找，若沒有找到，則分配一個"Generic PHY"。
綜上：cpsw_eth_probe的最終結(jié)果，是初始化了cpsw_priv各個部分，包括各個參數(shù)及mii_dev及phy_dev.
其中phy_dev非常重要，從后面的邏輯看出，phy_dev存在的情況下會根據(jù)LINK狀態(tài)下的mac_control值對slave->sliver->mac_control寄存器進行配置。這決定了RMII接口的正確配置。
所以，必須有一個phy_dev？或者有一個mac_control值對slave->sliver->mac_control寄存器進行配置？
驅(qū)動的初始化及調(diào)用
eth_init->eth_get_ops(current)->start(current)來進行網(wǎng)口通信的底層配置
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;
}
其中重點關(guān)注下cpsw_update_link(priv)->
cpsw_slave_update_link(slave, priv, &link),這個函數(shù)會根據(jù)根據(jù)現(xiàn)有的priv->phydev設(shè)備發(fā)起phy_startup（在LINK的狀態(tài)下解析phydev->speed、phydev->duplex等狀態(tài)），之后根據(jù)phy_startupde
的結(jié)果更新mac_control，最終通過此函數(shù)_raw_writel(mac_control, &slave->sliver->mac_control)將mac_control寫入到相關(guān)cpsw_priv
的slave->sliver->mac_control寄存器。只有在link狀態(tài)下正確配置了slave->sliver->mac_control寄存器,才能與phy正常進行通信。
以上配置好后，就可以在后續(xù)使用PING命令進行測試，PING命令使用之前，還需要配置好IP地址，可使用環(huán)境變量進行配置，如setenv ipaddr 192.168.1.30。
總結(jié)
以上是生活随笔為你收集整理的基于335X的UBOOT网口驱动分析的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 设计模式之合成/聚合利用原则（CARP）
- 下一篇： 情侣礼物（情侣必收藏）