初识 Embedded Visual C++ (转)

Linux网卡驱动

[align=center] [/align]
NE2000以太网卡的基础上进行的。
只要看懂一块网卡的驱动，那么其他网卡的驱动是类似的，模块的划分也是一致的，只是具体的函数和芯片的操作有区别。
文档中红色的标注都是重点。
自己看代码的时候避免依赖于硬件和芯片的代码，而对整个网络设备管理机制的学习，并关注一般网络设备所共有的东西。

[/b]

一. 网络设备驱动

网络的物理设备，称为接口（Interface）。所有对网络硬件的访问都是通过接口进行的，接口提供了一个对所有类型的硬件一致化的操作集合来处理基本数据的发送和接收。
一个网络接口被看作是一个发送和接收数据包（packets）的实体。
对于每个网络接口，都用一个device的数据结构表示，有关该数据结构的具体内容，将在本文的后面详细介绍，周日的代码中已经将主要的部分注释了。
网络设备是一个物理设备如以太网卡，但软件也可以作为网络设备，如回送设备（loopback）。
在内核启动时，通过网络设备驱动程序，将登记存在的网络设备。设备用标准的支持网络的机制来转递收到的数据到相应的网络层。
所有被发送和接收的包都用数据结构sk_buff表示。这是一个具有很好的灵活性的数据结构，可以很容易增加或删除网络协议数据包的首部，是和上层的接口，对于IP层的网络来说，只能识别和区分skbuff。
网络接口的核心用一个device数据结构表示的。网络设备在做数据包发送和接收时，直接通过接口访问。
网络接口是在系统初始化时实时生成的，对于核心支持的但不存在的物理网络设备，将不可能有与之相对应的device结构。
在内核中也存在着一张网络接口管理表dev_base，但与前两张表不同，dev_base是指向device结构的指针，因为网络设备是通过device数据结构来表示的。dev_base实际上是一条device结构链表的表头，在系统初始化完成以后，系统检测到的网络设备将自动地保存在这张链表中，其中每一个链表单元表示一个存在的物理网络设备。当要发送数据时，网络子系统将根据系统路由表选择相应的网络接口进行数据传输，而当接收到数据包时，通过驱动程序登记的中断服务程序进行数据的接收处理。
网络设备工作原理图：
[align=center][/align]

每一个具体的网络接口都应该有一个名字，以在系统中能唯一标识一个网络接口。通常一个名字仅表明该接口的类型。Linux对网络设备命名有以下约定：(其中N为一个非负整数)
ethN 以太网接口，包括10Mbps和100Mbps，对应到代码里的字符串“eth%d”；
trN 令牌环接口；
slN SLIP网络接口；
pppN PPP网络接口，包括同步和异步；
plipN PLIP网络接口，其中N与打印端口号相同；
tunlN IPIP压缩频道网络接口；
nrN NetROM虚拟设备接口；
isdnN ISDN网络接口；
dummyN 空设备；
lo 回送网络接口。

二. struct device

