TI AM335X 網卡驅動決議-有解無憂

1.CPSW驅動及設備的初始化；

（1）首先驅動注冊cpsw_driver ，會自動進入cpsw_probe執行；

1 static struct platform_driver cpsw_driver = {
2     .driver = {
3         .name     = "cpsw",
4         .owner     = THIS_MODULE,
5         .pm     = &cpsw_pm_ops,
6     },
7     .probe = cpsw_probe,
8     .remove = __devexit_p(cpsw_remove),
9 };

（2）cpsw_probe初始化

進入cpsw_probe后，主要干活是：

創建 cpsw_priv *priv，入參pedv->dev.platform_data的引數，都賦值到priv里，后續主要使用的結構；
創建netdev結構，這個是網卡的默認資料結構，和上層協議堆疊通訊，注意注冊都是用的name，后續作為匹配的，name應該來自入參；
初始化priv_sl2（網卡2），呼叫cpsw_init_slave_emac（）函式，大部分是直接使用網卡1的priv資料直接復制過去；
cpsw_netdev_ops內open，xmit等函式賦值到netdev的ndev->netdev_ops，協議堆疊使用會最終呼叫這些函式；

資料結構關系：

platform_device *pdev ： .dev ，指向創建 netdev *ndev，在netdev結構體后面定義一個 cpsw_priv *priv，

.dev.platform_data ，改名重定義指向到data ，

data： DMA DMA中斷 ----> cpsw_priv *priv， 這個結構也是后面主要用的；

　　　 reg 暫存器資訊

ALE 模塊

MAC 配置

clk 時鐘

下面對cpsw_probe函式主要部分說明一下：

static int __devinit cpsw_probe(struct platform_device *pdev)

{
    struct cpsw_platform_data    *data = https://www.cnblogs.com/xiaoyudian/p/pdev->dev.platform_data;
    struct net_device        *ndev;
    struct cpsw_priv        *priv;

    priv = netdev_priv(ndev);                 //在netdev后面，定義一個prio，用來保存詳細的私有網卡資料；
    spin_lock_init(&priv->lock);
    priv->slaves = kzalloc(sizeof(struct cpsw_slave) * data->slaves,
                   GFP_KERNEL);
    for (i = 0; i < data->slaves; i++)
        priv->slaves[i].slave_num = i;

    priv->slaves[0].ndev = ndev;                  //每個phy網卡對應的netdev結構系結;
    priv->emac_port = 0;
    priv->regs = regs;                           //暫存器地址賦值過來;
    for_each_slave(priv, cpsw_slave_init, priv);
    priv->dma = cpdma_ctlr_create(&dma_params); //dma;
    priv->ale = cpsw_ale_create(&ale_params);    //ale;

    ndev->netdev_ops = &cpsw_netdev_ops;       //主要的網卡發送，open函式都在這里賦值過去，協議堆疊最終使用的韓；
    /* register the network device */
    SET_NETDEV_DEV(ndev, &pdev->dev);
　　ret = register_netdev(ndev);               //注冊netdev，給協議堆疊使用;

    ret = cpsw_init_slave_emac(pdev, priv);//  網卡2資料部分初始化;
}

2.phy的掃描，設備注冊，及讀寫函式初始化；

Davinci_mdio.c，這個檔案很多函式后面用到；
genphy_driver 內的genphy_config_init，genphy_read_status，genphy_config_aneg等，后面在connect時候，及運行狀態及都用的到；
當然，這些函式最底下，都是呼叫MDIO的讀寫函式介面；

（1）初始化MDIO

后面phy的讀寫都是呼叫這里賦值過來的函式，通過MDIO介面讀寫；
mdiobus_register(data->bus);這句進去后，會先復位MDIO，掃描發現的PHY設備，及其ADDR地址，創建PHY DEV設備，給后續connect函式匹配PHY設備；

static int __devinit davinci_mdio_probe(struct platform_device *pdev)
{
    data->bus->name        = dev_name(dev);
    data->bus->read        = davinci_mdio_read,   
    data->bus->write    = davinci_mdio_write,
    data->bus->reset    = davinci_mdio_reset,
    data->bus->parent    = dev;
    data->bus->priv        = data;

    /* register the mii bus */
    ret = mdiobus_register(data->bus);
    if (ret)
        goto bail_out;
return 0;

}

