Linux网卡驱动移植--Dm9000网卡驱动分析

1. Linux网络体系结构由以下5部分组成

① 系统调用接口： 位于Linux网络子系统的顶部，为应用程序提供访问内核网络子系统的方法，主要指socket系统调用。

② 协议无关接口： 实现一组基于socket的通用函数来访问不同的协议。（Linux中的socket使用sock结构来描述（定义于include/net/sock.h），该结构包含特定socket所需要的所有状态信息，还包含socket所使用的特定协议和在socket上可以执行的一些操作。）

③ 网络协议： 用于实现具体的网络协议，如TCP、UDP等

④ 设备无关接口： 将协议与各种网络设备驱动连接在一起

⑤ 设备驱动：负责管理物理网络设备

 注：与字符设备与块设备不同，网络接口设备在Linux的/dev目录下不存在与之对应的设备文件，因此无法向字符设备或块设备那样通过访问设备文件来操作。Linux通过一些系统提供的工具来访问和设置网络设备，如ifconfig、mii-tool、ethtool等。

2. 每个网络设备都由一个net_device结构来描述，该结构位于include/linux/netdevice.h中定义

struct net_device
{
    char            name[IFNAMSIZ];/*
    unsigned long        base_addr;    /* device I/O address    */
    unsigned int        irq;        /* device IRQ number    */
　
　　unsigned long        state;

　　unsigned mtu; /* interface MTU value */

　　unsigned char        dev_addr[MAX_ADDR_LEN];    /* hw address, (before bcast 

    /* Management operations */
    const struct net_device_ops *netdev_ops;
    const struct ethtool_ops *ethtool_ops;

    /* Hardware header description */
    const struct header_ops *header_ops;

　　...
}

① name： 设备名称

② state： 设备状态

③ base_addr：网络接口的I/O基地址，由驱动在设备探测时赋值

④ irq：中断号

⑤ mtu：网卡设备可以处理的最大传输单元

⑥ dev_addr：设备的6字节MAC地址

⑦ netdev_ops：网络接口设备的操作接口函数集

3. 分配及注册网络设备

① 分配一个net_device结构可以使用宏：alloc_netdev

#define alloc_netdev(sizeof_priv, name, setup) \
    alloc_netdev_mq(sizeof_priv, name, setup, 1)

② 对于不同类型的网络设备，内核提供了更直接的分配函数。如以太网网卡分配函数：alloc_etherdev

#define alloc_etherdev(sizeof_priv) alloc_etherdev_mq(sizeof_priv, 1)

（1）alloc_etherdev_mq()函数只是对alloc_netdev_mq()函数的简单封装

struct net_device *alloc_etherdev_mq(int sizeof_priv, unsigned int queue_count)
{
    return alloc_netdev_mq(sizeof_priv, "eth%d", ether_setup, queue_count);
}

（2）ether_setup()是以太网设备专属初始化函数

void ether_setup(struct net_device *dev)
{
    dev->header_ops        = &eth_header_ops;
#ifdef CONFIG_COMPAT_NET_DEV_OPS
    dev->change_mtu        = eth_change_mtu;
    dev->set_mac_address     = eth_mac_addr;
    dev->validate_addr    = eth_validate_addr;
#endif
    dev->type        = ARPHRD_ETHER;
    dev->hard_header_len     = ETH_HLEN;
    dev->mtu        = ETH_DATA_LEN;
    dev->addr_len        = ETH_ALEN;
    dev->tx_queue_len    = 1000;    /* Ethernet wants good queues */
    dev->flags        = IFF_BROADCAST|IFF_MULTICAST;

    memset(dev->broadcast, 0xFF, ETH_ALEN);

}

③ 注册网络设备：register_netdev

4. sk_buff称为“套接字缓冲区”，用于在网络子系统各层之间传递数据。

struct sk_buff {
    /* These two members must be first. */
    struct sk_buff        *next;
    struct sk_buff        *prev;

    struct sock        *sk;
    struct net_device    *dev;

    __be16            protocol;

    void            (*destructor)(struct sk_buff *skb);

    sk_buff_data_t        transport_header;
    sk_buff_data_t        network_header;
    sk_buff_data_t        mac_header;
    /* These elements must be at the end, see alloc_skb() for details.  */
    sk_buff_data_t        tail;
    sk_buff_data_t        end;
    unsigned char        *head,
                *data;
    unsigned int        truesize;
    atomic_t        users;
};

