编写Linux网卡设备驱动（下）

编写Linux网卡设备驱动（下）

本文介绍基于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。

[cpp] view
plaincopy

#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接口的新实现：

[cpp] view
plaincopy

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]）。

[cpp] view
plaincopy

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）操作，确保内核每次循环确切读取设备，而不作优化去读缓存。

[cpp] view
plaincopy

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

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

[cpp] view
plaincopy

#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

[cpp] view
plaincopy

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

[cpp] view
plaincopy

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接口

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

[cpp] view
plaincopy

/* 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：

[cpp] view
plaincopy

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 收包中断处理函数

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

[cpp] view
plaincopy

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：

[html] view
plaincopy

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.小结

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