一、框架模型

linux下设备驱动都有一套标准的结构，字符设备，块设备，网络设备都是自己的一套框架。编写驱动只需要把内核的框架搞清楚，然后照着结构填入参数，注册进内核，在应用层就可以按照标准的形式调用了。 对于网络设备而言，主要目的就是网络数据的收发，编写驱动时将linux网络设备驱动里的接口与实际网卡硬件的操作接口对应上，应用层就可以操作网卡完成网络通信了。底层驱动里编写网卡驱动与单片机一样。

这是网络设备驱动注册的一些函数：

动态分配空间
#define alloc_etherdev(sizeof_priv) alloc_etherdev_mq(sizeof_priv, 1)
函数参数：分配的空间大小。如果自己没有定义自己的结构体，就直接填 sizeof(struct net_device)
函数返回值：执行成功返回申请的空间地址。
空间分配的函数还有一个 alloc_netdev()函数。
alloc_etherdev()是 alloc_netdev()针对以太网的"快捷"函数


注册网络设备
int register_netdev(struct net_device *dev)
函数形参：网络设备信息 struct net_device
函数返回值：执行成功返回 0。



注册网络设备示例
static struct net_device_ops netdev_ops_test= //网络设备虚拟文件操作集合
{
 .ndo_open = test_ndo_open,
.ndo_stop = test_ndo_stop,
.ndo_start_xmit = ndo_start_xmit,
};
net = alloc_etherdev(sizeof(*net));
//网络设备的名称，使用 ifconfig -a 可以查看到。
strcpy(net->name, "eth888"); 
net->netdev_ops=&netdev_ops_test; //虚拟文件操作集合


注销网络设备
void unregister_netdev(struct net_device *dev)
功能：注销网络设备
参数：注销的网络设备结构体

当前用来测试的网卡选用ENC28J60 ，这是带有行业标准串行外设接口（Serial Peripheral Interface，SPI）的独立以太网 控制器。

可作为任何配备有 SPI 的控制器的以太网接口。ENC28J60 符合 IEEE 802.3 的全部规范，采用了一系列包过滤机制以对传入数据包进行限制。 它还提供了一个内部 DMA 模块， 以实现快速数据吞吐和硬件支持的 IP 校验和计算。 与主控制器的通信通过两个中断引脚和 SPI 实现，数据传输速率高达 10 Mb/s。两个专用的引脚用
于连接 LED，进行网络活动状态指示。

与开发板的硬件连接：

二、驱动代码

2.1 ENC28J60网卡驱动+网络设备框架+中断接收数据.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/delay.h>
#include "enc28j60.h"
#include <linux/gpio.h>
#include <mach/gpio.h>
#include <plat/gpio-cfg.h>
#include <linux/delay.h>
#include <linux/workqueue.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/timer.h>

/*
以下是ENC28J60驱动移植接口：
SPI0接口:
	GPB_0--SCK
	GPB_1--CS
	GPB_2--MISO
	GPB_3--MOSI
    GPB(4)--复位
	GPX3(2)--中断
*/
static u32 ENC28J60_IRQ; //中断编号

/*SPI底层硬件IO定义*/
#define Tiny4412_GPIO_SPI_SCK EXYNOS4_GPB(0)
#define Tiny4412_GPIO_SPI_CS EXYNOS4_GPB(1)
#define Tiny4412_GPIO_SPI_MISO EXYNOS4_GPB(2)
#define Tiny4412_GPIO_SPI_MOSI EXYNOS4_GPB(3)
#define ENC28J60_GPIO_REST EXYNOS4_GPB(4)
#define ENC28J60_IRQ_NUMBER EXYNOS4_GPX3(2)

#define ENC28J60_CS(x)	if(x){gpio_set_value(Tiny4412_GPIO_SPI_CS,1);}else{gpio_set_value(Tiny4412_GPIO_SPI_CS,0);}	//ENC28J60片选信号
#define ENC28J60_RST(x)	if(x){gpio_set_value(ENC28J60_GPIO_REST,1);}else{gpio_set_value(ENC28J60_GPIO_REST,0);}	//ENC28J60复位信号
#define ENC28J60_MOSI(x) if(x){gpio_set_value(Tiny4412_GPIO_SPI_MOSI,1);}else{gpio_set_value(Tiny4412_GPIO_SPI_MOSI,0);}  //输出
#define ENC28J60_MISO (gpio_get_value(Tiny4412_GPIO_SPI_MISO))    //输入
#define ENC28J60_SCLK(x) if(x){gpio_set_value(Tiny4412_GPIO_SPI_SCK,1);}else{gpio_set_value(Tiny4412_GPIO_SPI_SCK,0);}  //时钟线

static u8 ENC28J60BANK;
static u32 NextPacketPtr;
static struct timer_list timer_date;
//网卡MAC地址,必须唯一
u8 ENC28J60_MacAddr[6]={0x04,0x02,0x35,0x00,0x00,0x01};	//MAC地址
static struct net_device *tiny4412_net=NULL;  //网络设备指针结构


/*
函数功能：底层SPI接口收发一个字节
说    明：模拟SPI时序，ENC28J60时钟线空闲电平为低电平，在第一个下降沿采集数据
*/
u8 ENC28J60_SPI_ReadWriteOneByte(u8 tx_data)
{
   u8 rx_data=0;				 
   u8 i;
   for(i=0;i<8;i++)
	{
		if(tx_data&0x80){ENC28J60_MOSI(1);}
		else {ENC28J60_MOSI(0);}
		tx_data<<=1;	
		{ENC28J60_SCLK(1); } 
		rx_data<<=1;
		if(ENC28J60_MISO)rx_data|=0x01;
		{ENC28J60_SCLK(0);}//第一个下降沿采集数据
	}
	return rx_data;		
}