① sk_buff定义了4个指向数据包缓冲区不同位置的指针head、data、tail、end。

（1） head与end分别指向数据包缓冲区的起始地址和结束地址，它们是在sk_buff和相关数据块分配后就固定下来

（2） data与tail分别指向当前协议层有效数据的起始地址和结束地址，因此随着sk_buff表示的数据包在不同协议层次间的传递，data与tail指针也会做相应的移动。

② 网卡接收到数据包，或者用户空间请求发送网络数据，skb都会被创建。内核中分配一个sk_buff使用函数：alloc_skb()

static inline struct sk_buff *alloc_skb(unsigned int size, gfp_t priority)

③ 在网卡驱动中，通常使用dev_alloc_skb()函数来分配一个skb。dev_alloc_skb()是对__dev_alloc_skb() 的简单封装，而__dev_alloc_skb()调用alloc_skb()以GFP_ATOMIC方式从内存分配skb，因此它可以用在中断上下文中。

struct sk_buff *dev_alloc_skb(unsigned int length)
{
    return __dev_alloc_skb(length, GFP_ATOMIC);
}

static inline struct sk_buff *__dev_alloc_skb(unsigned int length， gfp_t gfp_mask)
{
    struct sk_buff *skb = alloc_skb(length + NET_SKB_PAD, gfp_mask);
    if (likely(skb))
        skb_reserve(skb, NET_SKB_PAD);
    return skb;
}

注：GFP_ATOMIC，用来从中断处理和进程上下文之外的其他代码中分配内存，从不睡眠。

④ sk_buff的4个指针的基本操作函数

（1）skb_headroom： 获取sk_buff结构成员指针head到data之间空间的长度

static inline unsigned int skb_headroom(const struct sk_buff *skb)
{
    return skb->data - skb->head;
}

（2）skb_tailroom： 获取sk_buff结构成员指针tail到end之间空间的长度

static inline int skb_tailroom(const struct sk_buff *skb)
{
    return skb_is_nonlinear(skb) ? 0 : skb->end - skb->tail;
}

（3）skb_reserve： 将data和tail指针同时下移

static inline void skb_reserve(struct sk_buff *skb, int len)
{
    skb->data += len;
    skb->tail += len;
}

（4）skb_push： 将data指针上移，同时增加sk_buff中的len

unsigned char *skb_push(struct sk_buff *skb, unsigned int len)
{
    skb->data -= len;
    skb->len  += len;
    if (unlikely(skb->data<skb->head))
        skb_under_panic(skb, len, __builtin_return_address(0));
    return skb->data;
}

（5）skb_pull： 将data指针下移，同时减少sk_buff中的len

unsigned char *skb_pull(struct sk_buff *skb, unsigned int len)
{
    return unlikely(len > skb->len) ? NULL : __skb_pull(skb, len);
}
static inline unsigned char *__skb_pull(struct sk_buff *skb, unsigned int len)
{
    skb->len -= len;
    BUG_ON(skb->len < skb->data_len);
    return skb->data += len;
}

（6）skb_put：将tail指针下移len长度，并增加sk_buff中len的值，返回改变前的tail值

unsigned char *skb_put(struct sk_buff *skb, unsigned int len)
{
    unsigned char *tmp = skb_tail_pointer(skb);
    SKB_LINEAR_ASSERT(skb);
    skb->tail += len;
    skb->len  += len;
    if (unlikely(skb->tail > skb->end))
        skb_over_panic(skb, len, __builtin_return_address(0));
    return tmp;
}

（7）skb_trim：重设data到tail之间有效数据长度为len

void skb_trim(struct sk_buff *skb, unsigned int len)
{
    if (skb->len > len)
        __skb_trim(skb, len);
}
static inline void __skb_trim(struct sk_buff *skb, unsigned int len)
{
    if (unlikely(skb->data_len)) {
        WARN_ON(1);
        return;
    }
    skb->len = len;
    skb_set_tail_pointer(skb, len);
}

5. DM9000网卡驱动分析

① Linux2.6.29内核中已经有完整的DM9000网卡驱动，位于源文件drivers/net/dm9000.c。驱动将DM9000的IO内存资源和IRQ资源以平台设备资源的方式进行管理，并在dm9000.c中实现并注册了平台驱动，只要再向内核中注册板级相关的DM9000平台设备，网卡就能正常工作了。DM9000平台驱动定义如下