这里是我从代码里拷回来的，和代码里的注释是对应的，最好和代码一起看；
/* from include/linux/netdevice.h */
struct device [/b]
{

1. 属性

char *name;
设备的名字。如果第一字符为NULL（即’\0’），register_netdev [/i](drivers/net/net_init.c)将会赋给它一个n最小的可用网络设备名eth[/b]n。

unsigned long rmem_end; /* shmem "recv" end */
unsigned long rmem_start; /* shmem "recv" start */
unsigned long mem_end; /* shared mem end */
unsigned long mem_start; /* shared mem start */
这些域段标识被设备使用的共享内存的首地址及尾地址。如果设备用来接收和发送的内存块不同，则mem域段用来标识发送的内存位置，rmem用来标识接收的内存位置。mem_start和mem_end可在系统启动时用内核的命令行指定，用ifconfig[/i]可以查看它们的值。rmem域段从来不被驱动程序以外的程序所引用。

unsigned long base_addr; /* device I/O address */
unsigned char irq; /* device IRQ number */
I/O基地址和中断号。它们都是在设备检测期间被赋值的，但也可以在系统启动时指定传入（如传给LILO）。ifconfig命令可显示及修改他们的当前值。

volatile unsigned char start； /* start an operation */
volatile unsigned char interrupt; /* interrupt arrived */
这是两个二值的低层状态标志。通常在设备打开时置start标志，在设备关闭时清start标志。当interrupt置位时，表示有一个中断已到达且正在进行中断服务程序理。

unsigned long tbusy; /* transmitter busy must be long for bitops */
标识“发送忙”。在驱动程序不能接受一个新的需传输的包时，该域段应该为非零。

struct device *next;
指向下一个网络设备，用于维护链表。

unsigned char if_port;
记录哪个硬件I/O端口正在被接口所用，如BNC，AUI，TP等（drivers/net/de4x5.h）。
unsigned char dma;
设备用的DMA通道。
一些设备可能需要以上两个域段，但非必需的。

unsigned long trans_start; /* Time (in jiffies) of last Tx */
上次传输的时间点（in jiffies）
unsigned long last_rx; /* Time of last Rx */
上次接收的时间点（in jiffies）。如trans_start可用来帮助内核检测数据传输的死锁（lockup）。

unsigned short flags; /* interface flags (BSD) */
该域描述了网络设备的能力和特性。它包括以下flags：（include/linux/if.h）
IFF_UP
表示接口在运行中。当接口被激活时，内核将置该标志位。
IFF_BROADCAST
表示设备中的广播地址时有效的。以太网支持广播。
IFF_DEBUG
调试模式，表示设备调试打开。当想控制printk及其他一些基于调试目的的信息显示时，可利用这个标志位。虽然当前没有正式的驱动程序使用它，但它可以在程序中通过ioctl来设置从而使用它。
IFF_LOOPBACK
表示这是一个回送（loopback）设备，回送接口应该置该标志位。核心是通过检查此标志位来判断设备是否是回送设备的，而不是看设备的名字是否是lo。
IFF_POINTTOPOINT
表示这是一个点对点链接（SLIP and PPP），点对点接口必须置该标志位。Ifconfig也可以置此标志位及清除它。若置上该标志位，则dev->dstaddr应也相应的置为链接对方的地址。
IFF_MASTER /* master of a load balancer */
IFF_SLAVE /* slave of a load balancer */
此两个标志位在装入平等化中要用到。
IFF_NOARP
表示不支持ARP协议。通常的网络接口能传输ARP包，如果想让接口不执行ARP，可置上该标志位。如点对点接口不需要运行ARP。
IFF_PROMISC
全局接受模式。在该模式下，设备将接受所有的包，而不关这些包是发给谁的。在缺省情况下，以太网接口会使用硬件过滤，以保证只接受广播包及发给本网络接口的包。Sniff的原理就是通过设置网络接口为全局接受模式，接受所有到达本接口媒介的包，来“偷听”本子网的“秘密”。
IFF_MULTICAST
能接收多点传送的IP包，具有多点传输的能力。ether_setup缺省是置该标志位的，故若不想支持多点传送，必须在初始化时清除该标志位。
IFF_ALLMULTI
接收所有多点传送的IP包。
IFF_NOTRAILERS /*无网络TRAILER*/
IFF_RUNNING /*资源被分配*/

unsigned short family; /* address family ID (AF_INET) */
该域段标识本设备支持的协议地址簇。大部分为AF_INET（英特网IP协议），接口通常不需要用这个域段或赋值给它。

unsigned short metric; /* routing metric (not used) */
unsigned short mtu;
不包括数据链路层帧首帧尾的最大传输单位（Maximum Transfer Unit）。网络层在包传输时要用到。对以太网而言，该域段为1500，不包括MAC帧的帧首和帧尾（MAC帧格式稍后所示）。

unsigned short type; /* interface hardware type */
接口的硬件类型，描述了与该网络接口绑在一起的媒介类型。Linux网络设备支持许多不同种类的媒介，如以太网，X.25，令牌环，SLIP，PPP，Apple Localtalk等。ARP在判定接口支持哪种类型的物理地址时要用到该域段。若是以太网接口，则在ether_setup中将之设为ARPHRD_ETHER（Ethernet 10Mbps）。

unsigned short hard_header_len; /* hardware hdr length */
在被传送的包中IP头之前的字节数。对于以太网接口，该域段为14（ETH_HLEN，include\linux\if_ether.h），这个值可由MAC帧的格式得出：
MAC[/b]帧格式：[/b]
目的地址（6字节）+ 源地址（6字节）+ 数据长度（2字节）+ 数据（46~~1500）+FCS

void *priv; /* pointer to private data */
该指针指向私有数据，通常该数据结构中包括struct enet_statistics。类似于struct file的private_data指针，但priv指针是在设备初始化时被分配内存空间的（而不是在设备打开时），因为该指针指向的内容包括设备接口的统计数据，而这些数据即使在接口卸下（down）时也应可以得到的，如用户通过ifconfig查看。

unsigned char pad; /* make dev_addr aligned to 8 bytes */
unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */
广播地址由六个0xff构成，即表示255.255.255.255。
memset(dev->broadcast,0xFF, ETH_ALEN); （drivers/net/net_init.c）

unsigned char dev_addr[MAX_ADDR_LEN]; /* hw address */
设备的物理地址。当包传送给驱动程序传输时，要用物理地址来产生正确的帧首。

unsigned char addr_len; /* hardware address length */
物理地址的长度。以太网网卡的物理地址为6字节（ETH_ALEN）。

unsigned long pa_addr; /* protocol address */
unsigned long pa_brdaddr; /* protocol broadcast addr */
unsigned long pa_mask; /* protocol netmask */
该三个域段分别描述接口的协议地址、协议广播地址和协议的网络掩码。若dev->family为AF_INET，则它们即为IP地址。这些域段可用ifconfig赋值。

unsigned short pa_alen; /* protocol address length */
协议地址的长度。AF_INET的为4。

unsigned long pa_dstaddr; /* protocol P-P other side addr */
点对点协议接口（如SLIP、PPP）用这个域记录连接另一边的IP值。

struct dev_mc_list *mc_list; /* Multicast mac addresses */
int mc_count; /* Number of installed mcasts */
struct ip_mc_list *ip_mc_list; /* IP multicast filter chain */
这三个域段用于处理多点传输。其中mc_count表示mc_list中的项目数。

__u32 tx_queue_len; /* Max frames per queue allowed */
一个设备的传输队列能容纳的最大的帧数。对以太网，缺省为100；而plip则为节省系统资源，仅设为10。

/* For load balancing driver pair support */
unsigned long pkt_queue; /* Packets queued */
struct device *slave; /* Slave device */
struct net_alias_info *alias_info; /* main dev alias info */
struct net_alias *my_alias; /* alias devs */

struct sk_buff_head buffs[DEV_NUMBUFFS];
指向网络接口缓冲区的指针。

2. 结构中指向函数的指针，用来作为服务操作

网络接口操作可以分为两部分，一部分为基本操作，即每个网络接口都必须有的操作；另一部分是可选操作。

/* 基本操作 */
int (*init) (struct device *dev); /* Called only once. */
初始化函数的指针，仅被调用一次。当登记一个设备时，核心一般会让驱动程序初始化该设备。初始化函数功能包括以下内容：检测设备是否存在；自动检测该设备的I/O端口和中断号；填写该设备device结构的大部分域段；用kmalloc分配所需的内存空间等。若初始化失败，该设备的device结构就不会被链接到全局的网络设备表上。在系统启动时，每个驱动程序都试图登记自己，当只有那些实际存在的设备才会登记成功。这与用主设备号及次设备号索引的字符设备和块设备不同。

int (*open) (struct device *dev);
打开网络接口。每当接口被ifconfig激活时，网络接口都要被打开。Open操作做以下工作：登记一些需要的系统资源，如IRQ、DMA、I/O端口等；打开硬件；将module使用计数器加一。

int (*stop) (struct device *dev);
停止网络接口。操作内容与open相逆。

int (*hard_start_xmit) (struct sk_buff *skb, struct device *dev);
硬件开始传输。这个操作请求对一个包的传输，这个包原保存在一个socket缓冲区结构中（sk_buff）。

int (*hard_header) (struct sk_buff *skb, struct device *dev, unsigned short type,
void *daddr, void *saddr, unsigned len);
这个函数可根据先前得到的源物理地址和目的物理地址建立硬件头（hardware header）。以太网接口的缺省函数是eth_header。

int (*rebuild_header)(void *eth, struct device *dev, unsigned long raddr, struct sk_buff *skb);
在一个包被发送之前重建硬件头。对于以太网设备，若有未知的信息，缺省函数将使用ARP填写。

struct enet_statistics* (*get_stats)(struct device *dev);
当一个应用程序需要知道网络接口的一些统计数据时，可调用该函数，如ifconfig、netstat等。

/* 可选操作 */
void (*set_multicast_list)(struct device *dev);
设置多点传输的地址链表（*mc_list）。

int (*set_mac_address)(struct device *dev, void *addr);
改变硬件的物理地址。如果网络接口支持改变它的硬件物理地址，就可用这个操作。许多硬件不支持该功能。

int (*do_ioctl)(struct device *dev, struct ifreq *ifr, int cmd);
执行依赖接口的ioctl命令。

int (*set_config)(struct device *dev, struct ifmap *map);
改变接口配置。设备的I/O地址和中断号可以通过该函数进行实时修改。

void (*header_cache_bind)(struct hh_cache **hhp, struct device *dev,
unsigned short htype, __u32 daddr);
void (*header_cache_update)(struct hh_cache *hh, struct device *dev, unsigned char * haddr);

int (*change_mtu) (struct device *dev, int new_mtu);
这个函数负责使接口MTU改变后生效。如果当MTU改变时驱动程序要作一些特殊的事情，就应该写这个函数。

struct iw_statistics* (*get_wireless_stats) (struct device *dev);
};