/*
函数功能：复位ENC28J60，包括SPI初始化/IO初始化等
MISO--->PA6----主机输入
MOSI--->PA7----主机输出
SCLK--->PA5----时钟信号
CS----->PA4----片选
RESET-->PG15---复位
*/
void ENC28J60_Reset(void)
{
	/*释放GPIO*/
	gpio_free(Tiny4412_GPIO_SPI_SCK);	
	gpio_free(Tiny4412_GPIO_SPI_CS);
	gpio_free(Tiny4412_GPIO_SPI_MISO);	
	gpio_free(Tiny4412_GPIO_SPI_MOSI);
	gpio_free(ENC28J60_GPIO_REST);
	
	/*1. 配置GPIO模式*/
	printk("%d\n",gpio_request(Tiny4412_GPIO_SPI_SCK, "Tiny4412_Tiny4412_SPI_SCK"));
	printk("%d\n",gpio_request(Tiny4412_GPIO_SPI_CS, "Tiny4412_Tiny4412_SPI_CS"));
	printk("%d\n",gpio_request(Tiny4412_GPIO_SPI_MISO, "Tiny4412_Tiny4412_SPI_MISO"));
	printk("%d\n",gpio_request(Tiny4412_GPIO_SPI_MOSI, "Tiny4412_Tiny4412_SPI_MOSI"));
	printk("%d\n",gpio_request(ENC28J60_GPIO_REST, "Tiny4412_Tiny4412_SPI_REST"));

	printk("%d\n",s3c_gpio_cfgpin(Tiny4412_GPIO_SPI_SCK, S3C_GPIO_OUTPUT));
	printk("%d\n",s3c_gpio_cfgpin(Tiny4412_GPIO_SPI_CS, S3C_GPIO_OUTPUT));
	printk("%d\n",s3c_gpio_cfgpin(Tiny4412_GPIO_SPI_MISO, S3C_GPIO_INPUT));
	printk("%d\n",s3c_gpio_cfgpin(Tiny4412_GPIO_SPI_MOSI, S3C_GPIO_OUTPUT));
	printk("%d\n",s3c_gpio_cfgpin(ENC28J60_GPIO_REST, S3C_GPIO_OUTPUT));

	ENC28J60_RST(0);			//复位ENC28J60
	mdelay(10);	 
	ENC28J60_RST(1);			//复位结束				    
	mdelay(10);	 
}

/*
函数功能：读取ENC28J60寄存器(带操作码) 
参	  数：
 		 op：操作码
		 addr:寄存器地址/参数
返 回 值：读到的数据
*/
u8 ENC28J60_Read_Op(u8 op,u8 addr)
{
	u8 dat=0;	 
	ENC28J60_CS(0);	 
	dat=op|(addr&ADDR_MASK);
	ENC28J60_SPI_ReadWriteOneByte(dat);
	dat=ENC28J60_SPI_ReadWriteOneByte(0xFF);
	//如果是读取MAC/MII寄存器,则第二次读到的数据才是正确的,见手册29页
 	if(addr&0x80)dat=ENC28J60_SPI_ReadWriteOneByte(0xFF);
	ENC28J60_CS(1);
	return dat;
}

/*
函数功能：读取ENC28J60寄存器(带操作码) 
参    数：
		op：操作码
		addr:寄存器地址
		data:参数
*/
void ENC28J60_Write_Op(u8 op,u8 addr,u8 data)
{
	u8 dat = 0;	    
	ENC28J60_CS(0);			   
	dat=op|(addr&ADDR_MASK);
	ENC28J60_SPI_ReadWriteOneByte(dat);	  
	ENC28J60_SPI_ReadWriteOneByte(data);
	ENC28J60_CS(1);
}



/*
函数功能：读取ENC28J60接收缓存数据
参    数：
		len:要读取的数据长度
		data:输出数据缓存区(末尾自动添加结束符)
*/
void ENC28J60_Read_Buf(u32 len,u8* data)
{
	ENC28J60_CS(0);			 
	ENC28J60_SPI_ReadWriteOneByte(ENC28J60_READ_BUF_MEM);
	while(len)
	{
		len--;			  
		*data=(u8)ENC28J60_SPI_ReadWriteOneByte(0);
		data++;
	}
	*data='\0';
	ENC28J60_CS(1);
}


/*
函数功能：向ENC28J60写发送缓存数据
参    数：
		len:要写入的数据长度
		data:数据缓存区
*/
void ENC28J60_Write_Buf(u32 len,u8* data)
{
	ENC28J60_CS(0);			   
	ENC28J60_SPI_ReadWriteOneByte(ENC28J60_WRITE_BUF_MEM);		 
	while(len)
	{
		len--;
		ENC28J60_SPI_ReadWriteOneByte(*data);
		data++;
	}
	ENC28J60_CS(1);
}

/*
函数功能：设置ENC28J60寄存器Bank
参    数：
				ban:要设置的bank
*/
void ENC28J60_Set_Bank(u8 bank)
{								    
	if((bank&BANK_MASK)!=ENC28J60BANK)//和当前bank不一致的时候,才设置
	{				  
		ENC28J60_Write_Op(ENC28J60_BIT_FIELD_CLR,ECON1,(ECON1_BSEL1|ECON1_BSEL0));
		ENC28J60_Write_Op(ENC28J60_BIT_FIELD_SET,ECON1,(bank&BANK_MASK)>>5);
		ENC28J60BANK=(bank&BANK_MASK);
	}
}


/*
函数功能：读取ENC28J60指定寄存器
参    数：addr:寄存器地址
返 回 值：读到的数据
*/
u8 ENC28J60_Read(u8 addr)
{						  
	ENC28J60_Set_Bank(addr);//设置BANK		 
	return ENC28J60_Read_Op(ENC28J60_READ_CTRL_REG,addr);
}


/*
函数功能：向ENC28J60指定寄存器写数据
参    数：
		addr:寄存器地址
		data:要写入的数据		
*/
void ENC28J60_Write(u8 addr,u8 data)
{					  
	ENC28J60_Set_Bank(addr);		 
	ENC28J60_Write_Op(ENC28J60_WRITE_CTRL_REG,addr,data);
}


