编写Linux网卡设备驱动(下)

转载出处:

http://arttech.us/y-2011/writing-network-device-driver-b.html

 

本文介绍基于Realtek 8139芯片PCI接口的网卡驱动程序。我选择了Realtek芯片有两个原因:首先,Realtek提供免费的芯片技术手册; 第二,芯片相当便宜。

本文介绍的驱动程序是最基本的,它只有发送和接收数据包功能,和做一些简单的统计。对于一个全面和专业级的驱动程序,请参阅Linux源码。

本文(下)的主要内容是在前一文(上)实现的驱动模板的基础上进一步实现网卡驱动的分组收发功能。除了实现发包接口和收包接口,原模板上的初始化接口、打开接口和私有数据都要改动。另外,网卡的硬件收发原理在《RTL8139的收发原理》(下述简称《收发原理》)已经阐述得很清楚,本文是对《收发原理》中的理念用代码具体实现。

目录

网络设备驱动程序的开发,分解成以下步骤:

上:

  • 1.检测设备
  • 2.启用设备
  • 3.认识网络设备
  • 4.总线无关的设备访问
  • 5.理解PCI配置空间
  • 6.初始化网络设备(net_device)

中:

  • 7.RTL8139收发原理

下:

  • 8.编写网络设备的发包功能
  • 9.编写网络设备的收包功能

8.实现网络设备的发包功能

8.1 扩展rtl8139_private

在实现网络设备的打开和发送接口前,我必须先扩展我们的设备私有数据结构——rtl8139_private。

#define NUM_TX_DESC 4
struct rtl8139_private
{
    struct pci_dev *pci_dev;  /* PCI device */
    void *mmio_addr; /* memory mapped I/O addr */
    unsigned long regs_len; /* length of I/O or MMI/O region */
    unsigned int tx_flag;
    unsigned int cur_tx;
    unsigned int dirty_tx;
    unsigned char *tx_buf[NUM_TX_DESC];   /* Tx bounce buffers */
    unsigned char *tx_bufs;        /* Tx bounce buffer region. */
    dma_addr_t tx_bufs_dma;
};


 

Table 9: rtl8139_private structure

rtl8139_private为实现发包功能新添6个成员,我们一一介绍它们。tx_flag 成员从名字可知,发送状态字,它是《收发原理》中的TSD在主机方的一个副本,用来启动发送,下面代码中你将会看到;cur_tx成员和dirty_tx成员是《收发原理》中发包原理部分提到的两个全局变量——write_buff(记录最新可用缓冲区号)和read_buff(记录最后发送缓冲区号)的实现。tx_bufs是缓冲区的起始地址,tx_buf是地址数组,分别记录四块缓冲区的起始地址,它是《收发原理》中的TSAD在主机方的一个副本。注意这两种地址都是逻辑地址,在配置TSAD前必须转换为物理地址(转换方法在代码中可以看到)。转换的根据就是下一个成员,tx_bufs_dma。tx_bufs_dma保存缓冲区的物理地址。

8.2 扩展open接口

改写了rtl8139_private后,我们看open接口的新实现:

static int rtl8139_open(struct net_device *dev)
{
    int retval;
    struct rtl8139_private *tp = dev->priv;

    /* get the IRQ
    * second arg is interrupt handler
    * third is flags, 0 means no IRQ sharing
    */
    retval = request_irq(dev->irq, rtl8139_interrupt, 0, dev->name, dev);
    if(retval)
        return retval;

    /* get memory for Tx buffers
    * memory must be DMAable
    */
    tp->tx_bufs = pci_alloc_consistent(
    tp->pci_dev, TOTAL_TX_BUF_SIZE, &tp->tx_bufs_dma);

    if(!tp->tx_bufs) {
        free_irq(dev->irq, dev);
        return -ENOMEM;
    }

    tp->tx_flag = 0;
    rtl8139_init_ring(dev);
    rtl8139_hw_start(dev);

    return 0;
}

static void rtl8139_init_ring (struct net_device *dev)
{
    struct rtl8139_private *tp = dev->priv;
    int i;

    tp->cur_tx = 0;
    tp->dirty_tx = 0;

    for (i = 0; i < NUM_TX_DESC; i++)
        tp->tx_buf[i] = &tp->tx_bufs[i * TX_BUF_SIZE];

    return;
}

Table 11: Writing the open function
 