static struct platform_driver dm9000_driver = {
    .driver    = {
        .name    = "dm9000",
        .owner     = THIS_MODULE,
    },
    .probe   = dm9000_probe,
    .remove  = __devexit_p(dm9000_drv_remove),
    .suspend = dm9000_drv_suspend,
    .resume  = dm9000_drv_resume,
};

注：dm9000_probe是分析的重点。

② board_info结构：board_info是对net_device结构的扩展，以描述一个具体的网卡设备，也就是驱动中的DM9000。

/* Structure/enum declaration ------------------------------- */
typedef struct board_info {

    void __iomem    *io_addr;    /* Register I/O base address */
    void __iomem    *io_data;    /* Data I/O address */
    u16         irq;        /* IRQ */

    u16        tx_pkt_cnt;
    u16        queue_pkt_len;
    u16        queue_start_addr;
    u16        dbug_cnt;
    u8        io_mode;        /* 0:word, 2:byte */
    u8        phy_addr;
    u8        imr_all;

    unsigned int    flags;
    unsigned int    in_suspend :1;
    int        debug_level;

    enum dm9000_type type;

    void (*inblk)(void __iomem *port, void *data, int length);
    void (*outblk)(void __iomem *port, void *data, int length);
    void (*dumpblk)(void __iomem *port, int length);

    struct device    *dev;         /* parent device */

    struct resource    *addr_res;   /* resources found */
    struct resource *data_res;
    struct resource    *addr_req;   /* resources requested */
    struct resource *data_req;
    struct resource *irq_res;

    struct mutex     addr_lock;    /* phy and eeprom access lock */

    struct delayed_work phy_poll;
    struct net_device  *ndev;

    spinlock_t    lock;

    struct mii_if_info mii;
    u32        msg_enable;
} board_info_t;

注：net_device描述所有网卡的共性，按照面向对象的思想分析，board_info由net_device派生而来。驱动使用board_info的变量作为net_device对象的私有数据（紧跟着你net_device对象后存放，按32字节对齐）

③ dm9000_probe()函数

（1）在注册平台驱动时，内核遍历平台总线上的所有平台设备，通过名称匹配，并在找到匹配的设备后，调用平台驱动中的probe()方法。平台驱动通常利用probe()方法从匹配上的平台设备中获取平台资源，并根据这些资源申请和映射IO内存、获取并注册IRQ中断。DM9000_probe()除了做以上内容外，还最终调用register_netdev()注册网卡设备。

（2）dm9000_probe()函数分析1：获取设备私有数据（board_info结构），并为私有数据中的重要成员赋值。