/*
函数功能：向ENC28J60的PHY寄存器写入数据
参    数：
		addr:寄存器地址
		data:要写入的数据	
*/
void ENC28J60_PHY_Write(u8 addr,u32 data)
{
	u16 retry=0;
	ENC28J60_Write(MIREGADR,addr);	//设置PHY寄存器地址
	ENC28J60_Write(MIWRL,data);		//写入数据
	ENC28J60_Write(MIWRH,data>>8);		   
	while((ENC28J60_Read(MISTAT)&MISTAT_BUSY)&&retry<0XFFF)retry++;//等待写入PHY结束		  
}


/*
函数功能：初始化ENC28J60
参    数：macaddr:MAC地址
返 回 值：	 
		0,初始化成功;
        1,初始化失败;
*/
u8 ENC28J60_Init(u8* macaddr)
{		
	u16 retry=0;		  
	ENC28J60_Reset(); //复位底层引脚接口
	ENC28J60_Write_Op(ENC28J60_SOFT_RESET,0,ENC28J60_SOFT_RESET);//软件复位
	while(!(ENC28J60_Read(ESTAT)&ESTAT_CLKRDY)&&retry<500)//等待时钟稳定
	{
		retry++;
		mdelay(1);
	};
	if(retry>=500)return 1;//ENC28J60初始化失败
	// do bank 0 stuff
	// initialize receive buffer
	// 16-bit transfers,must write low byte first
	// set receive buffer start address	   设置接收缓冲区地址  8K字节容量
	NextPacketPtr=RXSTART_INIT;
	// Rx start
	//接收缓冲器由一个硬件管理的循环FIFO 缓冲器构成。
	//寄存器对ERXSTH:ERXSTL 和ERXNDH:ERXNDL 作
	//为指针，定义缓冲器的容量和其在存储器中的位置。
	//ERXST和ERXND指向的字节均包含在FIFO缓冲器内。
	//当从以太网接口接收数据字节时，这些字节被顺序写入
	//接收缓冲器。 但是当写入由ERXND 指向的存储单元
	//后，硬件会自动将接收的下一字节写入由ERXST 指向
	//的存储单元。 因此接收硬件将不会写入FIFO 以外的单
	//元。
	//设置接收起始字节
	ENC28J60_Write(ERXSTL,RXSTART_INIT&0xFF);	
	ENC28J60_Write(ERXSTH,RXSTART_INIT>>8);	  
	//ERXWRPTH:ERXWRPTL 寄存器定义硬件向FIFO 中
	//的哪个位置写入其接收到的字节。 指针是只读的，在成
	//功接收到一个数据包后，硬件会自动更新指针。 指针可
	//用于判断FIFO 内剩余空间的大小  8K-1500。 
	//设置接收读指针字节
	ENC28J60_Write(ERXRDPTL,RXSTART_INIT&0xFF);
	ENC28J60_Write(ERXRDPTH,RXSTART_INIT>>8);
	//设置接收结束字节
	ENC28J60_Write(ERXNDL,RXSTOP_INIT&0xFF);
	ENC28J60_Write(ERXNDH,RXSTOP_INIT>>8);
	//设置发送起始字节
	ENC28J60_Write(ETXSTL,TXSTART_INIT&0xFF);
	ENC28J60_Write(ETXSTH,TXSTART_INIT>>8);
	//设置发送结束字节
	ENC28J60_Write(ETXNDL,TXSTOP_INIT&0xFF);
	ENC28J60_Write(ETXNDH,TXSTOP_INIT>>8);
	// do bank 1 stuff,packet filter:
	// For broadcast packets we allow only ARP packtets
	// All other packets should be unicast only for our mac (MAADR)
	//
	// The pattern to match on is therefore
	// Type     ETH.DST
	// ARP      BROADCAST
	// 06 08 -- ff ff ff ff ff ff -> ip checksum for theses bytes=f7f9
	// in binary these poitions are:11 0000 0011 1111
	// This is hex 303F->EPMM0=0x3f,EPMM1=0x30
	//接收过滤器
	//UCEN：单播过滤器使能位
	//当ANDOR = 1 时：//1 = 目标地址与本地MAC 地址不匹配的数据包将被丢弃
	//0 = 禁止过滤器
	//当ANDOR = 0 时：//1 = 目标地址与本地MAC 地址匹配的数据包会被接受
	//0 = 禁止过滤器
	//CRCEN：后过滤器CRC 校验使能位//1 = 所有CRC 无效的数据包都将被丢弃
	//0 = 不考虑CRC 是否有效
	//PMEN：格式匹配过滤器使能位
	//当ANDOR = 1 时：	//1 = 数据包必须符合格式匹配条件，否则将被丢弃
	//0 = 禁止过滤器
	//当ANDOR = 0 时：	//1 = 符合格式匹配条件的数据包将被接受
	//0 = 禁止过滤器
	ENC28J60_Write(ERXFCON,ERXFCON_UCEN|ERXFCON_CRCEN|ERXFCON_PMEN);
	ENC28J60_Write(EPMM0,0x3f);
	ENC28J60_Write(EPMM1,0x30);
	ENC28J60_Write(EPMCSL,0xf9);
	ENC28J60_Write(EPMCSH,0xf7);
	// do bank 2 stuff
	// enable MAC receive
	//bit 0 MARXEN：MAC 接收使能位	//1 = 允许MAC 接收数据包
	//0 = 禁止数据包接收
	//bit 3 TXPAUS：暂停控制帧发送使能位	//1 = 允许MAC 发送暂停控制帧（用于全双工模式下的流量控制）
	//0 = 禁止暂停帧发送
	//bit 2 RXPAUS：暂停控制帧接收使能位	//1 = 当接收到暂停控制帧时，禁止发送（正常操作）
	//0 = 忽略接收到的暂停控制帧
	ENC28J60_Write(MACON1,MACON1_MARXEN|MACON1_TXPAUS|MACON1_RXPAUS);
	// bring MAC out of reset
	//将MACON2 中的MARST 位清零，使MAC 退出复位状态。
	ENC28J60_Write(MACON2,0x00);
	// enable automatic padding to 60bytes and CRC operations
	//bit 7-5 PADCFG2:PACDFG0：自动填充和CRC 配置位
	//111 = 用0 填充所有短帧至64 字节长，并追加一个有效的CRC
	//110 = 不自动填充短帧
	//101 = MAC 自动检测具有8100h 类型字段的VLAN 协议帧，并自动填充到64 字节长。如果不
	//是VLAN 帧，则填充至60 字节长。填充后还要追加一个有效的CRC
	//100 = 不自动填充短帧
	//011 = 用0 填充所有短帧至64 字节长，并追加一个有效的CRC
	//010 = 不自动填充短帧
	//001 = 用0 填充所有短帧至60 字节长，并追加一个有效的CRC
	//000 = 不自动填充短帧
	//bit 4 TXCRCEN：发送CRC 使能位	//1= 不管PADCFG如何，MAC都会在发送帧的末尾追加一个有效的CRC。 如果PADCFG规定要
	//追加有效的CRC，则必须将TXCRCEN 置1。
	//0 = MAC不会追加CRC。 检查最后4 个字节，如果不是有效的CRC 则报告给发送状态向量。
	//bit 0 FULDPX：MAC 全双工使能位	//1 = MAC工作在全双工模式下。 PHCON1.PDPXMD 位必须置1。
	//0 = MAC工作在半双工模式下。 PHCON1.PDPXMD 位必须清零。
	ENC28J60_Write_Op(ENC28J60_BIT_FIELD_SET,MACON3,MACON3_PADCFG0|MACON3_TXCRCEN|MACON3_FRMLNEN|MACON3_FULDPX);
	// set inter-frame gap (non-back-to-back)
	//配置非背对背包间间隔寄存器的低字节
	//MAIPGL。 大多数应用使用12h 编程该寄存器。
	//如果使用半双工模式，应编程非背对背包间间隔
	//寄存器的高字节MAIPGH。 大多数应用使用0Ch
	//编程该寄存器。
	ENC28J60_Write(MAIPGL,0x12);
	ENC28J60_Write(MAIPGH,0x0C);
	// set inter-frame gap (back-to-back)
	//配置背对背包间间隔寄存器MABBIPG。当使用
	//全双工模式时，大多数应用使用15h 编程该寄存
	//器，而使用半双工模式时则使用12h 进行编程。
	ENC28J60_Write(MABBIPG,0x15);
	// Set the maximum packet size which the controller will accept
	// Do not send packets longer than MAX_FRAMELEN:
	// 最大帧长度  1500
	ENC28J60_Write(MAMXFLL,MAX_FRAMELEN&0xFF);	
	ENC28J60_Write(MAMXFLH,MAX_FRAMELEN>>8);
	// do bank 3 stuff
	// write MAC address
	// NOTE: MAC address in ENC28J60 is byte-backward
	//设置MAC地址
	ENC28J60_Write(MAADR5,macaddr[0]);	
	ENC28J60_Write(MAADR4,macaddr[1]);
	ENC28J60_Write(MAADR3,macaddr[2]);
	ENC28J60_Write(MAADR2,macaddr[3]);
	ENC28J60_Write(MAADR1,macaddr[4]);
	ENC28J60_Write(MAADR0,macaddr[5]);
	//配置PHY为全双工  LEDB为拉电流
	ENC28J60_PHY_Write(PHCON1,PHCON1_PDPXMD);	 
	// no loopback of transmitted frames	 禁止环回
	//HDLDIS：PHY 半双工环回禁止位
	//当PHCON1.PDPXMD = 1 或PHCON1.PLOOPBK = 1 时：
	//此位可被忽略。
	//当PHCON1.PDPXMD = 0 且PHCON1.PLOOPBK = 0 时：	//1 = 要发送的数据仅通过双绞线接口发出
	//0 = 要发送的数据会环回到MAC 并通过双绞线接口发出
	ENC28J60_PHY_Write(PHCON2,PHCON2_HDLDIS);
	// switch to bank 0
	//ECON1 寄存器
	//寄存器3-1 所示为ECON1 寄存器，它用于控制
	//ENC28J60 的主要功能。 ECON1 中包含接收使能、发
	//送请求、DMA 控制和存储区选择位。	   
	ENC28J60_Set_Bank(ECON1);
	// enable interrutps
	//EIE： 以太网中断允许寄存器
	//bit 7 INTIE： 全局INT 中断允许位	//1 = 允许中断事件驱动INT 引脚
	//0 = 禁止所有INT 引脚的活动（引脚始终被驱动为高电平）
	//bit 6 PKTIE： 接收数据包待处理中断允许位	//1 = 允许接收数据包待处理中断
	//0 = 禁止接收数据包待处理中断
	ENC28J60_Write_Op(ENC28J60_BIT_FIELD_SET,EIE,EIE_INTIE|EIE_PKTIE);
	// enable packet reception
	//bit 2 RXEN：接收使能位	//1 = 通过当前过滤器的数据包将被写入接收缓冲器
	//0 = 忽略所有接收的数据包
	ENC28J60_Write_Op(ENC28J60_BIT_FIELD_SET,ECON1,ECON1_RXEN);
	if(ENC28J60_Read(MAADR5)== macaddr[0])return 0;//初始化成功
	else return 1; 	  

}