现在简要分析一下,open函数首先通过API(request_irq)向系统申请绑定IRQ号(KEMIN:逻辑中断号是怎么得到的?)和中断处理函数(rtl8139_interrupt);接着向PCI子系统申请内存空间给发送缓冲区(tp->tx_bufs),注意,pci_alloc_consistent直接返回的是虚拟地址,物理地址通过第三个参数返回。然后在rtl8139_init_ring 函数中将缓冲区分为四段(tp->tx_buf[i])。
 
static void rtl8139_chip_reset (void *ioaddr)
{
    int i;

    /* Soft reset the chip. */
    writeb(CmdReset, ioaddr + CR);

    /* Check that the chip has finished the reset. */
    for (i = 1000; i > 0; i--) {
        barrier();
        if ((readb(ioaddr + CR) & CmdReset) == 0)
            break;
        udelay (10);
    }
    return;
}


 

缓冲区分配好后,rtl8139_hw_start函数可以启动硬件了。我们首先做是的重置(reset)设备——向设备命令寄存器(CR)写入重置值,让RTL8139回到预定状态;rtl8139_chip_reset函数使用了一个循环来检测重置操作,注意循环开始用了一个内存防护(barrier)操作,确保内核每次循环确切读取设备,而不作优化去读缓存。

static void rtl8139_hw_start (struct net_device *dev)
{
    struct rtl8139_private *tp = dev->priv;
    void *ioaddr = tp->mmio_addr;
    u32 i;

    rtl8139_chip_reset(ioaddr);

    /* Must enable Tx before setting transfer thresholds! */
    writeb(CmdTxEnb, ioaddr + CR);

    /* tx config */
    writel(0x00000600, ioaddr + TCR); /* DMA burst size 1024 */

    /* init Tx buffer DMA addresses */
    for (i = 0; i < NUM_TX_DESC; i++) {
        writel(tp->tx_bufs_dma + (tp->tx_buf[i] - tp->tx_bufs),ioaddr + TSAD0 + (i * 4));
    }

    /* Enable all known interrupts by setting the interrupt mask. */
    writew(INT_MASK, ioaddr + IMR);

    netif_start_queue (dev);
    return;
}


 

完成重置操作后,我们启用设备的发送功能——向设备命令寄存器(CR)写入启用值。然后,我们配置发送模式—— TCR (Transmission Configuration Register),这里我们只配置了“DMA突发传输的最大值”(Max DMA Burst Size per Tx DMA Burst),其它使用默认配置。接着我们把刚分配好四段缓冲区地址(转为物理地址后)写入四个发送描述符(TSAD),最后打开所有中断——将IMR (Interrupt Mask Register)全部位置1;

至此,设备使用前配置基本完成,最后调用netif_start_queue,把设备挂到系统活动的网络设备列表,供网络协议栈使用。

8.3 发送接口hard_start_xmit

我们现在可以进一点充实发包接口了。代码如下:

#define ETH_MIN_LEN 60  /* minimum Ethernet frame size */

static int rtl8139_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
    struct rtl8139_private *tp = dev->priv;
    void *ioaddr = tp->mmio_addr;
    unsigned int entry = tp->cur_tx;
    unsigned int len = skb->len;

    if (len < TX_BUF_SIZE) {
        if(len < ETH_MIN_LEN)
            memset(tp->tx_buf[entry], 0, ETH_MIN_LEN);
        skb_copy_and_csum_dev(skb, tp->tx_buf[entry]);
        dev_kfree_skb(skb);
    } else {
        dev_kfree_skb(skb);
        return 0;
    }

    writel(tp->tx_flag | max(len, (unsigned int)ETH_MIN_LEN),
    ioaddr + TSD0 + (entry * sizeof (u32)));
    entry++;
    tp->cur_tx = entry % NUM_TX_DESC;

    if(tp->cur_tx == tp->dirty_tx) {
        netif_stop_queue(dev);
    }
    return 0;
}


 

Table 12: Writing start_xmit function

发送接口函数还是比较直观的。首先,函数检查数据包大小,确保不大于缓冲区,亦不小于以太网帧最小值(60字节);然后调用skb_copy_and_csum_dev函数将其拷入第cur_tx号缓冲区。完了后,配置tx_flag(这里只配置了数据包的大小,不限阀值)后调用writel将其写TSD,启动发送。接着,更新cur_tx,代码用模操作(%)来实现缓冲区循环制使用。最后判断缓冲区是否满,然则通知协议栈停止发送。

8.4 发包完成中断处理