static int __devinit
dm9000_probe(struct platform_device *pdev)
{
    struct dm9000_plat_data *pdata = pdev->dev.platform_data;
    struct board_info *db;    /* Point a board information structure */
    struct net_device *ndev;
　　...

　　/* Init network device */
    ndev = alloc_etherdev(sizeof(struct board_info));
    SET_NETDEV_DEV(ndev, &pdev->dev);/* setup board info structure */
    db = netdev_priv(ndev);
    memset(db, 0, sizeof(*db));

    db->dev = &pdev->dev;
    db->ndev = ndev;

    spin_lock_init(&db->lock);
    mutex_init(&db->addr_lock);

    INIT_DELAYED_WORK(&db->phy_poll, dm9000_poll_work);

　　对于代码INIT_DELAYED_WORK(&db->phy_poll, dm9000_poll_work)，安装延迟调度工作dm9000_poll_work，而dm9000_poll_work的作用是动态轮询检查DM9000的连接状态（由于DM9000E系列芯片不支持连接状态改变中断，故用此方法来检查连接状态）

（3）dm9000_probe()函数分析2：获取并保存平台资源和根据这些资源信息申请IO内存和中断

　　/* 获取平台资源 */
　　db->addr_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    db->data_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
    db->irq_res  = platform_get_resource(pdev, IORESOURCE_IRQ, 0);

　　/* 申请IO内存并映射--DM9000的INDEX端口 */
    iosize = res_size(db->addr_res);
    db->addr_req = request_mem_region(db->addr_res->start, iosize, pdev->name);
    db->io_addr = ioremap(db->addr_res->start, iosize);

　　/* 申请IO内存并映射--DM9000的DATA端口 */
    iosize = res_size(db->data_res);
    db->data_req = request_mem_region(db->data_res->start, iosize, pdev->name);

　　/* fill in parameters for net-dev structure */
    db->io_data = ioremap(db->data_res->start, iosize);
    ndev->base_addr = (unsigned long)db->io_addr;
    ndev->irq    = db->irq_res->start;

（4）dm9000_probe()函数分析3： 根据在平台设备中指定的私有数据，确定board_info结构中关于DM9000块读写的具体函数

    /* ensure at least we have a default set of IO routines */
    dm9000_set_io(db, iosize);

    /* check to see if anything is being over-ridden */
    if (pdata != NULL) {
        /* check to see if the driver wants to over-ride the
         * default IO width */

        if (pdata->flags & DM9000_PLATF_8BITONLY)
            dm9000_set_io(db, 1);

        if (pdata->flags & DM9000_PLATF_16BITONLY)
            dm9000_set_io(db, 2);

        if (pdata->flags & DM9000_PLATF_32BITONLY)
            dm9000_set_io(db, 4);

        /* check to see if there are any IO routine
         * over-rides */

        if (pdata->inblk != NULL)
            db->inblk = pdata->inblk;

        if (pdata->outblk != NULL)
            db->outblk = pdata->outblk;

        if (pdata->dumpblk != NULL)
            db->dumpblk = pdata->dumpblk;

        db->flags = pdata->flags;
    }

（5）dm9000_probe()函数分析4：确定驱动找到的芯片是DM9000，并且确定芯片的具体型号。

    dm9000_reset(db);

    /* try multiple times, DM9000 sometimes gets the read wrong */
    for (i = 0; i < 8; i++) {
        id_val  = ior(db, DM9000_VIDL);
        id_val |= (u32)ior(db, DM9000_VIDH) << 8;
        id_val |= (u32)ior(db, DM9000_PIDL) << 16;
        id_val |= (u32)ior(db, DM9000_PIDH) << 24;

        if (id_val == DM9000_ID)
            break;
        dev_err(db->dev, "read wrong id 0x%08x\n", id_val);
    }

    if (id_val != DM9000_ID) {
        dev_err(db->dev, "wrong id: 0x%08x\n", id_val);
        ret = -ENODEV;
        goto out;
    }

    /* Identify what type of DM9000 we are working on */

    id_val = ior(db, DM9000_CHIPR);
    dev_dbg(db->dev, "dm9000 revision 0x%02x\n", id_val);

    switch (id_val) {
    case CHIPR_DM9000A:
        db->type = TYPE_DM9000A;
        break;
    case CHIPR_DM9000B:
        db->type = TYPE_DM9000B;
        break;
    default:
        dev_dbg(db->dev, "ID %02x => defaulting to DM9000E\n", id_val);
        db->type = TYPE_DM9000E;
    }

（6）dm9000_probe()函数分析5：进一步填充ndev和db这两个结构体变量的成员，注册网络设备。

　　/* from this point we assume that we have found a DM9000 */
    /* driver system function */
    ether_setup(ndev);

　　/* 网卡操作方法填充 */
    ndev->open         = &dm9000_open;
    ndev->hard_start_xmit    = &dm9000_start_xmit;
    ndev->tx_timeout         = &dm9000_timeout;
    ndev->watchdog_timeo = msecs_to_jiffies(watchdog);
    ndev->stop         = &dm9000_stop;
    ndev->set_multicast_list = &dm9000_hash_table;
    ndev->ethtool_ops     = &dm9000_ethtool_ops;
    ndev->do_ioctl         = &dm9000_ioctl;

#ifdef CONFIG_NET_POLL_CONTROLLER
    ndev->poll_controller     = &dm9000_poll_controller;
#endif
　　/* 调试信息只对连接事件开放 */
    db->msg_enable       = NETIF_MSG_LINK;
　　/* 指定网卡MII的属性和方法 */
    db->mii.phy_id_mask  = 0x1f;
    db->mii.reg_num_mask = 0x1f;
    db->mii.force_media  = 0;
    db->mii.full_duplex  = 0;
    db->mii.dev         = ndev;
    db->mii.mdio_read    = dm9000_phy_read;
    db->mii.mdio_write   = dm9000_phy_write;

#if defined(CONFIG_ARCH_S3C2410)
    printk("Now use the default MAC address: 08:90:90:90:90:90\n");
    mac_src = "friendly-arm";
    ndev->dev_addr[0] = 0x08;
    ndev->dev_addr[1] = 0x90;
    ndev->dev_addr[2] = 0x90;
    ndev->dev_addr[3] = 0x90;
    ndev->dev_addr[4] = 0x90;
    ndev->dev_addr[5] = 0x90;
#else
    mac_src = "eeprom";

    /* try reading the node address from the attached EEPROM */
    for (i = 0; i < 6; i += 2)
        dm9000_read_eeprom(db, i / 2, ndev->dev_addr+i);

    if (!is_valid_ether_addr(ndev->dev_addr) && pdata != NULL) {
        mac_src = "platform data";
        memcpy(ndev->dev_addr, pdata->dev_addr, 6);
    }

    if (!is_valid_ether_addr(ndev->dev_addr)) {
        /* try reading from mac */
        
        mac_src = "chip";
        for (i = 0; i < 6; i++)
            ndev->dev_addr[i] = ior(db, i+DM9000_PAR);
    }

    if (!is_valid_ether_addr(ndev->dev_addr))
        dev_warn(db->dev, "%s: Invalid ethernet MAC address. Please "
             "set using ifconfig\n", ndev->name);
#endif

    platform_set_drvdata(pdev, ndev);
    ret = register_netdev(ndev);

    if (ret == 0)
        printk(KERN_INFO "%s: dm9000%c at %p,%p IRQ %d MAC: %pM (%s)\n",
               ndev->name, dm9000_type_to_char(db->type),
               db->io_addr, db->io_data, ndev->irq,
               ndev->dev_addr, mac_src);
    return 0;

out:
#if defined(CONFIG_ARCH_S3C2410)
    *(volatile unsigned int *)S3C2410_BWSCON   = oldval_bwscon;
    *(volatile unsigned int *)S3C2410_BANKCON4 = oldval_bankcon4;
#endif
    dev_err(db->dev, "not found (%d).\n", ret);

    dm9000_release_board(pdev, db);
    free_netdev(ndev);

    return ret;
}