/*
函数功能：读取EREVID
*/
u8 ENC28J60_Get_EREVID(void)
{
	//在EREVID 内也存储了版本信息。 EREVID 是一个只读控
	//制寄存器，包含一个5 位标识符，用来标识器件特定硅片
	//的版本号
	return ENC28J60_Read(EREVID);
}

/*
函数功能：通过ENC28J60发送数据包到网络
参    数：
		len   :数据包大小
        packet:数据包
*/
void ENC28J60_Packet_Send(u32 len,u8* packet)
{
	//设置发送缓冲区地址写指针入口
	ENC28J60_Write(EWRPTL,TXSTART_INIT&0xFF);
	ENC28J60_Write(EWRPTH,TXSTART_INIT>>8);
	//设置TXND指针，以对应给定的数据包大小	   
	ENC28J60_Write(ETXNDL,(TXSTART_INIT+len)&0xFF);
	ENC28J60_Write(ETXNDH,(TXSTART_INIT+len)>>8);
	//写每包控制字节（0x00表示使用macon3的设置） 
	ENC28J60_Write_Op(ENC28J60_WRITE_BUF_MEM,0,0x00);
	//复制数据包到发送缓冲区
	//printf("len:%d\r\n",len);	//监视发送数据长度
 	ENC28J60_Write_Buf(len,packet);
 	//发送数据到网络
	ENC28J60_Write_Op(ENC28J60_BIT_FIELD_SET,ECON1,ECON1_TXRTS);
	//复位发送逻辑的问题。参见Rev. B4 Silicon Errata point 12.
	if((ENC28J60_Read(EIR)&EIR_TXERIF))ENC28J60_Write_Op(ENC28J60_BIT_FIELD_CLR,ECON1,ECON1_TXRTS);
}