数据包发走后还需要后续处理,处理在中断处理函数内完成。设备驱动只有一支中断处理函数,设备的中断事件需在函数内进一步区分。

rtl8139_interrupt
static void rtl8139_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
{
    struct net_device *dev = (struct net_device*)dev_instance;
    struct rtl8139_private *tp = dev->priv;
    void *ioaddr = tp->mmio_addr;
    unsigned short isr = readw(ioaddr + ISR);

    /* clear all interrupt.
    * Specs says reading ISR clears all interrupts and writing
    * has no effect. But this does not seem to be case. I keep on
    * getting interrupt unless I forcibly clears all interrupt 
    */
    writew(0xffff, ioaddr + ISR);

    if((isr & TxOK) || (isr & TxErr))
    {
        while((tp->dirty_tx != tp->cur_tx) || netif_queue_stopped(dev))
        {
            unsigned int txstatus =
            readl(ioaddr + TSD0 + tp->dirty_tx * sizeof(int));

            if(!(txstatus & (TxStatOK | TxAborted | TxUnderrun)))
                break; /* yet not transmitted */

            if(txstatus & TxStatOK) {
                LOG_MSG("Transmit OK interrupt\n");
                tp->stats.tx_bytes += (txstatus & 0x1fff);
                tp->stats.tx_packets++;
            }
            else {
                LOG_MSG("Transmit Error interrupt\n");
                tp->stats.tx_errors++;
        }

        tp->dirty_tx++;
        tp->dirty_tx = tp->dirty_tx % NUM_TX_DESC;

        if((tp->dirty_tx == tp->cur_tx) & netif_queue_stopped(dev))
        {
            LOG_MSG("waking up queue\n");
            netif_wake_queue(dev);
        }
        }
    }
.......
}

代码中我们可以看到,中断处理首先将8139的中断状态复制到本地,然后重置中断状态;接着判断是什么中断事件,如果是发包完成(TxOK),则取得发送状态信息,然后作一些统计。最后更新读指针(dirty_tx),并唤醒发包队列。

值得注意的是,统计和更新操作在一个while循环内完成的,那是因为8139不是在成功发送一个包后发出中断,而是将缓冲区上所有包发走后才发出中断的。可以想像一下发包情形,由于相对于8139,主机CPU较快,它会在很短的时间内(或在发完第一个包之前)[注]将发包缓冲区填满而停掉发包队列,等待缓冲区再次可用,而8139在处理完所有TSD.OWN为0的缓冲区后,发出中断,唤醒发包队列,如此循环往复。

注:事实上,主机CPU在8139发完哪个包之前停掉发包队列均可,因为主机CPU和8139是独立工作的。只有一个情况值得特别注意,就是当主机CPU在完成写入一块缓冲区前,发包完成中断(TxOK)出现。由于发包完成中断是硬件中断,优先级较高,它会中断发包函数,优先处理。所以必须特别小心两个函数的共享变量——cur_tx和dirty_tx的访问顺序。

现在我们的驱动程序已经具有发包功能了。你可以编译并安装它,尝试ping一个远程主机,如无意外,你将在远程主机看到有ARP数据包收到;不过在本地,我们看不到远程主机发回的ARP应答包,因为我们还没有实现收包功能。

9.实现网络设备的收包功能

接下来,我们实现网络设备的收包功能,与发包功能实现相似,我们需要扩展现有打开接口和设备私有数据。

9.1 扩展rtl8139_private

struct rtl8139_private
{
    struct pci_dev *pci_dev;  /* PCI device */
    void *mmio_addr; /* memory mapped I/O addr */
    unsigned long regs_len; /* length of I/O or MMI/O region */
    unsigned int tx_flag;
    unsigned int cur_tx;
    unsigned int dirty_tx;
    unsigned char *tx_buf[NUM_TX_DESC];   /* Tx bounce buffers */
    unsigned char *tx_bufs;        /* Tx bounce buffer region. */
    dma_addr_t tx_bufs_dma;

    struct net_device_stats stats;
    unsigned char *rx_ring;
    dma_addr_t rx_ring_dma;
    unsigned int cur_rx;
};


 

Table 13: Extending rtl8139_private structure

rtl8139_private为实现收包功能新添4个成员。stats成员是net_device_stats实例[注],记录设备运作的统计信息(如大部分通过ifconfig查询到的统计信息来源此成员)。rx_ring成员是收包缓冲区(环形缓冲区)的逻辑地址,rx_ring_dma成员是对应的物理地址。cur_rx成员是环缓冲的读指针,不过它的类型不是指针,因为它是一个16位偏移值。

