Динамически распределять пространство
#define alloc_etherdev(sizeof_priv) alloc_etherdev_mq(sizeof_priv, 1)
Параметры функции: Объем выделенного пространства. Если вы не определили собственную структуру, просто заполните ее напрямую. sizeof(struct net_device)
Возвращаемое значение функции: если выполнение успешно, возвращается запрошенный адрес пространства.
Есть еще одна функция распределения пространства. функция alloc_netdev().
alloc_etherdev() — это alloc_netdev() функция «ярлыка» для Ethernet


Зарегистрируйте сетевое устройство
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)
Функция：Отменить регистрацию сетевого устройства
женьшеньчисло:Незарегистрированная структура сетевого устройства

#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
    ГПБ(4) -- сброс
	GPX3(2) — прерывание
*/
static u32 ENC28J60_IRQ; //Номер прерывания

/*Определение базового аппаратного ввода-вывода SPI*/
#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/инициализацию ввода-вывода и т. д.
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 (с кодом операции) 
женьшень	  число:
 		 оп: код операции
		 адрес: адрес регистрации/женьшеньчисло
возвращаться раз Значение: считанные данные
*/
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 (с кодом операции) 
женьшень    число:
		оп: код операции
		адрес: адрес регистрации
		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: длина записываемых данных
		данные: область кэша данных
*/
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.
женьшень    число:
				бан: банк будет установлен
*/
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.
женьшень    число:адрес: адрес регистрации
возвращаться раз Значение: считанные данные
*/
u8 ENC28J60_Read(u8 addr)
{						  
	ENC28J60_Set_Bank(addr);//Установить БАНК		 
	return ENC28J60_Read_Op(ENC28J60_READ_CTRL_REG,addr);
}


/*
Функция: запись данных в указанный регистр ENC28J60.
женьшень    число:
		адрес: адрес регистрации
		данные: данные для записи		
*/
void ENC28J60_Write(u8 addr,u8 data)
{					  
	ENC28J60_Set_Bank(addr);		 
	ENC28J60_Write_Op(ENC28J60_WRITE_CTRL_REG,addr,data);
}


/*
Функция: запись данных в регистр PHY ENC28J60.
женьшень    число:
		адрес: адрес регистрации
		данные: данные для записи	
*/
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	   Установить адрес буфера приема  Емкость 8 КБ
	NextPacketPtr=RXSTART_INIT;
	// Rx start
	//Буфер приема управляется аппаратным циклическим FIFO Буферный состав.
	//Регистрируем пару ERXSTH:ERXSTL иERXNDH:ERXNDL делать
	//Для указателей определите емкость буфера и его расположение в памяти.
	//Байты, на которые указывают ERXST и ERXND, включаются в буфер FIFO.
	//Когда байты данных принимаются из интерфейса Ethernet, эти байты записываются последовательно
	//Получаем буфер. Но когда пишет 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: бит включения одноадресного фильтра
	//Когда ИНДОР = 1 Время://1 = Адрес назначения и локальный MAC Пакеты с несовпадающими адресами будут отброшены.
	//0 = Отключить фильтр
	//Когда ИНДОР = 0 Время://1 = Адрес назначения и локальный MAC Пакеты с совпадающими адресами будут приняты.
	//0 = Отключить фильтр
	//CRCEN: постфильтр CRC Проверьте бит включения//1 = Все CRC Недействительные пакеты будут отброшены
	//0 = CRC не учитывается Это действительно?
	//PMEN: бит включения фильтра соответствия формата
	//Когда ИНДОР = 1 час:	//1 = Пакет должен соответствовать формату соответствия, иначе он будет отброшен.
	//0 = Отключить фильтр
	//Когда ИНДОР = 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 бит очищен до 0, что делает 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 показан ЭКОН1 зарегистрироваться,он используется для контроля
	//ENC28J60 основные функции. ECON1 середина содержит разрешение получения、волосы
	//Отправляем запрос, DMA Биты управления и выбора банка.	   
	ENC28J60_Set_Bank(ECON1);
	// enable interrutps
	//EIE： Разрыв Ethernet-середины позволяет зарегистрироваться
	//bit 7 INTIE： Глобальный ИНТ середина выключена, бит включения	//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; 	  

}

/*
Функция: прочитать ЭРЕВИД
*/
u8 ENC28J60_Get_EREVID(void)
{
	//В ЭРЕВИД Информация о версии также хранится внутри. EREVID это элемент управления только для чтения
	//системазарегистрироваться,содержит 5 Битовый идентификатор, используемый для идентификации конкретного кремния устройства.
	//номер версии
	return ENC28J60_Read(EREVID);
}

/*
Функция: отправлять пакеты данных в сеть через ENC28J60.
женьшень    число:
		len   :размер пакета
        пакет: пакет данных
*/
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: Максимально допустимая длина полученного пакета данных.
		пакет: пакет данныхобласть кэша
возвращаться раз ценить:получатьприезжатьизчисло Длина пакета(байт)	
*/
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");
	}

	 /*Использовать таймер 100 мс*/
	 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)
	{
        /* Если длина кадра меньше минимальной длины кадра Ethernet, добавьте 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. назначение чистой структуры*/
  	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");

#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