/*
函数功能：从网络获取一个数据包内容
函数参数：
		maxlen:数据包最大允许接收长度
		packet:数据包缓存区
返 回 值：收到的数据包长度(字节)	
*/
u32 ENC28J60_Packet_Receive(u32 maxlen,u8* packet)
{
	u32 rxstat;
	u32 len;    													 
	if(ENC28J60_Read(EPKTCNT)==0)return 0;  //是否收到数据包?	   
	//设置接收缓冲器读指针
	ENC28J60_Write(ERDPTL,(NextPacketPtr));
	ENC28J60_Write(ERDPTH,(NextPacketPtr)>>8);	   
	// 读下一个包的指针
	NextPacketPtr=ENC28J60_Read_Op(ENC28J60_READ_BUF_MEM,0);
	NextPacketPtr|=ENC28J60_Read_Op(ENC28J60_READ_BUF_MEM,0)<<8;
	//读包的长度
	len=ENC28J60_Read_Op(ENC28J60_READ_BUF_MEM,0);
	len|=ENC28J60_Read_Op(ENC28J60_READ_BUF_MEM,0)<<8;
 	len-=4; //去掉CRC计数
	//读取接收状态
	rxstat=ENC28J60_Read_Op(ENC28J60_READ_BUF_MEM,0);
	rxstat|=ENC28J60_Read_Op(ENC28J60_READ_BUF_MEM,0)<<8;
	//限制接收长度	
	if (len>maxlen-1)len=maxlen-1;	
	//检查CRC和符号错误
	// ERXFCON.CRCEN为默认设置,一般我们不需要检查.
	if((rxstat&0x80)==0)len=0;//无效
	else ENC28J60_Read_Buf(len,packet);//从接收缓冲器中复制数据包	    
	//RX读指针移动到下一个接收到的数据包的开始位置 
	//并释放我们刚才读出过的内存
	ENC28J60_Write(ERXRDPTL,(NextPacketPtr));
	ENC28J60_Write(ERXRDPTH,(NextPacketPtr)>>8);
	//递减数据包计数器标志我们已经得到了这个包 
 	ENC28J60_Write_Op(ENC28J60_BIT_FIELD_SET,ECON2,ECON2_PKTDEC);
	return(len);
}

/*--------------------------工作队列、定时器、中断服务函数---------------------------------------*/

static struct work_struct work_list;

/*
工作队列处理函数
以下函数用于读取网卡里的数据。
读取完毕之后,再通过netif_rx()函数上报到应用层
*/

u8 Enc28j60_Rx_Buff[1518];
static void workqueue_function(struct work_struct *work)
{
	int length;
	length=ENC28J60_Packet_Receive(1518,Enc28j60_Rx_Buff); //接收ENC28J60的数据
	if(length<=0)
	{
		return;
	}

	/*2. 分配新的套接字缓冲区*/
    struct sk_buff *skb = dev_alloc_skb(length+NET_IP_ALIGN);
    skb_reserve(skb, NET_IP_ALIGN); //对齐
    skb->dev = tiny4412_net;

    /* 读取硬件上接收到的数据 */
	// skb_put(skb, length)//存放网卡里读取数据的缓冲区地址
	memcpy(skb_put(skb, length),Enc28j60_Rx_Buff,length);
	
    /* 获取上层协议类型 */
    skb->protocol = eth_type_trans(skb,tiny4412_net);

    /* 把数据包交给上层 */
    netif_rx(skb);

    /* 记录接收时间戳 */
    tiny4412_net->last_rx = jiffies;
	
	//printk("工作队列处理函数调用成功!\n");
}


/*
函数功能:  中断服务函数
*/
irqreturn_t ENC28J60_irq_handler(int irq, void *dev)
{
	 /*共享工作队列调度*/
	 //printk("进入到中断服务函数!\n");
	 /*使用的ENC28J60网卡中断不好使,程序就使用定时器轮询接收了*/
	 schedule_work(&work_list);
	 return IRQ_HANDLED;
}

static void timer_function(unsigned long data)
{
	/*共享工作队列调度*/
	 schedule_work(&work_list);
	/*修改定时器超时*/
	mod_timer(&timer_date,jiffies+usecs_to_jiffies(100));		
}


/*----------------------------网络设备相关代码--------------------------------------*/

/*1. 设备初始化调用,该函数在注册成功后会调用一次,可以编写网卡初始化相关代码*/
static int tiny4412_ndo_init(struct net_device * dev)
{
	/*1. ENC28J60网卡初始化*/
	u8 stat=ENC28J60_Init(ENC28J60_MacAddr);
	if(stat)
	{
		 printk("ENC28J60网卡初始化失败!\r\n");
	}
	/*2. 获取中断编号*/
	ENC28J60_IRQ=gpio_to_irq(ENC28J60_IRQ_NUMBER);
	printk("ENC28J60_IRQ=%d\n",ENC28J60_IRQ);
	
	/*3. 初始化工作队列*/
	INIT_WORK(&work_list,workqueue_function);

	/*4. 注册中断*/
	if(request_irq(ENC28J60_IRQ,ENC28J60_irq_handler,IRQ_TYPE_EDGE_FALLING,"ENC28J60_NET",NULL)!=0)
	{
		printk("ENC28J60中断注册失败!\n");
	}

	 /*使用定时器100ms*/
	 timer_date.expires=jiffies+usecs_to_jiffies(100);
	 timer_date.function=timer_function;
	 
	 /*5. 初始化定时器*/
	 init_timer(&timer_date);

	 /*6. 添加定时器到内核并启动*/
	 add_timer(&timer_date);
	 
	printk("网络设备初始化!\n");
	return 0;
}

