TI AM335X 网卡驱动解析

1.CPSW驱动及设备的初始化；

（1）首先驱动注册cpsw_driver ，会自动进入cpsw_probe执行；

static struct platform_driver cpsw_driver = {
    .driver = {
        .name     = "cpsw",
        .owner     = THIS_MODULE,
        .pm     = &cpsw_pm_ops,
    },
    .probe = cpsw_probe,
    .remove = __devexit_p(cpsw_remove),
};

（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 = 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
",
            slave->data->phy_id, slave->slave_num);
        slave->phy = NULL;
    } else {
        dev_info(priv->dev, "CPSW phy found : id is : 0x%x
",
            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)
网络协议接口层             设备驱动功能层                     网络物理设备