（2）注冊掃描phy設備，發現phy，注冊phy設備；

注意，這里會吧MDIO bus的ID（0）和phy的addr(0-31)，合起來，寫進phy dev的name，類似"0:13"；
具體操作是在phy_device_create函式，陳述句是 dev_set_name(&dev->dev, PHY_ID_FMT, bus->id, addr);
phy的創建，會設定速率，雙工，狀態機函式，name，ID等等；

int mdiobus_register(struct mii_bus *bus)
{
    dev_set_name(&bus->dev, "%s", bus->id);
    err = device_register(&bus->dev);
    if (bus->reset)
        bus->reset(bus);                   //呼叫上面的davinci_mdio_reset復位MDIO，使能CLK，enable等
                                           //復位函式中，讀取MDIO的alive暫存器，反映當前發現的PHY，取反賦值到phy_mask，下一句創建scan使用；
    for (i = 0; i < PHY_MAX_ADDR; i++) {  //對應MDIO，最多有0-31個地址的PHY，都掃描
        if ((bus->phy_mask & (1 << i)) == 0) {
            struct phy_device *phydev;
            phydev = mdiobus_scan(bus, i);//把發現的phy，通過MDIO介面讀取ID，判斷有效，即創建phy dev設備；
            }
        }
    }
}

3.phy的連接；

協議堆疊使用，會呼叫open函式，然后連接phy，配置phy的引數，啟動狀態機函式，配置自適應MAC的函式；
狀態機就是下一步運行起來用的，會自協商，掉線重連等；
自適應MAC函式，在phy_connect 入參，帶入，作為自協商速率后，配置CPU的MAC暫存器；
執行流程：netdev.netdev_ops.open -》 cpsw_ndo_open -》cpsw_slave_open -》phy_connect ，cpsw_set_phy_config

（1）cpsw_slave_open

主要是開啟中斷，配置mac地址，尋找用戶配置的phy，運行phy狀態機；

static void cpsw_slave_open(struct cpsw_slave *slave, struct cpsw_priv *priv)
{
    soft_reset(name, &slave->sliver->soft_reset);
    cpsw_set_slave_mac(slave, priv);//mac地址設一下

    slave->phy = phy_connect(priv->ndev, slave->data->phy_id,
                 &cpsw_adjust_link, 0, slave->data->phy_if)//匹配用戶配置的phy_name，在上一步MDIO創建的phy dev中尋找用戶的phy，同時帶入mac自適應函式
    if (IS_ERR(slave->phy)) {
        msg(err, ifup, "phy %s not found on slave %d\n",
            slave->data->phy_id, slave->slave_num);
        slave->phy = NULL;
    } else {
        dev_info(priv->dev, "CPSW phy found : id is : 0x%x\n",
            slave->phy->phy_id);
        cpsw_set_phy_config(priv, slave->phy);       //配置phy暫存器，速率等設定；
        phy_start(slave->phy);                      //狀態：READY -> UP
    }
}

（2）phy_connect

通過用戶配置的phy name欄位，到MDIO掃描到的phy dev串列尋找，找到后，回傳phy dev設備；
呼叫 phy_connect_direct 把mac自適應函式賦給phy dev，開啟phy dev創建時定義的狀態機函式phy_state_machine，中斷開啟；

struct phy_device * phy_connect(struct net_device *dev, const char *bus_id, void (*handler)(struct net_device *), u32 flags, phy_interface_t interface)
{
    /* Search the list of PHY devices on the mdio bus for the PHY with the requested name */
    d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);   //用戶配置的name，去匹配MDIO掃描創建的PHY的name，找到回傳phy dev；
    phydev = to_phy_device(d);

    rc = phy_connect_direct(dev, phydev, handler, flags, interface);//配置MAC自適應函式，開啟狀態機
    if (rc)
        return ERR_PTR(rc);

    return phydev;
}

（3）讀寫phy的暫存器，配置phy速率；

退出上述函式后，回傳外層，執行cpsw_set_phy_config，配置phy 的速率等；
phy_start，把phy狀態，ready，改為up；

4.phy運行