三. 网卡的初始化

网络设备的初始化主要工作是检测设备的存在、初始化设备的device结构及在系统中登记该设备。系统内核中存在着一张网络接口管理表dev_base，但与dev_base是指向device结构的，因为网络设备是通过device数据结构来表示的。
dev_base实际上是一条device结构链表的表头，在系统初始化完成以后，系统检测到的网络设备将自动地保存在这张链表中，其中每一个链表单元表示一个存在的物理网络设备。登记成功的网络设备必定可在dev_base链表中找到。

网络设备的初始化从触发角度看可分为两类：
一类是由shell命令insmod触发的模块化驱动程序（module），只有模块化的网络设备驱动程序才能用这种方式对设备进行初始化，称为“模块初始化模式”；
另一类是系统驱动时由核心自动检测网络设备并进行初始化，我们称为“启动初始化模式”。

1. “模块初始化模式”的分析

insmod命令将调用相应模块的init_module（），装载模块。init_module函数在初始化dev->init函数指针后，将调用register_netdev（）在系统登记该设备。
若登记成功，则模块装载成功，否则返回出错信息。
register_netdev首先检查设备名是否已确定，若没赋值则给它一个缺省的值ethN，N为最小的可用以太网设备号注；
然后，网络设备自己的init_function，即刚在init_module中赋值的dev->init，将被调用，用来实现对网络接口的实际的初始化工作。
若初始化成功，则将该网络接口加到网络设备管理表dev_base的尾部。

NE2000网卡为例。NE2000网卡的主要驱动程序在文件drivers/net/ne.c中。

init_module

init_module---模块初始化函数，当装载模块时，核心将自动调用该函数。在次此函数中一般处理以下内容：
1．处理用户可能传入的参数name、ports及irq的值。若有，则赋给相应的接口

2．对dev->init函数指针进行赋值，对于任何网络设备这一步必不可少！因为在register_netdev中要用到该函数指针；
3．调用register_netdev，完成检测、初始化及设备登记等工作。