/*2. 打开网络接口，对应ifconfig up命令，编写网络设备硬件初始化的相关代码*/
static int	tiny4412_ndo_open(struct net_device *dev)
{
	printk("网络设备打开成功!\n");
	return 0;
}

/*3. 关闭网络设备，对应ifconfig down命令，实现的内容与OPEN相反*/
static int	tiny4412_ndo_stop(struct net_device *dev)
{
	printk("网络设备关闭成功!\n");
	return 0;
}

/*4. 启动网络数据包传输的方法*/
static netdev_tx_t	tiny4412_ndo_start_xmit(struct sk_buff *skb,struct net_device *dev)
{
	int len;
	char *data, shortpkt[ETH_ZLEN];
    /* 获得有效数据指针和长度 */
    data = skb->data;
    len = skb->len;
    if(len < ETH_ZLEN)
	{
        /* 如果帧长小于以太网帧最小长度,补0 */
        memset(shortpkt,0,ETH_ZLEN);
        memcpy(shortpkt,skb->data,skb->len);
        len = ETH_ZLEN;
	    data = shortpkt;
    }
    dev->trans_start = jiffies;     //记录发送时间戳
    
    /* 设置硬件寄存器让硬件将数据发出去 */
    ENC28J60_Packet_Send(len,data);
	return NETDEV_TX_OK; //这是个枚举状态。
}


/*5. 设置MAC地址,对应的命令: ifconfig eth888 hw ether 00:AA:BB:CC:DD:EE  */
static int tiny4412_set_mac_address(struct net_device *dev, void *addr)
{
	struct sockaddr *address = addr;
	memcpy(dev->dev_addr, address->sa_data, dev->addr_len);
	printk("修改的MAC地址如下:\n");
	printk("%X-%X-%X-%X-%X-%X\n",
		tiny4412_net->dev_addr[0],
		tiny4412_net->dev_addr[1],
		tiny4412_net->dev_addr[2],
		tiny4412_net->dev_addr[3],
		tiny4412_net->dev_addr[4],
		tiny4412_net->dev_addr[5]);
	//设置MAC地址
	ENC28J60_Write(MAADR5,tiny4412_net->dev_addr[0]);	
	ENC28J60_Write(MAADR4,tiny4412_net->dev_addr[1]);
	ENC28J60_Write(MAADR3,tiny4412_net->dev_addr[2]);
	ENC28J60_Write(MAADR2,tiny4412_net->dev_addr[3]);
	ENC28J60_Write(MAADR1,tiny4412_net->dev_addr[4]);
	ENC28J60_Write(MAADR0,tiny4412_net->dev_addr[5]);
	return 0;
}

/*网络设备虚拟文件操作集合*/
static  struct net_device_ops netdev_ops_test= 
{
	.ndo_open			= tiny4412_ndo_open,
	.ndo_stop			= tiny4412_ndo_stop,
	.ndo_start_xmit 	= tiny4412_ndo_start_xmit,
	.ndo_init       	= tiny4412_ndo_init,
	.ndo_set_mac_address= tiny4412_set_mac_address,
};

/*--------------------------驱动框架------------------------------------*/
static int __init Net_test_init(void)
{
	/*1. 分配及初始化net_device对象,参数:私有数据大小（单位：字节数）*/
	tiny4412_net=alloc_etherdev(sizeof(struct net_device));

	/*2. net结构体赋值*/
  	strcpy(tiny4412_net->name, "eth888");//网络设备的名称，使用ifconfig -a可以查看到。
  	tiny4412_net->netdev_ops=&netdev_ops_test; //虚拟文件操作集合
	tiny4412_net->if_port = IF_PORT_10BASET; 	 //协议规范
	tiny4412_net->watchdog_timeo = 4 * HZ;     //看门狗超时时间
	
  	/*3. 随机生成MAC地址*/
	eth_hw_addr_random(tiny4412_net);
    printk("随机生成的MAC地址如下:\n");
	printk("%X-%X-%X-%X-%X-%X\n",
		tiny4412_net->dev_addr[0],
		tiny4412_net->dev_addr[1],
		tiny4412_net->dev_addr[2],
		tiny4412_net->dev_addr[3],
		tiny4412_net->dev_addr[4],
		tiny4412_net->dev_addr[5]);
	ENC28J60_MacAddr[0]=tiny4412_net->dev_addr[0];
	ENC28J60_MacAddr[1]=tiny4412_net->dev_addr[1];
	ENC28J60_MacAddr[2]=tiny4412_net->dev_addr[2];
	ENC28J60_MacAddr[3]=tiny4412_net->dev_addr[3];
	ENC28J60_MacAddr[4]=tiny4412_net->dev_addr[4];
	ENC28J60_MacAddr[5]=tiny4412_net->dev_addr[5];
	
	/*注册网络设备*/
	register_netdev(tiny4412_net);
	
	printk("网络设备注册成功!\n");	
	return 0;
}


static void __exit Net_test_exit(void)
{	
	//注销网络设备
	unregister_netdev(tiny4412_net);
	
	/*1. 释放GPIO口使用权*/
	gpio_free(Tiny4412_GPIO_SPI_SCK);	
	gpio_free(Tiny4412_GPIO_SPI_CS);
	gpio_free(Tiny4412_GPIO_SPI_MISO);
	gpio_free(Tiny4412_GPIO_SPI_MOSI);
	gpio_free(ENC28J60_GPIO_REST);	

	/*2. 释放中断号*/
	free_irq(ENC28J60_IRQ,NULL);

	/*3. 停止定时器*/
	del_timer_sync(&timer_date);
		
	/*4. 清除工作*/
	cancel_work_sync(&work_list);
	
	printk("网络设备注销成功!\n");	
}