phy_state_machine：狀態機函式，up -> force / an -> run -> nolink -> changelink -> run；
genphy_driver： phy的配置函式，基本都在里，phy_devices.c檔案中；
實質：phy中斷/phy狀態機，run -》 changelink，狀態機呼叫phy狀態查詢link及自協商，MAC的暫存器隨之改變；

driver/net/phy/phy_devices.c   //檔案都是phy mdio 具體的驅動操作函式；

static struct phy_driver genphy_driver = {
.config_init    = genphy_config_init,     //讀取phy，查看支持的速率，雙工等，賦值到phydev->support;
.config_aneg    = genphy_config_aneg,     //重啟phy的自協商，或者強制設定phy的速率
.read_status    = genphy_read_status,     //更新link狀態，讀取phy的速率，配置到phy結構，后面進狀態機函式呼叫adjust自適應調整mac的速率；
};

driver/net/phy/phy.c      //主要是phy 狀態機函式，phy中斷，phy狀態列印函式；
void phy_state_machine(struct work_struct *work)
{
    if (phydev->adjust_state)
        phydev->adjust_state(phydev->attached_dev);  //根據phy dev的速率更新，自適應調整mac的速率配置；
    switch(phydev->state) {
        case PHY_DOWN:
        case PHY_STARTING:
        case PHY_READY:
        case PHY_PENDING:
            break;
        case PHY_UP:                            //剛才連接完畢后，狀態進入了 UP
            needs_aneg = 1;                     //設定該變數，最底下進 phy_start_aneg，調整phy進入 自協商或者強制 狀態；
break;
        case PHY_AN:
            err = phy_read_status(phydev);     //更新link，讀取phy狀態reg的速率等，更新到dev的speed等；
/* If the link is down, give up on negotiation for now */
            if (!phydev->link) {
                phydev->state = PHY_NOLINK;
                netif_carrier_off(phydev->attached_dev);  //告知內核子系統停止發包；
                phydev->adjust_link(phydev->attached_dev);//自適應調整MAC速率
                break;
            }

            /* Check if negotiation is done.  Break if there's an error */
            err = phy_aneg_done(phydev);
        /* If AN is done, we're running */
            if (err > 0) {
                phydev->state = PHY_RUNNING;
                netif_carrier_on(phydev->attached_dev);
                phydev->adjust_link(phydev->attached_dev);

            } else if (0 == phydev->link_timeout--) {
                int idx;

                needs_aneg = 1;
                /* If we have the magic_aneg bit,
                 * we try again */
                if (phydev->drv->flags & PHY_HAS_MAGICANEG)
                    break;

       /* The timer expired, and we still don't have a setting, so we try forcing it until we find one that works, starting from the fastest speed,and working our way down */
                idx = phy_find_valid(0, phydev->supported);
                phydev->speed = settings[idx].speed;
                phydev->duplex = settings[idx].duplex;
                phydev->autoneg = AUTONEG_DISABLE;
            }
            break;
        case PHY_NOLINK:
            err = phy_read_status(phydev);
if (phydev->link) {
                phydev->state = PHY_RUNNING;
                netif_carrier_on(phydev->attached_dev);
                phydev->adjust_link(phydev->attached_dev);
            }
            break;
        case PHY_FORCING:
            err = genphy_update_link(phydev);      //更新link狀態；
            if (phydev->link) {
                phydev->state = PHY_RUNNING;        //進入run狀態；
                netif_carrier_on(phydev->attached_dev);  //通知內核子系統，開啟發包；
            } else {
                if (0 == phydev->link_timeout--) {
                    phy_force_reduction(phydev);
                    needs_aneg = 1;
                }
            }
            phydev->adjust_link(phydev->attached_dev);   //調整MAC REG 速率;
            break;
        case PHY_RUNNING:
            /* Only register a CHANGE if we are polling */
            if (PHY_POLL == phydev->irq)
                phydev->state = PHY_CHANGELINK;            //phy產生中斷，會進changlink狀態，重新調整速率
            break;
        case PHY_CHANGELINK:
            err = phy_read_status(phydev);                 //更新link，讀取phy速率，
if (phydev->link) {
                phydev->state = PHY_RUNNING;               //進入run狀態；
                netif_carrier_on(phydev->attached_dev);     //告知內核子系統，協議堆疊，開啟發包；
            } else {
                phydev->state = PHY_NOLINK;                  //進入nolink狀態；
                netif_carrier_off(phydev->attached_dev);     //停止發包；
            }
            phydev->adjust_link(phydev->attached_dev);       //調整MAC速率暫存器配置；
            if (PHY_POLL != phydev->irq)
                err = phy_config_interrupt(phydev,PHY_INTERRUPT_ENABLED);
            break;
        case PHY_HALTED:
            if (phydev->link) {
                phydev->link = 0;
                netif_carrier_off(phydev->attached_dev);
                phydev->adjust_link(phydev->attached_dev);
            }
            break;
        case PHY_RESUMING:
            err = phy_clear_interrupt(phydev);
            err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);if (AUTONEG_ENABLE == phydev->autoneg) 
            {
                err = phy_aneg_done(phydev);
                if (err > 0) {
                    err = phy_read_status(phydev);if (phydev->link) {
                       .....
                }
            } ....break;
    }
if (needs_aneg)
        err = phy_start_aneg(phydev);           //自協商，進入an / force 狀態；

    schedule_delayed_work(&phydev->state_queue, PHY_STATE_TIME * HZ);   //狀態機繼續定時調度；
}