注:本文使用的代码比较原始,此成员目前已经被标准化,抽象到通用的结构net_device上去了。

9.2 扩展open接口

扩展的第一步是分配收包缓冲区。

/* Size of the in-memory receive ring. */
#define RX_BUF_LEN_IDX 2         /* 0==8K, 1==16K, 2==32K, 3==64K */
#define RX_BUF_LEN     (8192 << RX_BUF_LEN_IDX)
#define RX_BUF_PAD     16           /* see 11th and 12th bit of RCR: 0x44 */
#define RX_BUF_WRAP_PAD 2048   /* spare padding to handle pkt wrap */
#define RX_BUF_TOT_LEN  (RX_BUF_LEN + RX_BUF_PAD + RX_BUF_WRAP_PAD)

/* this we have already done */
tp->tx_bufs = pci_alloc_consistent(tp->pci_dev, TOTAL_TX_BUF_SIZE, &tp->tx_bufs_dma);

/* add this code to rtl8139_function */
tp->rx_ring = pci_alloc_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
               &tp->rx_ring_dma);

if((!tp->tx_bufs)  || (!tp->rx_ring)) {
    free_irq(dev->irq, dev);

if(tp->tx_bufs) {
    pci_free_consistent(tp->pci_dev, TOTAL_TX_BUF_SIZE, tp->tx_bufs, tp->tx_bufs_dma);
    p->tx_bufs = NULL;
}
if(tp->rx_ring) {
    pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN, tp->rx_ring,
                    tp->rx_ring_dma);
    tp->rx_ring = NULL;
    }
return -ENOMEM;
}


 

Table 14: Extending rtl8139_open function

代码14首先算得收包缓冲区所需大小。RX_BUF_TOT_LEN 的值取决于收包配置(RCR寄存器)。我将在下面扩展的rtl8139_hw_start函数看到,我们配置了RCR的位12-11为10,位7为1;前者意为收包缓冲区大小为32K+16,后者意为当写入收到的数据包写到了缓冲区的末端,而数据包还没有收完时,剩下的数据继续往下写,而不写到缓冲区的始端,因此我们为收包缓冲区分配了2K额外的附加区。

现在我们扩展rtl8139_hw_start:

static void rtl8139_hw_start (struct net_device *dev)
{
    struct rtl8139_private *tp = dev->priv;
    void *ioaddr = tp->mmio_addr;
    u32 i;

    rtl8139_chip_reset(ioaddr);

    /* Must enable Tx/Rx before setting transfer thresholds! */
    writeb(CmdTxEnb | CmdRxEnb, ioaddr + CR);

    /* tx config */
    writel(0x00000600, ioaddr + TCR); /* DMA burst size 1024 */

    /* rx config */
    writel(((1 << 12) | (7 << 8) | (1 << 7) |
    (1 << 3) | (1 << 2) | (1 << 1)), ioaddr + RCR);

    /* init Tx buffer DMA addresses */
    for (i = 0; i < NUM_TX_DESC; i++) {
        writel(tp->tx_bufs_dma + (tp->tx_buf[i] - tp->tx_bufs),
        ioaddr + TSAD0 + (i * 4));
    }

    /* init RBSTART */
    writel(tp->rx_ring_dma, ioaddr + RBSTART);

    /* initialize missed packet counter */
    writel(0, ioaddr + MPC);

    /* no early-rx interrupts */
    writew((readw(ioaddr + MULINT) & 0xF000), ioaddr + MULINT);

    /* Enable all known interrupts by setting the interrupt mask. */
    writew(INT_MASK, ioaddr + IMR);

    netif_start_queue (dev);
    return;
}

Table 15: Extending rtl8139_hw_start function

 
代码15中,首先改动的是写入CR寄存器值 CmdTxEnb | CmdRxEnb,意为同时开启收包和发包功能;接着配置了收包功能,我在代码没有使用macros作配置值,但意思已经很明白了,RCR的配置位意思如下:
  • Bit 1 – 接受物理匹配的包
  • Bit 2 – 接受组播包
  • Bit 3 – 接受广播包
  • Bit 7 – WRAP,当写入收到的数据包写到了缓冲区的末端,而数据包还没有收完时,剩下的数据继续往下写,还是截断写到始端
  • Bit 8-10 – 最大DMA单次突发传输量,我们配置为111,即无限制
  • Bit 11-12 – 收包缓冲区大小,我们配置为10,即32K+16 bytes