module_init(Net_test_init);
module_exit(Net_test_exit);
MODULE_AUTHOR("xiaolong");
MODULE_LICENSE("GPL");

2.2  对应enc28j60.h代码

#ifndef __ENC28J60_H
#define __ENC28J60_H	  

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ENC28J60 Control Registers
// Control register definitions are a combination of address,
// bank number, and Ethernet/MAC/PHY indicator bits.
// - Register address         (bits 0-4)
// - Bank number              (bits 5-6)
// - MAC/PHY indicator        (bit 7)
#define ADDR_MASK        0x1F
#define BANK_MASK        0x60
#define SPRD_MASK        0x80
// All-bank registers
#define EIE              0x1B
#define EIR              0x1C
#define ESTAT            0x1D
#define ECON2            0x1E
#define ECON1            0x1F
// Bank 0 registers
#define ERDPTL           (0x00|0x00)
#define ERDPTH           (0x01|0x00)
#define EWRPTL           (0x02|0x00)
#define EWRPTH           (0x03|0x00)
#define ETXSTL           (0x04|0x00)
#define ETXSTH           (0x05|0x00)
#define ETXNDL           (0x06|0x00)
#define ETXNDH           (0x07|0x00)
#define ERXSTL           (0x08|0x00)
#define ERXSTH           (0x09|0x00)
#define ERXNDL           (0x0A|0x00)
#define ERXNDH           (0x0B|0x00)
//ERXWRPTH:ERXWRPTL 寄存器定义硬件向FIFO 中
//的哪个位置写入其接收到的字节。 指针是只读的，在成
//功接收到一个数据包后，硬件会自动更新指针。 指针可
//用于判断FIFO 内剩余空间的大小。
#define ERXRDPTL         (0x0C|0x00)
#define ERXRDPTH         (0x0D|0x00)
#define ERXWRPTL         (0x0E|0x00)
#define ERXWRPTH         (0x0F|0x00)
#define EDMASTL          (0x10|0x00)
#define EDMASTH          (0x11|0x00)
#define EDMANDL          (0x12|0x00)
#define EDMANDH          (0x13|0x00)
#define EDMADSTL         (0x14|0x00)
#define EDMADSTH         (0x15|0x00)
#define EDMACSL          (0x16|0x00)
#define EDMACSH          (0x17|0x00)
// Bank 1 registers
#define EHT0             (0x00|0x20)
#define EHT1             (0x01|0x20)
#define EHT2             (0x02|0x20)
#define EHT3             (0x03|0x20)
#define EHT4             (0x04|0x20)
#define EHT5             (0x05|0x20)
#define EHT6             (0x06|0x20)
#define EHT7             (0x07|0x20)
#define EPMM0            (0x08|0x20)
#define EPMM1            (0x09|0x20)
#define EPMM2            (0x0A|0x20)
#define EPMM3            (0x0B|0x20)
#define EPMM4            (0x0C|0x20)
#define EPMM5            (0x0D|0x20)
#define EPMM6            (0x0E|0x20)
#define EPMM7            (0x0F|0x20)
#define EPMCSL           (0x10|0x20)
#define EPMCSH           (0x11|0x20)
#define EPMOL            (0x14|0x20)
#define EPMOH            (0x15|0x20)
#define EWOLIE           (0x16|0x20)
#define EWOLIR           (0x17|0x20)
#define ERXFCON          (0x18|0x20)
#define EPKTCNT          (0x19|0x20)
// Bank 2 registers
#define MACON1           (0x00|0x40|0x80)
#define MACON2           (0x01|0x40|0x80)
#define MACON3           (0x02|0x40|0x80)
#define MACON4           (0x03|0x40|0x80)
#define MABBIPG          (0x04|0x40|0x80)
#define MAIPGL           (0x06|0x40|0x80)
#define MAIPGH           (0x07|0x40|0x80)
#define MACLCON1         (0x08|0x40|0x80)
#define MACLCON2         (0x09|0x40|0x80)
#define MAMXFLL          (0x0A|0x40|0x80)
#define MAMXFLH          (0x0B|0x40|0x80)
#define MAPHSUP          (0x0D|0x40|0x80)
#define MICON            (0x11|0x40|0x80)
#define MICMD            (0x12|0x40|0x80)
#define MIREGADR         (0x14|0x40|0x80)
#define MIWRL            (0x16|0x40|0x80)
#define MIWRH            (0x17|0x40|0x80)
#define MIRDL            (0x18|0x40|0x80)
#define MIRDH            (0x19|0x40|0x80)
// Bank 3 registers
#define MAADR1           (0x00|0x60|0x80)
#define MAADR0           (0x01|0x60|0x80)
#define MAADR3           (0x02|0x60|0x80)
#define MAADR2           (0x03|0x60|0x80)
#define MAADR5           (0x04|0x60|0x80)
#define MAADR4           (0x05|0x60|0x80)
#define EBSTSD           (0x06|0x60)
#define EBSTCON          (0x07|0x60)
#define EBSTCSL          (0x08|0x60)
#define EBSTCSH          (0x09|0x60)
#define MISTAT           (0x0A|0x60|0x80)
#define EREVID           (0x12|0x60)
#define ECOCON           (0x15|0x60)
#define EFLOCON          (0x17|0x60)
#define EPAUSL           (0x18|0x60)
#define EPAUSH           (0x19|0x60)
// PHY registers
#define PHCON1           0x00
#define PHSTAT1          0x01
#define PHHID1           0x02
#define PHHID2           0x03
#define PHCON2           0x10
#define PHSTAT2          0x11
#define PHIE             0x12
#define PHIR             0x13
#define PHLCON           0x14	   
// ENC28J60 ERXFCON Register Bit Definitions
#define ERXFCON_UCEN     0x80
#define ERXFCON_ANDOR    0x40
#define ERXFCON_CRCEN    0x20
#define ERXFCON_PMEN     0x10
#define ERXFCON_MPEN     0x08
#define ERXFCON_HTEN     0x04
#define ERXFCON_MCEN     0x02
#define ERXFCON_BCEN     0x01
// ENC28J60 EIE Register Bit Definitions
#define EIE_INTIE        0x80
#define EIE_PKTIE        0x40
#define EIE_DMAIE        0x20
#define EIE_LINKIE       0x10
#define EIE_TXIE         0x08
#define EIE_WOLIE        0x04
#define EIE_TXERIE       0x02
#define EIE_RXERIE       0x01
// ENC28J60 EIR Register Bit Definitions
#define EIR_PKTIF        0x40
#define EIR_DMAIF        0x20
#define EIR_LINKIF       0x10
#define EIR_TXIF         0x08
#define EIR_WOLIF        0x04
#define EIR_TXERIF       0x02
#define EIR_RXERIF       0x01
// ENC28J60 ESTAT Register Bit Definitions
#define ESTAT_INT        0x80
#define ESTAT_LATECOL    0x10
#define ESTAT_RXBUSY     0x04
#define ESTAT_TXABRT     0x02
#define ESTAT_CLKRDY     0x01
// ENC28J60 ECON2 Register Bit Definitions
#define ECON2_AUTOINC    0x80
#define ECON2_PKTDEC     0x40
#define ECON2_PWRSV      0x20
#define ECON2_VRPS       0x08
// ENC28J60 ECON1 Register Bit Definitions
#define ECON1_TXRST      0x80
#define ECON1_RXRST      0x40
#define ECON1_DMAST      0x20
#define ECON1_CSUMEN     0x10
#define ECON1_TXRTS      0x08
#define ECON1_RXEN       0x04
#define ECON1_BSEL1      0x02
#define ECON1_BSEL0      0x01
// ENC28J60 MACON1 Register Bit Definitions
#define MACON1_LOOPBK    0x10
#define MACON1_TXPAUS    0x08
#define MACON1_RXPAUS    0x04
#define MACON1_PASSALL   0x02
#define MACON1_MARXEN    0x01
// ENC28J60 MACON2 Register Bit Definitions
#define MACON2_MARST     0x80
#define MACON2_RNDRST    0x40
#define MACON2_MARXRST   0x08
#define MACON2_RFUNRST   0x04
#define MACON2_MATXRST   0x02
#define MACON2_TFUNRST   0x01
// ENC28J60 MACON3 Register Bit Definitions
#define MACON3_PADCFG2   0x80
#define MACON3_PADCFG1   0x40
#define MACON3_PADCFG0   0x20
#define MACON3_TXCRCEN   0x10
#define MACON3_PHDRLEN   0x08
#define MACON3_HFRMLEN   0x04
#define MACON3_FRMLNEN   0x02
#define MACON3_FULDPX    0x01
// ENC28J60 MICMD Register Bit Definitions
#define MICMD_MIISCAN    0x02
#define MICMD_MIIRD      0x01
// ENC28J60 MISTAT Register Bit Definitions
#define MISTAT_NVALID    0x04
#define MISTAT_SCAN      0x02
#define MISTAT_BUSY      0x01
// ENC28J60 PHY PHCON1 Register Bit Definitions
#define PHCON1_PRST      0x8000
#define PHCON1_PLOOPBK   0x4000
#define PHCON1_PPWRSV    0x0800
#define PHCON1_PDPXMD    0x0100
// ENC28J60 PHY PHSTAT1 Register Bit Definitions
#define PHSTAT1_PFDPX    0x1000
#define PHSTAT1_PHDPX    0x0800
#define PHSTAT1_LLSTAT   0x0004
#define PHSTAT1_JBSTAT   0x0002
// ENC28J60 PHY PHCON2 Register Bit Definitions
#define PHCON2_FRCLINK   0x4000
#define PHCON2_TXDIS     0x2000
#define PHCON2_JABBER    0x0400
#define PHCON2_HDLDIS    0x0100