5.phy_id的匹配

例如：phy_id = "0:19" 的匹配；

這個東西，別看少，貫穿了整個代碼，得全域通讀帶起來才能看透；

注意：

　addr 對應的 phy的物理管腳連接，addr，范圍是0-31；

phy id 對應phy暫存器 PHYIDR1 PHYIDR2，類似0x20359081
phy_id實際是phy dev的name欄位，字串形式，類似“0:19”，0是MDIO的總線ID，19是0x19，是addr；
得注意區分這三個，容易混淆；

(1) "0"

devices.c
am33xx_cpsw_init - 》 pdev = omap_device_build("davinci_mdio", 0,...);   //入參0配置MDIO設備pdv_id 為0；

(2) "0" "19" -> "0:19"

這里注冊在MDIO總線上的phy_id的值：

Davinci_mdio.c
davinci_mdio_probe - 》 snprintf(data->bus->id, MII_BUS_ID_SIZE, "%x", pdev->id);配置進 bus.id ，就是0；

- 》 mdiobus_register - 》 mdiobus_scan - 》get_phy_device - 》 phy_device_create dev_set_name(&dev->dev, PHY_ID_FMT, bus->id, addr);
這里， bus->id為0, addr為19，id和addr合起來，即可得出，“0:19”
addr為掃描到的phy對應的地址，alive暫存器能看出來，具體值和實際的phy物理連接配置有關（phy手冊有說明）；

至此，軟體掃描到的phy已經完成了phy_id的值，即phy的name欄位；
接下來就等著用戶配置的phy_id來匹配了，

(3)用戶初始化配置，phy_id；

cpsw.c
入參bus.id ：cpsw_probe - 》 cpsw_slave_init - 》 am33xx_cpsw_slaves[0].phy_id用戶初始化配的值，
在這里，id給prio.slaves

static struct cpsw_slave_data am33xx_cpsw_slaves[] = {
{
.slave_reg_ofs = 0x200,
.sliver_reg_ofs = 0xd80,
.phy_id = "0:19",
.dual_emac_reserved_vlan = CPSW_PORT_VLAN_SLAVE_0,
},

{
.slave_reg_ofs = 0x300,
.sliver_reg_ofs = 0xdc0,
.phy_id = "0:01",
.dual_emac_reserved_vlan = CPSW_PORT_VLAN_SLAVE_1,
},
};

(4).與總線上的id進行匹配名字

cpsw.c
cpsw_ndo_open - 》 cpsw_slave_open - 》 phy_connect - 》 bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
這里bus.id是入參帶入的，匹配&mdio_bus_type的bus->id，即上一步的“0:19”

6.協議堆疊分層結構；

（1）發送函式：

dev.c dev.c cpsw.c

dev_queue_xmit dev_hard_start_xmit cpsw_ndo_start_xmit

(cpsw_netdev_ops)
網路協議介面層設備驅動功能層網路物理設備

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/17583.html

標籤：其他

上一篇：滑塊驗證碼（騰訊）——基于selenium，pillow實作

下一篇：Javashop電商系統7.2發布