（7）dm9000_probe()函数总结：dm9000_probe()函数的作用是分配ndev（net_device结构）存储空间、填充其成员，并最终将其注册进内核。而db（board_info结构）作为ndev的私有数据也将一并注册进内核。

注1：dm9000_probe()函数在申请内存空间的时候是带有board_info结构体的空间的，

ndev = alloc_etherdev(sizeof(struct board_info))

其申请的内存空间长度实际为：sizeof(struct net_device) + align + (sizeof(struct board_info)。

注2：db（board_info）指针获取的方法是通过ndev（net_device），即db = ndev + sizeof(net_device) + align

db = netdev_priv(ndev);

static inline void *netdev_priv(const struct net_device *dev)
{
    return (char *)dev + ((sizeof(struct net_device)
                   + NETDEV_ALIGN_CONST)
                  & ~NETDEV_ALIGN_CONST);
}

④ dm9000_open()函数：在网卡被激活时调用，主要完成的工作有向内核注册中断、复位并初始化dm9000、检查MII接口等。

static int dm9000_open(struct net_device *dev)
{
    board_info_t *db = netdev_priv(dev);
    unsigned long irqflags = db->irq_res->flags & IRQF_TRIGGER_MASK;

    if (netif_msg_ifup(db))
        dev_dbg(db->dev, "enabling %s\n", dev->name);

    /* If there is no IRQ type specified, default to something that
     * may work, and tell the user that this is a problem */

    if (irqflags == IRQF_TRIGGER_NONE)
        dev_warn(db->dev, "WARNING: no IRQ resource flags set.\n");

    irqflags |= IRQF_SHARED;

    if (request_irq(dev->irq, &dm9000_interrupt, irqflags, dev->name, dev))
        return -EAGAIN;

    /* Initialize DM9000 board */
    dm9000_reset(db);
    dm9000_init_dm9000(dev);

    /* Init driver variable */
    db->dbug_cnt = 0;

    mii_check_media(&db->mii, netif_msg_link(db), 1);
    netif_start_queue(dev);
    
    dm9000_schedule_poll(db);

    return 0;

⑤ dm9000_start_xmit()：用于启动数据包的发送，负责将上层送过来的skb数据包发送出去

static int
dm9000_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
    unsigned long flags;
    board_info_t *db = netdev_priv(dev);

    dm9000_dbg(db, 3, "%s:\n", __func__);

    if (db->tx_pkt_cnt > 1)
        return 1;

    spin_lock_irqsave(&db->lock, flags);

    /* Move data to DM9000 TX RAM */
    writeb(DM9000_MWCMD, db->io_addr);

    (db->outblk)(db->io_data, skb->data, skb->len);
    dev->stats.tx_bytes += skb->len;

    db->tx_pkt_cnt++;
    /* TX control: First packet immediately send, second packet queue */
    if (db->tx_pkt_cnt == 1) {
        /* Set TX length to DM9000 */
        iow(db, DM9000_TXPLL, skb->len);
        iow(db, DM9000_TXPLH, skb->len >> 8);

        /* Issue TX polling command */
        iow(db, DM9000_TCR, TCR_TXREQ);    /* Cleared after TX complete */

        dev->trans_start = jiffies;    /* save the time stamp */
    } else {
        /* Second packet */
        db->queue_pkt_len = skb->len;
        netif_stop_queue(dev);
    }

    spin_unlock_irqrestore(&db->lock, flags);

    /* free this SKB */
    dev_kfree_skb(skb);

    return 0;
}

⑥ 数据包接收函数：dm9000_rx()

（1）网卡收到数据包后，调用dm9000_rx()完成以下工作

　　* 判断包是否接收到

　　* 检查包的状态和长度

　　* 读取包数据

　　* 利用读取到的包的实际数据构造skb，并调用netif_rx()将skb送到上层协议处理。

（2）dm9000_rx()中构造skb，并且递交到上层处理的代码

static void
dm9000_rx(struct net_device *dev)
{
    ...
　　do {   
    　　...
　　　　　/* Move data from DM9000 */
        if (GoodPacket
            && ((skb = dev_alloc_skb(RxLen + 4)) != NULL)) {
            skb_reserve(skb, 2);
            rdptr = (u8 *) skb_put(skb, RxLen - 4);

            /* Read received packet from RX SRAM */

            (db->inblk)(db->io_data, rdptr, RxLen);
            dev->stats.rx_bytes += RxLen;

            /* Pass to upper layer */
            skb->protocol = eth_type_trans(skb, dev);
            netif_rx(skb);
            dev->stats.rx_packets++;

        } else {
            /* need to dump the packet's data */

            (db->dumpblk)(db->io_data, RxLen);
        }
    } while(rxbyte == DM9000_PKT_RDY)
}

⑦ 数据包发送函数：dm9000_tx_done()

 （1）DM9000数据包发送完整过程：

　　* 在发送一个包之前，将包中的有效数据通过MWCMD寄存器，写入TX缓冲区

　　* 如果待发送包是第一个包，则直接启动包发送：

　　* 如果待发送包不是第一个包，则暂不发送，而是记录包长度和校验控制位，并停止发送队列

　　（注：以上三步在dm9000_start_xmit()方法中实现的）

　　* 如果设置了IMR（中断屏蔽）寄存器的PTM位，则当数据发送完成后产生中断，并使ISR（中断状态）寄存器的PTS位被设置。因此可以在中断处理函数中判断中断，执行剩余的发送操作

　　（注：以下三步在dm9000_tx_done()中完成）

　　* 读取NSR（网络状态）寄存器获取发送的状态，根据NSR_TX2END、NSR_TX1END为来判断是否进行接下来的处理

　　* 将待发送数据包计数（db->tx_pkt_cnt）减1，且检查db->tx_pkt_cnt是否大于0。如果大于0，则表明还有数据包要发送，将待发送包的长度写入TXPLL和TXPLH寄存器，并通过TCR寄存器请求发送

　　* 调用函数netif_wake_queue()通知内核可以将待发送的数据包加入发送队列（将skb包通过MWCMD寄存器，写入TX缓冲区）

（2）dm9000_tx_done()函数实现如下：

static void dm9000_tx_done(struct net_device *dev, board_info_t *db)
{
    int tx_status = ior(db, DM9000_NSR);    /* Got TX status */

    if (tx_status & (NSR_TX2END | NSR_TX1END)) {
        /* One packet sent complete */
        db->tx_pkt_cnt--;
        dev->stats.tx_packets++;

        if (netif_msg_tx_done(db))
            dev_dbg(db->dev, "tx done, NSR %02x\n", tx_status);

        /* Queue packet check & send */
        if (db->tx_pkt_cnt > 0) {
            iow(db, DM9000_TXPLL, db->queue_pkt_len);
            iow(db, DM9000_TXPLH, db->queue_pkt_len >> 8);
            iow(db, DM9000_TCR, TCR_TXREQ);
            dev->trans_start = jiffies;
        }
        netif_wake_queue(dev);
    }
}

 ⑧ 中断处理函数：dm9000_interrupt()

（1）Linux源码中的DM9000驱动采用中断方式实现，触发中断的时机发生在：接收到一个数据包后、发送完一个数据包后及连接状态改变之后（DM9000E不支持连接状态改变中断）

（2）中断处理函数在设备执行open方法时被注册进内核，dm9000_interrupt()源码如下

static irqreturn_t dm9000_interrupt(int irq, void *dev_id)
{
    struct net_device *dev = dev_id;
    board_info_t *db = netdev_priv(dev);
    int int_status;
    unsigned long flags;
    u8 reg_save;

    dm9000_dbg(db, 3, "entering %s\n", __func__);

    /* A real interrupt coming */

    /* holders of db->lock must always block IRQs */
    spin_lock_irqsave(&db->lock, flags);

    /* Save previous register address */
    reg_save = readb(db->io_addr);

    /* Disable all interrupts */
    iow(db, DM9000_IMR, IMR_PAR);

    /* Got DM9000 interrupt status */
    int_status = ior(db, DM9000_ISR);    /* Got ISR */
    iow(db, DM9000_ISR, int_status);    /* Clear ISR status */

    if (netif_msg_intr(db))
        dev_dbg(db->dev, "interrupt status %02x\n", int_status);

    /* Received the coming packet */
    if (int_status & ISR_PRS)
        dm9000_rx(dev);

    /* Trnasmit Interrupt check */
    if (int_status & ISR_PTS)
        dm9000_tx_done(dev, db);

    if (db->type != TYPE_DM9000E) {
        if (int_status & ISR_LNKCHNG) {
            /* fire a link-change request */
            schedule_delayed_work(&db->phy_poll, 1);
        }
    }

    /* Re-enable interrupt mask */
    iow(db, DM9000_IMR, db->imr_all);

    /* Restore previous register address */
    writeb(reg_save, db->io_addr);

    spin_unlock_irqrestore(&db->lock, flags);

    return IRQ_HANDLED;
}

6. Mini2440的DM9000网卡驱动移植

① 由于Linux2.6.29内核已经有DM9000完整的驱动，我们只需在板级初始化文件中添加DM9000网卡的平台设备。

② 在板级初始化文件arch/arm/mach-s3c2440/mack-smdk2440.c中添加如下内容：

#include <linux/dm9000.h>
#define MACH_SMDK2440_DM9000_BASE (S3C2410_CS4)

static struct resource smdk2440_dm9000_resource[] = {
    [0] = {
        .start = MACH_SMDK2440_DM9000_BASE,
        .end = MACH_SMDK2440_DM9000_BASE + 3,
        .flags = IORESOURCE_MEM,
    },
    [1] = {
        .start = MACH_SMDK2440_DM9000_BASE + 4,
        .end = MACH_SMDK2440_DM9000_BASE + 7,
        .flags = IORESOURCE_MEM,
    },
    [2] = {
        .start = IRQ_EINT7,
        .end = IRQ_EINT7,
        .flags = (IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE),
    }
};

static struct dm9000_plat_data smdk2440_dm9000_pdata = {
    .flags = (DM9000_PLATF_16BITONLY | DM9000_PLATF_NO_EEPROM),
};

static struct platform_device smdk2440_device_eth = {
    .name = "dm9000",
    .id = -1,
    .num_resources = ARRAY_SIZE(smdk2440_dm9000_resource),
    .resource = smdk2440_dm9000_resource,
    .dev = {
        .platform_data = &smdk2440_dm9000_pdata,
    }
};

static struct platform_device *smdk2440_devices[] __initdata = {
    &s3c_device_usb,
    &s3c_device_lcd,
    &s3c_device_wdt,
    &s3c_device_i2c0,
    &s3c_device_iis,
    &smdk2440_device_eth,
};