// ENC28J60 Packet Control Byte Bit Definitions
#define PKTCTRL_PHUGEEN  0x08
#define PKTCTRL_PPADEN   0x04
#define PKTCTRL_PCRCEN   0x02
#define PKTCTRL_POVERRIDE 0x01

// SPI operation codes
#define ENC28J60_READ_CTRL_REG       0x00
#define ENC28J60_READ_BUF_MEM        0x3A
#define ENC28J60_WRITE_CTRL_REG      0x40
#define ENC28J60_WRITE_BUF_MEM       0x7A
#define ENC28J60_BIT_FIELD_SET       0x80
#define ENC28J60_BIT_FIELD_CLR       0xA0
#define ENC28J60_SOFT_RESET          0xFF

// The RXSTART_INIT should be zero. See Rev. B4 Silicon Errata
// buffer boundaries applied to internal 8K ram
// the entire available packet buffer space is allocated
//
// start with recbuf at 0/
#define RXSTART_INIT     0x0
// receive buffer end
#define RXSTOP_INIT      (0x1FFF-1518-1)
// start TX buffer at 0x1FFF-0x0600, pace for one full ethernet frame (0~1518 bytes)
#define TXSTART_INIT     (0x1FFF-1518)
// stp TX buffer at end of mem
#define TXSTOP_INIT      0x1FFF
// max frame length which the conroller will accept:
#define   MAX_FRAMELEN    1518        // (note: maximum ethernet frame length would be 1518)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void ENC28J60_Reset(void);
u8 ENC28J60_Read_Op(u8 op,u8 addr);
void ENC28J60_Write_Op(u8 op,u8 addr,u8 data);
void ENC28J60_Read_Buf(u32 len,u8* data);
void ENC28J60_Write_Buf(u32 len,u8* data);
void ENC28J60_Set_Bank(u8 bank);
u8 ENC28J60_Read(u8 addr);
void ENC28J60_Write(u8 addr,u8 data);
void ENC28J60_PHY_Write(u8 addr,u32 data);
u8 ENC28J60_Init(u8* macaddr);
u8 ENC28J60_Get_EREVID(void);
void ENC28J60_Packet_Send(u32 len,u8* packet);
u32 ENC28J60_Packet_Receive(u32 maxlen,u8* packet);  
#endif