接着的改动是配置了8139的RBSTART寄存器,告诉8139收包缓冲区的起始地址;最后初始化了MPC (Missed Packet Counter)寄存和屏蔽了预收包中断(early rx interrupts)。

9.3 收包中断处理函数

收包功能最后一步是收包中断处理。

static void rtl8139_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
{
    struct net_device *dev = (struct net_device*)dev_instance;
    struct rtl8139_private *tp = dev->priv;
    void *ioaddr = tp->mmio_addr;
    unsigned short isr = readw(ioaddr + ISR);

    /* clear all interrupt.
    * Specs says reading ISR clears all interrupts and writing
    * has no effect. But this does not seem to be case. I keep on
    * getting interrupt unless I forcibly clears all interrupt 
    */
    writew(0xffff, ioaddr + ISR);

    if(isr & RxOK) {
    LOG_MSG("receive interrupt received\n");
    while((readb(ioaddr + CR) & RxBufEmpty) == 0)
    {
        unsigned int rx_status;
        unsigned short rx_size;
        unsigned short pkt_size;
        struct sk_buff *skb;

        if(tp->cur_rx > RX_BUF_LEN)
            tp->cur_rx = tp->cur_rx % RX_BUF_LEN;

        /* TODO: need to convert rx_status from little to host endian
        * XXX: My CPU is little endian only 
        */
        rx_status = *(unsigned int*)(tp->rx_ring + tp->cur_rx);
        rx_size = rx_status >> 16;

        /* first two bytes are receive status register
        * and next two bytes are frame length
        */
        pkt_size = rx_size - 4;

        /* hand over packet to system */
        skb = dev_alloc_skb (pkt_size + 2);
        if (skb) {
            skb->dev = dev;
            skb_reserve (skb, 2); /* 16 byte align the IP fields */

            eth_copy_and_sum(
            skb, tp->rx_ring + tp->cur_rx + 4, pkt_size, 0);

            skb_put (skb, pkt_size);
            skb->protocol = eth_type_trans (skb, dev);
            netif_rx (skb);

            dev->last_rx = jiffies;
            tp->stats.rx_bytes += pkt_size;
            tp->stats.rx_packets++;
        }
        else {
            LOG_MSG("Memory squeeze, dropping packet.\n");
            tp->stats.rx_dropped++;
        }

        /* update tp->cur_rx to next writing location  * /
        tp->cur_rx = (tp->cur_rx + rx_size + 4 + 3) & ~3;

        /* update CAPR */
        writew(tp->cur_rx, ioaddr + CAPR);
        }
    }
//......
}

Table 16: Interrupt Handler
 
代码中我们可以看到,中断处理首先将8139的中断状态复制到本地,然后重置中断状态;接着判断收包中断事件(RxOK)。收包处理使用了一个while循环,可见收包与发包类似,都不是每包一次中断,而每缓冲区一次中断,这样降低的中断次数,提高收发效率。收包循环第一件事是判断读指针(cur_rx)是否越出缓冲区边界(从前面的收包功能配置可知,收包缓冲区可配置附加区的),如果越出,则wrap回来。完了后开始正式的收包操作,如取得收包状态、分析包大小、分配skb、对skb作一些链路层处理后将其交与内核的收包接口netif_rx,最后统计。

收包处理最后一步是更新读指针,包括主机CPU副本cur_rx和8139的CAPR。更新8139的CAPR还有一个重要的副作用,就是如果CAPR==CBA时,8139置CR.RxBufEmpty为1,表示缓冲为空,8139对外发出消除暂停控制帧,驱动程序退出while循环,完成收包中断处理。

9.4 统计

最后实现的接口是rtl8139_get_stats,它只是简单地返回tp->stats:

static struct net_device_stats* rtl8139_get_stats(struct net_device *dev)
{
    struct rtl8139_private *tp = dev->priv;
    return &(tp->stats);
}

Table 17: rtl8139_get_stats function

到此,网卡设备驱动基本完成,你可以再次编译并安装它,尝试ping一个远程主机,如无意外,你将在远程主机看到有ARP数据包收到;在本地,亦可以收到远程主机发回的ARP应答包。

10.小结

虽然专业级的设备驱动比本文的基本驱动需要更多的功能,然而,本文的基本驱动对你理解网卡驱动和开发产品级驱动是有帮助的。


 

你可能感兴趣的:(linux,设备驱动)