/* from drivers/net/ne.c */
init_module[/b](void)
{
int this_dev, found = 0;

/* 对所有可能存在的以太网接口进行检测并试图去登记，MAX_NE_CARDS为4，
* 即最多可以使用4块NE2000兼容网卡。 */
for (this_dev = 0; this_dev < MAX_NE_CARDS; this_dev++) {
struct device *dev = &dev_ne[this_dev];
/* 可能有用户传入的参数：指定的name、ports及irq的值 */
dev->name = namelist+(NAMELEN*this_dev);
dev->irq = irq[this_dev];
dev->base_addr = io[this_dev];
dev->init = ne_probe; /* NE2000的检测和初始化函数 */
dev->mem_end = bad[this_dev];
if (register_netdev(dev) == 0) { /* 试图登记该设备 */
found++;
continue; /* 设备登记成功，继续登记下一个设备 */
}
/* 第一次发生登记不成功事件 */
if (found != 0) /* 在这之前没有成功登记NE2000接口，返回 */
return 0;
/* 显示出错信息 */
if (io[this_dev] != 0)
printk(KERN_WARNING "ne.c: No NE*000 card found at i/o = %#x\n", io[this_dev]);
else
printk(KERN_NOTICE "ne.c: No PCI cards found. Use \"io=0xNNN\" value(s) for

…………

register_netdev

该函数实现对网络接口的登记功能。其实现步骤如下：
1．首先检查设备名是否已确定，若没赋值则以以太网设备待之并给它一个缺省的值ethN，N为最小的可用以太网设备号；
2．然后，网络设备自己的init_function，即刚在init_module中赋值的dev->init，将被调用，用来实现对网络接口的实际的初始化工作。
3．若初始化成功，则将该网络接口加到网络设备管理表dev_base的尾部

/* from drivers/net/net_init.c */
int register_netdev[/b](struct device *dev)
{
struct device *d = dev_base; /* 取得网络设备管理表的表头指针 */
…………
if (dev && dev->init) {
/*若设备名字没确定，则将之看作是以太网设备！！*/
if (dev->name &&
((dev->name[0] == '\0') || (dev->name[0] == ' '))) {
/* 找到下一个最小的空闲可用以太网设备名字 */
for (i = 0; i < MAX_ETH_CARDS; ++i)
if (ethdev_index == NULL) {
sprintf(dev->name, "eth%d", i);
printk("loading device '%s'...\n", dev->name);
ethdev_index[i] = dev;
break;
}
}
…………
/* 调用初始化函数进行设备的初始化 */
if (dev->init(dev) != 0) {
…………
/* 将设备加到网络设备管理表中，加在最后 */
if (dev_base) {
/* 找到链表尾部 */
while (d->next)
d = d->next;
d->next = dev;
}
else
dev_base = dev;
dev->next = NULL;
…………

init_function

函数原型：int init_function (struct device *dev);
当系统登记一个网络设备时，核心一般会请求该设备的驱动程序初始化自己。初始化函数功能包括以下内容：
1.检测设备是否存在，一般和第二步一起作；
2.自动检测该设备的I/O地址和中断号；
对于可以与其他共享中断号的设备，我们应尽量避免在初始化函数中登记I/O地址和中断号，I/O地址和中断号的登记最好在设备被打开的时候，因为中断号有可能被其他设备所共享。若不准备和其他设备共享，则可在此调用request_irq和request_region马上向系统登记。
3.填写传入的该设备device结构的大部分域段；
对于以太网接口，device[/i]结构中许多有关网络接口信息都是通过调用ether_setup函数（driver/net/net_init.c）统一来设置的，因为以太网卡有很好的共性。对于非以太网接口，也有一些类似于ether_setup的函数，如tr_setup（令牌网），fddi_setup。若添加的网络设备都不属于这些类型，就需要自己填写device[/i]结构的各个分量。
4.kmalloc需要的内存空间。

若初始化失败，该设备的device[/i]结构就不会被链接到全局的网络设备表上。在系统启动时，每个驱动程序都试图登记自己，当只有那些实际存在的设备才会登记成功。这与用主设备号及次设备号索引的字符设备和块设备不同。

在胶片的代码里物理设备NE2000网卡的初始化函数是由ne_probe和ne_probe1及ethdev_init共同实现。

/* from drivers/net/ne.c */
int ne_probe[/b](struct device *dev)
{
…………
int base_addr = dev ? dev->base_addr : 0;
/* I/O地址. User knows best. <cough> */
if (base_addr > 0x1ff) /* I/O地址有指定值 */
return ne_probe1[/b](dev, base_addr); /* 这个函数在下面分析 */
else if (base_addr != 0) /* 不自动检测I/O */
return ENXIO;
…………
/* base_addr=0，自动检测，若有第二块ISA网卡则是一个冒险！J
* 对所有NE2000可能的I/O地址都进行检测，可能的I/O地址在存在
* netcard_portlist数组中：
* static unsigned int netcard_portlist[]={ 0x300, 0x280, 0x320, 0x340, 0x360, 0};
*/
for (i = 0; netcard_portlist; i++) {
int ioaddr = netcard_portlist[i];
if (check_region(ioaddr, NE_IO_EXTENT))
continue;
/* 检测到一个I/O端口地址 */
if (ne_probe1(dev, ioaddr) == 0)
return 0;
…………

/* from drivers/net/ne.c */
static int ne_probe1[/b](struct device *dev, int ioaddr)
{
…………
/* 检测、确认I/O地址；初始化8390 */
…………
/* 自动检测中断号，非常巧妙！！ */
if (dev->irq < 2) {
autoirq_setup(0); /* 自动检测准备 */
outb_p(0x50, ioaddr + EN0_IMR); /* 中断使能 */
outb_p(0x00, ioaddr + EN0_RCNTLO);
outb_p(0x00, ioaddr + EN0_RCNTHI);
outb_p(E8390_RREAD+E8390_START, ioaddr); /* 触发中断 */
outb_p(0x00, ioaddr + EN0_IMR); /* 屏蔽中断 */
dev->irq = autoirq_report(0); /* 获得刚才产生的中断号 */
…………
…………
/* 登记中断号，中断服务程序为ei_interrupt。
* 因为ISA网卡不能和其他设备共享中断。*/
int irqval = request_irq(dev->irq, ei_interrupt,
pci_irq_line ? SA_SHIRQ : 0, name, dev);
if (irqval) {
printk (" unable to get IRQ %d (irqval=%d).\n", dev->irq, irqval);
return EAGAIN;
}
dev->base_addr = ioaddr; /* 设置I/O地址——已经过确认 */

/* 调用ethdev_init初始化dev结构 */
if (ethdev_init(dev)[/b]) { /* 该函数下面将分析 */
printk (" unable to get memory for dev->priv.\n");
free_irq(dev->irq, NULL); /* 初始化不成功，释放登记的中断号！ */
return -ENOMEM;
}
/* 向系统登记I/O地址 */
request_region(ioaddr, NE_IO_EXTENT, name);
/* 将硬件的物理地址赋给dev->dev_add */
for(i = 0; i < ETHER_ADDR_LEN; i++) {
printk(" %2.2x", SA_prom[i]);
dev->dev_addr[i] = SA_prom[i];
}
printk("\n%s: %s found at %#x, using IRQ %d.\n",
dev->name, name, ioaddr, dev->irq);
…………
/* 向dev结构登记设备打开和关闭函数 */
dev->open = &ne_open;
dev->stop = &ne_close;
…………

/* from drivers/net/8390.c */
int ethdev_init[/b](struct device *dev)
{
…………
if (dev->priv == NULL) {
struct ei_device *ei_local;
/* 申请私有数据结构空间，用于记录设备的状态等 */
dev->priv = kmalloc(sizeof(struct ei_device), GFP_KERNEL);
…………
dev->hard_start_xmit = &ei_start_xmit;
dev->get_stats = get_stats;
dev->set_multicast_list = &set_multicast_list;
ether_setup(dev);
…………

ether_setup

ether_setup是一个通用于以太网接口的网络接口设置函数。所有的以太网卡的device结构中许多有关的网络接口信息都是通过调用[/b]ether_setup[/b]函数统一来[/b]设置。

/* from drivers/net/net_init.c */
void ether_setup[/b](struct device *dev)
{
int i;
/* 初始化缓冲队列链表，这是一个双向链表 */
for (i = 0; i < DEV_NUMBUFFS; i++) /* DEV_NUMBUFFS=3 */
skb_queue_head_init(&dev->buffs);
…………
/* 一些处理函数的初始化，驱动程序可以不写这些函数了 */
dev->change_mtu= eth_change_mtu;
dev->hard_header= eth_header;
dev->rebuild_header = eth_rebuild_header;
dev->set_mac_address = eth_mac_addr;
dev->header_cache_bind = eth_header_cache_bind;
dev->header_cache_update= eth_header_cache_update;

dev->type = ARPHRD_ETHER; /* Ethernet 10Mbps */
dev->hard_header_len= ETH_HLEN; /* MAC层协议头的大小 14 */
dev->mtu = 1500; /* 最大传输单位 */
dev->addr_len = ETH_ALEN; /* 协议地址长度 4 */
dev->tx_queue_len = 100; /* 传输队列的长度 */
memset(dev->broadcast,0xFF, ETH_ALEN);/* 物理地址长度 6 */

/* 广播地址有效及支持多点传输 */
dev->flags = IFF_BROADCAST|IFF_MULTICAST;
dev->family = AF_INET; /* 英特网IP协议簇 */
dev->pa_addr = 0; /* 以后用ifconfig命令设置 */
dev->pa_brdaddr= 0; /* 以后用ifconfig命令设置 */
dev->pa_mask = 0; /* 以后用ifconfig命令设置 */
dev->pa_alen = 4; /* 协议地址长度 4 */
}

2. “启动初始化模式”的分析

初始化策略

“启动初始化模式”与“模块初始化模式”不同，前者要对所有内核支持的网络设备进行检测和初始化，而后者仅需检测和初始化被装载模块的网络设备。
为了实现在启动时对所有可能存在的设备进行初始化，系统在启动之前将所有内核支持的网络设备的名字及相应的初始化函数都挂在网络设备管理表（dev_base）上。
启动后，net_dev_int（）将依次对网络设备管理表dev_base中的每个设备，调用该设备本身的init_function进行初始化。
若init_function失败，即该设备不存在或I/O、IRQ不能获得，则将该设备从dev_base去掉。
最后网络设备管理表中剩下的网络接口都是存在的，而且是被初始化过的。



/* 网络设备管理表的初始化 */
/* from drivers/net/Space.c */
…………
static struct device eth7_dev = {
"eth7", 0,0,0,0,0xffe0 /* I/O base*/, 0,0,0,0, NEXT_DEV, ethif_probe };
static struct device eth6_dev = {
"eth6", 0,0,0,0,0xffe0 /* I/O base*/, 0,0,0,0, ð7_dev, ethif_probe };
…………
static struct device eth0_dev = {
"eth0", 0, 0, 0, 0, ETH0_ADDR, ETH0_IRQ, 0, 0, 0, ð1_dev, ethif_probe };
/* 在八个eth接口中，只有eth0将I/O设为0，让其进行自动检测，其他
* eth接口的I/O都设为0xffe0，不进行检测。Linux缺省的内核在启动时
* 只能自动检测到一块eth网卡，就是这个原因 */

# undef NEXT_DEV
# define NEXT_DEV (ð0_dev)
#if defined(PLIP) || defined(CONFIG_PLIP)
extern int plip_init(struct device *);
static struct device plip2_dev = {
"plip2", 0, 0, 0, 0, 0x278, 2, 0, 0, 0, NEXT_DEV, plip_init, };
…………
static struct device plip0_dev = {
"plip0", 0, 0, 0, 0, 0x3BC, 5, 0, 0, 0, &plip1_dev, plip_init, };
…………
extern int loopback_init(struct device *dev);
struct device loopback_dev = {
"lo", 0x0, 0x0, 0x0, 0x0, 0, 0, 0, 0, 0, NEXT_DEV, loopback_init };[/b]
struct device dev_base = &loopback_dev; /* [/b]关键 */[/b]

函数调用关系

系统转入核心后，start_kernel将会创建一个init进程，该init进程则会通过系统调用sys_steup进行所有尚未初始化的设备。D
evice_setup不仅要初始化内核支持的字符设备、块设备，也调用net_dev_init初始化所有内核支持的且实际存在的网络设备。
net_dev_init会对每个内核支持的网络设备调用该设备的init_functions进行具体的物理设备的初始化工作。整个函数调用关系图如下：

具体流程

LINUX启动时，完成了实模式下的系统初始化（arch/i386/boot/setup.S）与保护模式下的核心初始化包括初始化寄存器和数据区(arch/i386/boot/compressed/head.S)、核心代码解压缩、页表初始化（arch/i386/kernel/head.S）、初始化idt、gdt和ldt等工作后，系统转入了核心。调用函数start_kernel启动核心（init/main.c）后，将继续各方面的初始化工作，其中与网络子系统有关的部分为：调用sock_init()（net/socket.c）初始化网络模块。
sock_init（）函数主要做以下动作：
① 初始状态设为不支持任何网络协议：
static struct proto_ops *pops[NPROTO]; // #define NPROTO 16
……
for (i = 0; i < NPROTO; ++i) pops[i] = NULL;
② 调用init_netlink()[/b]，[/b]登记一个网络字符设备（即把netlink看作一种字符设备），主设备号为NETLINK_MAJOR(36)： （net/netlink.c）
register_chrdev(NETLINK_MAJOR,"netlink", &netlink_fops);
for(ct=0;ct<MAX_LINKS;ct++){
skb_queue_head_init(&skb_queue_rd[ct]);
netlink_handler[ct]=netlink_err;
}
其中static int (*netlink_handler[MAX_LINKS])(struct sk_buff *skb)；MAX_LINKS为次设备数，定义为11。
③ 调用netlink_attach()[/b]，在netlink_handler登记路由设备的回调函数：（net/netlink.c）
netlink_attach(NETLINK_ROUTE, netlink_donothing);
其中netlink_attach为：{
active_map|=(1<<unit);
netlink_handler[unit]=function;}
④ 调用fwchain_init()[/b]，初始化防火墙，设为FW_ACCEPT。
⑤ 调用proto_init()[/b]，执行核心支持的各种网络协议的初始化函数：
void proto_init(void){
/* 核心支持的网络协议在net/protocols.c中定义 */
extern struct net_proto protocols[];
struct net_proto *pro;
pro = protocols;
while (pro->name != NULL) {
(*pro->init_func)(pro);
pro++;
}
}
⑥ 调用export_net_symbols()[/b]，向系统登记发布network symbols，以供系统的模块（modules）使用，因为module中的函数所调用的外部函数只能是已分布登记（export）的函数：
/* from net/netsyms.c */
void export_net_symbols(void)
{
/* 该函数为宏，定义在（include/linux/module.h）*/
register_symtab(&net_syms);
}
其中net_syms静态结构变量初始化为：（net/netsyms.c）
static struct symbol_table net_syms = {
#include <linux/symtab_begin.h>

/* Socket layer registration */
X(sock_register),
X(sock_unregister),
X(sock_alloc),
X(sock_release),
…………
…………
#include <linux/symtab_end.h>
};
网络协议的初始化竟是在网络设备的初始化之前！
start_kernel最后将调用kernel_thread[/b] (init, NULL, 0)，创建init进程进行系统配置（其中包括所有设备的初始化工作）。

/* from init/main.c */
static int init[/b](void * unused)
{
…………
/* 创建后台进程bdflush，以不断循环写出文件系统缓冲区中“脏”的内容 */
kernel_thread[/b](bdflush, NULL, 0);
/* 创建后台进程kswapd，专门处理页面换出工作 */
kswapd_setup();[/b]
kernel_thread(kswapd, NULL, 0);[/b]
…………
/ *
* [/b]该setup() [/b]函数即系统调用sys_setup()[/b]
* 关于这一点，作者已作过以下试验：在setup()调用以前和调用之后，
* 以及在sys_setup()函数内部的开始和结束加入printk语句（以使系统
* 启动时能输出信息）后，重新编译内核。发现用新的内核后，通过
* 启动时的信息显示，发现setup()函数的确就是系统调用sys_setup()。
*
*/
setup()[/b];
…………
}

sys_setup[/b]函数[/b]调用device_setup对所有的设备进行初始化工作。
/* from fs/filesystems.c */
asmlinkage int sys_setup[/b](void)
{
static int callable = 1;
if (!callable)
return -1;
callable = 0; /* 通过静态变量，限制该函数最多只能被调用一次 */

device_setup();[/b] /* 调用device_setup()，初始化所有设备 */
…………
}
在device_setup中将对字符设备、块设备、网络设备、SCSI设备等进行初始化
/* from drivers/block/genhd.c */
void device_setup(void) {
…………
chr_dev_init(); /* 字符设备的初始化 drivers/cha/mem.c */
blk_dev_init(); /* 块设备的初始化 drivers/block/ll_rw_blk.c */
sti();
#ifdef CONFIG_SCSI
scsi_dev_init(); /* SCSI设备的初始化 drivers/scsi/scsi.c */
#endif
#ifdef CONFIG_INET
net_dev_init(); /* 网络设备的初始化 net/core/dev.c */
#endif
…………
}

/* from net/core/dev.c */
int net_dev_init[/b](void) {
…………
/* 初始化数据包接收队列 */
skb_queue_head_init(&backlog);
/* 网桥必须在其他设备之前初始化 */
#ifdef CONFIG_BRIDGE
br_init();
#endif
…………
/* 以下进行网络设备初始化检测，如果dev->init初始化失败（大多数是
* 因为设备不存在），则从网络设备链dev_base上除去该设备。*/

/* dev_base是drivers/net/Space.c中的一个指向device结构的静态指针变量，
* 并已初始化为核心支持的所有网络设备的链表，其中包括每个设备的probe
* 函数指针。 */
dp = &dev_base;
while ((dev = *dp) != NULL)
{
int i;
for (i = 0; i < DEV_NUMBUFFS; i++) { /* #define DEV_NUMBUFFS 3 */
skb_queue_head_init(dev->buffs + i);
}
if (dev->init && dev->init(dev))
/* 初始化失败，将该设备从链表中删除，并准备初始化下一个 */
*dp = dev->next;
else
dp = &dev->next; /* 成功，准备初始化下一个 */
}
…………

四. 网络设备的打开和关闭

使用网络设备，激活（打开）初始化好了的接口。打开和关闭一个接口是由shell命令ifconfig[/i]调用的，而ifconfig[/i] 则要调用一个通用的设备打开函数dev_open[/b]（net/core/dev.c），相应地还有一个dev_close[/b]函数。这两个函数提供了独立于设备的操作接口的打开和关闭的功能。
需要调用网络接口dev的open、stop函数，同时它们还需置上dev->flags的IFF_UP标志。

/* from net/core/dev.c */
int dev_open[/b](struct device *dev)
{
int ret = -ENODEV;
if (dev->open)
ret = dev->open[/b](dev); /* 调用接口的open函数 */
if (ret == 0) /* 接口打开成功 */
{
dev->flags |= (IFF_UP | IFF_RUNNING); /* 置标志位 */
/*初始化有关多点传输的一些状态 */
dev_mc_upload(dev);
notifier_call_chain(&netdev_chain, NETDEV_UP, dev);
}
return(ret);
}

对于网络接口自己的dev->open函数一般包括以下几方面内容：
1． 若没有在初始化函数中登记中断号和I/O地址，则在设备打开时要进行登记分别用request_irq request_region这两个函数进行登记。
2． 若要分配DMA通道，则用request_dma进行分配登记；
3． 将该设备挂到irq2dev_map中。若是使用基于中断的接收数据方式，以后就可以通过中断号直接索引到相应的设备了；
4． 初始化物理设备的寄存器的状态；
5． 设置接口相应dev的私有数据结构(dev->priv)中的一些域段；
6． 设置dev中的tbusy、interrupt、start等域段；
7． 在返回之前嵌入宏MOD_INC_USE_COUNT。
dev->stop函数则相反，如第六步要改为MOD_DEC_USE_COUNT。
我们看NE2000， NE2000的dev->open和dev->stop分别对应ne_open和ne_close。由于NE2000驱动程序是在初始化就登记IRQ和I/O地址的，在这里就不需要登记了。
/* from drivers/net/ne.c */
static int ne_open[/b](struct device *dev)
{
ei_open(dev); /* 下面将分析 */
MOD_INC_USE_COUNT; /* 对应于第7项内容 */
return 0;
}
static int ne_close[/b](struct device *dev)
{
if (ei_debug > 1)
printk("%s: Shutting down ethercard.\n", dev->name);
ei_close(dev); /* 下面将分析 */
MOD_DEC_USE_COUNT; /* 对应于第7项内容 */
return 0;
}

/* from drivers/net/8390.c */
int ei_open(struct device *dev)
{
struct ei_device *ei_local = (struct ei_device *) dev->priv;
if (ei_local == NULL){ /* 只有没调用ethdev_init()，才会出现以下的错误 */
printk(KERN_EMERG "%s: ei_open passed a non-existent device!\n", dev->name);
return -ENXIO;
}
irq2dev_map[dev->irq] = dev; /* 对应于上面所列内容的第3项 */
NS8390_init[/b](dev, 1); /* 下面将分析 */
dev->start = 1; /* 对应于第6项，表示接口UP */
ei_local->irqlock = 0; /* 对应于第5项 */
return 0;
}
int ei_close[/b](struct device *dev)
{
NS8390_init(dev, 0);
dev->start = 0; /* 对应于第6项内容，表示接口DOWN */
return 0;
}

void NS8390_init[/b](struct device *dev, int startp)
{
…………
/* 设置8390的各种寄存器的状态 */
…………
dev->tbusy = 0;
dev->interrupt = 0; /* 对应于第6项内容 */
ei_local->tx1 = ei_local->tx2 = 0;
ei_local->txing = 0; /* 对应于第5项内容 */
…………
}

另外，文件net/core/dev.c还提供独立于具体网络设备的操作函数，如
dev_ifsioc[/b](void *arg, unsigned int getset)
它可以处理许多ioctl SIGNAL：读取和修改接口网络地址（对TCP/IP就是IP地址）、读取和修改接口的dev->flags、读取和设置MTU、读取和设置广播地址等等。

五. 数据包的传输和接收

当物理网络设备接收到数据时，可通过两种途径解决这个问题。
一种方法是轮询方式[/b]，系统每隔一定的时间间隔就去检查一次物理设备，若设备“报告”说有数据到达，就调用读取数据的程序。在Linux中，轮询方式可通过定时器实现，但该方法存在一个明显的缺点：不管设备是否有数据，系统总是要固定地花CPU时间去查看设备，且可能延迟对一些紧急数据的处理，因为网络设备有数据时可能不能马上得到CPU的响应。在这种方式下，设备完全处于一种被动的状态，而CPU又负担过重。无论从资源的利用率上还是从效率上看，这种方法都不是最优的。
另一种方法是中断方式[/b]，中断方式利用硬件体系结构的中断机制实现设备和系统的应答对话，即当物理设备需要CPU处理数据时，设备就发一个中断信号给系统，系统则在收到信号后调用相应的中断服务程序响应对设备中断的处理。中断方式有效地解决了设备与CPU的对话交流问题，并将CPU从繁重的设备轮询中解脱出来，大大提高了CPU的利用率。当前不管是Linux平台还是Windows平台，它们的网络设备驱动程序几乎都是使用中断方式的。
网络分层有一个问题是，每层的协议在发送数据包时要加协议头和协议尾到原数据中，在收到数据包时则要将本层的协议头和协议尾从数据包中去掉。这使得在不同层协议间传输时，每层都需要知道自己这一层的协议头和协议尾在数据包的哪里。
一种解决方法是在每层都复制缓冲区，但显然效率太低。
Linux的做法是用一种数据结构[/b]sk_buf[/i][/b]f[/i]在不同协议层及网络设备驱动程序之间传送数据。sk_buff [/b]包括指针和长度域段，允许每个协议层通过标准的函数操作传送的数据包。
首先来分析sk_buff这个数据结构。

1. Socket缓冲区及相关操作

网络设备发送与接收数据包用的缓冲区是一个统一的数据结构sk_buff [/b]（include/linux/skbuff.h）。对该数据结构，核心提供了一系列低层的操作函数，从而使该数据结构具有网络协议传输需要的通常的缓冲功能和流控制能力，并可方便、灵活地处理数据包首尾的增加和删除。

sk_buff[/i]结构的一个示意图，其中每个sk_buff[/i] 都带有一块数据区，并有四个数据指针指向相应的位置：
unsigned char *head;
指向被分配的内存空间的首地址；
unsigned char *data;
指向当前数据包的首地址；
unsigned char *tail;
指向当前数据包的末地址；
unsigned char *end;
指向被分配的内存空间的末地址；
unsigned long len;
当前数据包的大小。
len=skb->tail – skb->data；
unsigned long truesize
分配到的内存空间大小。
len=skb->end – skb->head；
由于数据包的大小会随着自己在不同协议层间的传送而会不断地变化，故data和tail指针也将会不断地改变，即依赖于skb当前所在的协议层；head和end指针则在内存空间分配后就固定不变。
对缓冲区的操作，核心提供了一个比较完整的函数界面，下面将列出用的最多的几个函数并作分析说明。
/* from net/core/skbuff.c */
struct sk_buff *alloc_skb (unsigned int len, int priority);
struct sk_buff *dev_alloc_skb (unsigned int len);
申请一个sk_buff缓冲区。alloc_skb函数分配一个缓冲区并将skb->data和skb->tail初始化为skb->head；dev_alloc_skb函数是alloc_skb函数的一个快捷方式，它用priority= GFP_ATOMIC调用alloc_skb并在skb->data和skb->head之间保留16字节的空间。这16字节也用来填写硬件头（hardware header）。
void kfree_skb (struct sk_buff *skb, int rw);
void dev_kfree_skb (struct sk_buff *skb, int rw);
释放一个sk_buff缓冲区。kfree_skb供核心内部调用，驱动程序应该用dev_kfree_skb，因为它能正确处理缓冲区加锁。参数rw可用FREE_READ或FREE_WRITE。用于发送的缓冲区应该用FREE_WRITE，用于接收的则用FREE_READ。
unsigned char *skb_put (struct sk_buff *skb, int len);
当有数据要加到缓冲区的尾部时，用于增加skb->tail和skb->len。返回值是修改之前[/b]的skb->tail指针。
unsigned char *skb_push (struct sk_buff *skb, int len);
当有数据要加到缓冲区的首部时，用于减少skb->data及增大skb->len。返回值是修改之后[/b]的skb->data。
int skb_tailroom (struct sk_buff *skb);
该函数返回在sk_buff 中可用于put的空间大小（尾部空余空间）。若缓冲区被正确分配到空间，驱动程序通常不需要检查缓冲区中空余空间的大小。由于驱动程序在申请空间之前可得到数据包的大小，故只有严重出错的驱动程序才会put太多的数据到缓冲区中。
int skb_headroom (struct sk_buff *skb);
类似于skb_tailroom，该函数返回可用的push的空间大小，即首部空余空间。
void skb_reserve (struct sk_buff *skb, int len);
该函数既增加skb->data又增加skb->tail，即在首部留出len大小的空间。在填充缓冲区之前，可用该函数保留一部分首部空间。许多以太网卡在首部保留2字节空间，这样在14字节的以太网头的后面，IP头就能以16字节对齐了。
unsigned char *skb_pull (struct sk_buff *skb, int len);
从数据包的头部剔除数据。它减少skb->len并增加skb->data。以太网的头就是这样从接收到的数据包中被剔除的。
void skb_trim(struct sk_buff *skb, int len)
从数据包的尾部剔除数据。它将skb->len设为len，并改变skb->tail。

2. 数据包的传输

用户要传输数据时，数据包是沿着网络协议由上往下逐层下传的。数据包将通过dev_queue_xmit[/b]（）[/b][net/core/dev.c]函数传送给网络接口。网络接口的任务就是将数据包传送给硬件，让物理网络设备完成最终的物理传输。从device结构中我们可以看到，每个网络接口都应有一个叫dev->hard_start_xmit[/b]的硬件传输函数指针，通过这个函数指针来完成实际的数据传输的。
硬件传输函数hard_start_xmit函数的一般流程如下：

1．通过标志位tbusy判断上次数据包的传输是否完成。若tbusy=0就做下一步；否则，看上次传输是否已超时，若未超时，就不成功返回，若已超时，则初始化芯片寄存器、置tbusy=0，然后继续下一步；
2．将tbusy标志位打开；
3．将数据包传给硬件发送；
4．释放缓冲区skb；
5．修改接口的一些统计信息。

NE2000的传输函数dev->hard_start_xmit为ei_start_xmit[/b]（）[/b]。

/* from drivers/net/8390.c drivers/net/8390.h */
/* 传输函数 */
static int ei_start_xmit[/b](struct sk_buff *skb, struct device *dev)
{
int e8390_base = dev->base_addr;
struct ei_device *ei_local = (struct ei_device *) dev->priv;
int length, send_length, output_page;

/* 若设备忙，就判断上次传输是否已超时 */
if (dev->tbusy) {
/* 读取传输状态寄存器的值 */
int txsr = inb(e8390_base+EN0_TSR), isr; /* EN0_TSR 传输状态寄存器（读）*/
int tickssofar = jiffies - dev->trans_start;

/* #define TX_TIMEOUT (20*HZ/100) */
if (tickssofar < TX_TIMEOUT || (tickssofar < (TX_TIMEOUT+5) &&
! (txsr & ENTSR_PTX))) {
return 1; /* 未超时，或超时一点点且发送时出错 */
}
/* 已超时 */
…………
/* 重新初始化芯片寄存器 */
ei_reset_8390[/b](dev);
NS8390_init([/b]dev, 1);
/* 将开始传输域段置为的当前时间坐标点 */
dev->trans_start = jiffies;
}
…………
/* 屏蔽网络设备的硬件中断 */
outb_p(0x00, e8390_base + EN0_IMR); /* EN0_IMR 中断屏蔽寄存器（WR）*/
if (dev->interrupt) {
/* 正在运行中断服务程序 */
printk("%s: Tx request while isr active.\n",dev->name);
/* 恢复中断屏蔽，失败返回； EN0_IMR 中断屏蔽寄存器（WR）*/
outb_p(ENISR_ALL, e8390_base + EN0_IMR);
return 1;
}
ei_local->irqlock = 1;
send_length = ETH_ZLEN < length ? length : ETH_ZLEN;
/* 硬件传输 */
ei_block_output(dev, length, skb->data, ei_local->tx_start_page);
ei_local->txing = 1;
NS8390_trigger_send(dev, send_length, ei_local->tx_start_page);
/* 设置开始传输时间坐标点，打开“忙”标志 */
dev->trans_start = jiffies;
dev->tbusy = 1;
…………
ei_local->irqlock = 0;
/* 恢复中断屏蔽 */
outb_p(ENISR_ALL, e8390_base + EN0_IMR);/* EN0_IMR 中断屏蔽寄存器（WR）*/
/* 释放缓冲区skb */
dev_kfree_skb (skb, FREE_WRITE);
return 0;
}

3. 数据包的接收

由于使用了硬件中断请求机制，当物理网络设备接收到新数据时，它将发送一个硬件中断请求给系统。系统在侦察到有物理设备发出中断请求，就会调用相应的中断服务程序来处理中断请求。在这里，系统首先要知道哪个中断对应哪个中断服务程序。
为了让系统知道网络设备的中断服务程序，一般在网络设备初始化的时候或设备被打开时，要向系统登记中断号及相应的中断服务程序（用[/b]request_irq[/b]这个函数登记）[/b]。
基于中断方式的设备驱动程序若在设备初始化和设备打开时都没向系统登记中断服务程序，则该设备肯定不能正常工作。
NE2000的中断号登记是在设备初始化的时候，并登记中断服务程序为ei_interrupt[/b]。
一个网络接口的中断服务程序的工作步骤一般有以下几步：

1．确定发生中断的具体网络接口，是rq2dev_map[irq]还是 (struct device*) dev_id；
2．打开标志位dev->interrupt，表示本服务程序正在被使用；
3．读取中断状态寄存器，根据寄存器判断中断发生的原因。有两种可能：一种是有新数据包到达；另一种是上次的数据传输已完成。
4．若是因为有新数据包到达，则调用接收数据包的子函数；
5．若中断由上次传输引起，则通知协议的上一层、修改接口的统计信息、关闭标志位tbusy为下次传输做准备；
6．关闭标志位interrupt。

当中断服务程序明确物理网络设备有数据包收到时，将调用数据接收子程序来完成实际的依赖于硬件的数据接收工作，并在接收完成后通过函数[/b]netif_rx[/b]（）[/b][net/core/dev.c]将收到的数据包往上层传。数据接收子程序的内容可以由以下四点来概括：

1．申请skb缓冲区给新的数据包存储；
2．从硬件中读取新到达的数据；
3．调用netif_rx（），将新的数据包往网络协议的上一层传送；
4．修改接口的统计数据。

NE2000中断服务程序ei_interrupt（），同时我们还将发现NE2000的数据接收子程序是ei_receive（）。

/* from drivers/net/8390.c drivers/net/8390.h */
/* 中断服务程序 */
void ei_interrupt([/b]int irq, void *dev_id, struct pt_regs * regs)
{
struct device *dev = (struct device *)(irq2dev_map[irq]);
…………
e8390_base = dev->base_addr;
ei_local = (struct ei_device *) dev->priv;
if (dev->interrupt || ei_local->irqlock) {
/* 有其他进程运行中断服务程序 */
return;
}
/* 打开中断处理标志，阻止再次进入 */
dev->interrupt = 1;
…………
/* 读取中断状态寄存器（RD WR）*/
while ((interrupts = inb_p(e8390_base + EN0_ISR)) != 0
&& ++nr_serviced < MAX_SERVICE) {
…………
if (interrupts & ENISR_OVER) { /* ENISR_OVER 接收overrun标志 */
/* 接收超出物理设备的承受能力 */
ei_rx_overrun([/b]dev); /* 恢复设备的正确状态 */
} else if (interrupts & (ENISR_RX+ENISR_RX_ERR)) {
/* ENISR_RX 正确接收标志；ENISR_RX_ERR 接收有错标志 */
/* 接收到数据包，包括正确接收和接收出错 */
ei_receive(dev); /* 从物理设备的缓存中取出数据 */
}
if (interrupts & ENISR_TX) {
/* 正确发送了数据包， */
ei_tx_intr(dev); /* 为下一次传输做准备 */
} else if (interrupts & ENISR_TX_ERR) {
/* 发送数据包的过程中出错 */
ei_tx_err(dev); /* 错误处理 */
}
…………
}

…………
/* 关闭中断处理标志 */
dev->interrupt = 0;
return;
}

/* 数据接收子程序，被中断服务程序所调用 */
static void ei_receive[/b](struct device *dev)
{
…………
/* 申请物理空间--skb缓冲区，为读取新的数据包作准备 */
skb = dev_alloc_skb(pkt_len+2);
…………
/* 由于MAC头是14字节的，为了与 IP头的16字节对齐规则 一致，
* 特意保留了2字节 */
skb_reserve(skb,2);
skb->dev = dev;
/* 腾出逻辑空间给新的数据包 */
skb_put(skb, pkt_len); /* Make room */
/* 从硬件中读取新到达的数据 */
ei_block_input(dev, pkt_len, skb, current_offset + sizeof(rx_frame));
skb->protocol=eth_type_trans(skb,dev);
/* 通过netif_rx函数，将收到的数据包往网络协议的上一层传送 */
netif_rx(skb)[/b];
/* 修改接口的统计数据。*/
ei_local->stat.rx_packets++;
…………
}

六. 网络设备驱动程序

网络设备（或网络接口）是通过一个数据结构struct device来表示的。在系统中，每一个实际存在[/b]的物理网络设备都对应于一个device结构。而所有这些device结构联成一张链表并由一个全局变量指针dev_base指向表头，从而使系统能够随时得到每个网络接口的信息。
一个最简单的网络设备驱动程序，应该包括：

1．该网络设备的检测及初始化函数，供核心启动初始化时调用
2．该网络设备的初始化函数，供register_netdev调用（可以写成与第1项的共用，即用同一个）；若是写成module兼容方式的，还需写该设备的init_module和cleanup_module函数；
3．提供该网络设备的打开和关闭操作。供设备被打开或被关闭时调用（一般用shell命令ifconfig调用）；
4．提供该网络设备的数据传输函数，负责向硬件发送数据包。当上层协议需要传输数据时，供dev_queue_xmit调用；
5．提供该网络设备的中断服务程序，处理数据传输完毕的善后事宜和数据的接收。当物理网络设备有新数据到达或数据传输完毕时，将向系统发送硬件中断请求，该函数就是用来响应该中断请求的。

}本文出自 “aban3rd的酒壶” 博客，谢绝转载！