smsc911x.c

smsc911x 网卡驱动 This the users/programmers guide for the LAN911x Linux Driver The following sections

#define PHY_ANEG_ADV_100H_	((WORD)0x80)
#define PHY_ANEG_ADV_100F_	((WORD)0x100)
#define PHY_ANEG_ADV_SPEED_	((WORD)0x1E0)

#define PHY_ANEG_LPA	((DWORD)5U)
#define PHY_ANEG_LPA_ASYMP_		((WORD)0x0800)
#define PHY_ANEG_LPA_SYMP_		((WORD)0x0400)
#define PHY_ANEG_LPA_100FDX_	((WORD)0x0100)
#define PHY_ANEG_LPA_100HDX_	((WORD)0x0080)
#define PHY_ANEG_LPA_10FDX_		((WORD)0x0040)
#define PHY_ANEG_LPA_10HDX_		((WORD)0x0020)

#define PHY_MODE_CTRL_STS		((DWORD)17)	// Mode Control/Status Register
	#define MODE_CTRL_STS_FASTRIP_		((WORD)0x4000U)
	#define MODE_CTRL_STS_EDPWRDOWN_	((WORD)0x2000U)
	#define MODE_CTRL_STS_LOWSQEN_		((WORD)0x0800U)
	#define MODE_CTRL_STS_MDPREBP_		((WORD)0x0400U)
	#define MODE_CTRL_STS_FARLOOPBACK_	((WORD)0x0200U)
	#define MODE_CTRL_STS_FASTEST_		((WORD)0x0100U)
	#define MODE_CTRL_STS_REFCLKEN_		((WORD)0x0010U)
	#define MODE_CTRL_STS_PHYADBP_		((WORD)0x0008U)
	#define MODE_CTRL_STS_FORCE_G_LINK_	((WORD)0x0004U)
	#define MODE_CTRL_STS_ENERGYON_		((WORD)0x0002U)

#define PHY_INT_SRC			((DWORD)29)
#define PHY_INT_SRC_ENERGY_ON_			((WORD)0x0080U)
#define PHY_INT_SRC_ANEG_COMP_			((WORD)0x0040U)
#define PHY_INT_SRC_REMOTE_FAULT_		((WORD)0x0020U)
#define PHY_INT_SRC_LINK_DOWN_			((WORD)0x0010U)

#define PHY_INT_MASK		((DWORD)30)
#define PHY_INT_MASK_ENERGY_ON_		((WORD)0x0080U)
#define PHY_INT_MASK_ANEG_COMP_		((WORD)0x0040U)
#define PHY_INT_MASK_REMOTE_FAULT_	((WORD)0x0020U)
#define PHY_INT_MASK_LINK_DOWN_		((WORD)0x0010U)

#define PHY_SPECIAL			((DWORD)31)
#define PHY_SPECIAL_SPD_	((WORD)0x001CU)
#define PHY_SPECIAL_SPD_10HALF_		((WORD)0x0004U)
#define PHY_SPECIAL_SPD_10FULL_		((WORD)0x0014U)
#define PHY_SPECIAL_SPD_100HALF_	((WORD)0x0008U)
#define PHY_SPECIAL_SPD_100FULL_	((WORD)0x0018U)

BOOLEAN Phy_Initialize(
	PPRIVATE_DATA privateData,
	DWORD dwPhyAddress,
	DWORD dwLinkMode);
void Phy_SetLink(PPRIVATE_DATA privateData,
				 DWORD dwLinkRequest);
WORD Phy_GetRegW(
	PPRIVATE_DATA privateData,
	DWORD dwRegIndex,
	VL_KEY keyCode);
void Phy_SetRegW(
	PPRIVATE_DATA privateData,
	DWORD dwRegIndex,
	WORD wVal,
	VL_KEY keyCode);
void Phy_UpdateLinkMode(
	PPRIVATE_DATA privateData);
void Phy_GetLinkMode(
	PPRIVATE_DATA privateData,
	VL_KEY keyCode);
void Phy_CheckLink(unsigned long ptr);

TIME_SPAN Gpt_FreeRunCompare(DWORD time1,DWORD time2);
void Gpt_ScheduleInterrupt(PPRIVATE_DATA privateData,TIME_SPAN timeSpan);
void Gpt_ScheduleCallBack(
	PPRIVATE_DATA privateData,
	void (*callBackFunction)(PPRIVATE_DATA privateData),
	DWORD callBackTime);//100uS units relative to now
BOOLEAN Gpt_HandleInterrupt(
	PPRIVATE_DATA privateData,DWORD dwIntSts);
void GptCB_RestartBurst(PPRIVATE_DATA privateData);
void GptCB_MeasureRxThroughput(PPRIVATE_DATA privateData);

void Tx_Initialize(
	PPRIVATE_DATA privateData,
	DWORD dwTxDmaCh,
	DWORD dwTxDmaThreshold);
void Tx_SendSkb(
	PPRIVATE_DATA privateData,
	struct sk_buff *skb);
BOOLEAN Tx_HandleInterrupt(
	PPRIVATE_DATA privateData,DWORD dwIntSts);

void Tx_StopQueue(
	PPRIVATE_DATA privateData,DWORD dwSource);
void Tx_WakeQueue(
	PPRIVATE_DATA privateData,DWORD dwSource);

static void Tx_WriteFifo(
	PPRIVATE_DATA privateData,
	DWORD *pdwBuf,
	DWORD dwDwordCount);
static DWORD Tx_GetTxStatusCount(
	PPRIVATE_DATA privateData);
static DWORD Tx_CompleteTx(
	PPRIVATE_DATA privateData);
void Tx_UpdateTxCounters(
	PPRIVATE_DATA privateData);

void Tx_CompleteDma(
	PPRIVATE_DATA privateData);


void Rx_Initialize(
	PPRIVATE_DATA privateData,
	DWORD dwRxDmaCh,
	DWORD dwDmaThreshold);

static void Rx_ReadFifo(
	PPRIVATE_DATA privateData,
	DWORD *pdwBuf,
	DWORD dwDwordCount);
static void Rx_HandleOverrun(PPRIVATE_DATA privateData);
static void Rx_HandOffSkb(
	PPRIVATE_DATA privateData,
	struct sk_buff *skb);
static DWORD Rx_PopRxStatus(
	PPRIVATE_DATA privateData);
void Rx_CountErrors(PPRIVATE_DATA privateData,DWORD dwRxStatus);
void Rx_FastForward(PPRIVATE_DATA privateData,DWORD dwDwordCount);
void Rx_ProcessPackets(PPRIVATE_DATA privateData);

unsigned long Rx_TaskletParameter=0;

void Rx_ProcessPacketsTasklet(unsigned long data);
DECLARE_TASKLET(Rx_Tasklet,Rx_ProcessPacketsTasklet,0);

BOOLEAN Rx_HandleInterrupt(
	PPRIVATE_DATA privateData,
	DWORD dwIntSts);
static DWORD Rx_Hash(BYTE addr[6]);

void Rx_SetMulticastList(
	struct net_device *dev);
void Rx_ReceiverOff(
	PPRIVATE_DATA privateData);
void Rx_ReceiverOn(
	PPRIVATE_DATA privateData);


void Eeprom_EnableAccess(PPRIVATE_DATA privateData);
void Eeprom_DisableAccess(PPRIVATE_DATA privateData);

BOOLEAN Eeprom_IsMacAddressLoaded(PPRIVATE_DATA privateData);
BOOLEAN Eeprom_IsBusy(PPRIVATE_DATA privateData);
BOOLEAN Eeprom_Timeout(PPRIVATE_DATA privateData);

BOOLEAN Eeprom_ReadLocation(
	PPRIVATE_DATA privateData,BYTE address, BYTE * data);
BOOLEAN Eeprom_EnableEraseAndWrite(
	PPRIVATE_DATA privateData);
BOOLEAN Eeprom_DisableEraseAndWrite(
	PPRIVATE_DATA privateData);
BOOLEAN Eeprom_WriteLocation(
	PPRIVATE_DATA privateData,BYTE address,BYTE data);
BOOLEAN Eeprom_EraseAll(
	PPRIVATE_DATA privateData);
BOOLEAN Eeprom_Reload(
	PPRIVATE_DATA privateData);

BOOLEAN Eeprom_SaveMacAddress(
	PPRIVATE_DATA privateData,
	DWORD dwHi16,DWORD dwLo32);


#define OLD_REGISTERS(privData) (((privData->dwIdRev&0x0000FFFFUL)==0UL)&& \
								 ((privData->dwFpgaRev)>=0x01)&& \
								 ((privData->dwFpgaRev)<=0x25))

#define IS_REV_A(privData)	((privData->dwIdRev&0x0000FFFFUL)==0UL)

extern volatile DWORD g_GpioSetting;
extern DWORD debug_mode;
#define GP_0	(0x01UL)
#define GP_1	(0x02UL)
#define GP_2	(0x04UL)
#define GP_3	(0x08UL)
#define GP_4	(0x10UL)
#define GP_ISR	GP_0
#define GP_RX	GP_1
#define GP_TX	GP_2

#define SET_GPIO(gpioBit)					\
if(debug_mode&0x04UL) {						\
	g_GpioSetting|=gpioBit;					\
	Lan_SetRegDW(GPIO_CFG,g_GpioSetting);	\
}

#define CLEAR_GPIO(gpioBit)					\
if(debug_mode&0x04UL) {						\
	g_GpioSetting&=(~gpioBit);				\
	Lan_SetRegDW(GPIO_CFG,g_GpioSetting);	\
}

#define PULSE_GPIO(gpioBit,count)	\
if(debug_mode&0x04UL) {				\
	DWORD pulseNum=0;				\
	/*make first pulse longer */	\
	SET_GPIO(gpioBit);				\
	while(pulseNum<count) {			\
		SET_GPIO(gpioBit);			\
		CLEAR_GPIO(gpioBit);		\
		pulseNum++;					\
	}								\
}

BOOLEAN Lan_Initialize(
	PPRIVATE_DATA privateData,DWORD dwIntCfg,
	DWORD dwTxFifSz,DWORD dwAfcCfg);
void Lan_EnableInterrupt(PPRIVATE_DATA privateData,DWORD dwIntEnMask);
void Lan_DisableInterrupt(PPRIVATE_DATA privateData,DWORD dwIntEnMask);
void Lan_EnableIRQ(PPRIVATE_DATA privateData);
void Lan_DisableIRQ(PPRIVATE_DATA privateData);
void Lan_SetIntDeas(PPRIVATE_DATA privateData,DWORD dwIntDeas);
void Lan_SetTDFL(PPRIVATE_DATA privateData,BYTE level);
void Lan_SetTSFL(PPRIVATE_DATA privateData,BYTE level);
void Lan_SetRDFL(PPRIVATE_DATA privateData,BYTE level);
void Lan_SetRSFL(PPRIVATE_DATA privateData,BYTE level);

void Lan_SignalSoftwareInterrupt(PPRIVATE_DATA privateData);
BOOLEAN Lan_HandleSoftwareInterrupt(PPRIVATE_DATA privateData,DWORD dwIntSts);

void Lan_ShowRegs(PPRIVATE_DATA privateData);

#include "ioctl_11x.h"


DWORD lan_base=0x0UL;
MODULE_PARM(lan_base,"i");
MODULE_PARM_DESC(lan_base,"Base Address of LAN911x, (default: choosen by platform code)");

DWORD bus_width=0UL;
MODULE_PARM(bus_width,"i");
MODULE_PARM_DESC(bus_width,"Force bus width of 16 or 32 bits, default: autodetect");

DWORD link_mode=0x7FUL;
MODULE_PARM(link_mode,"i");
MODULE_PARM_DESC(link_mode,"Set Link speed and Duplex, 1=10HD,2=10FD,4=100HD,8=100FD,default=0xF");

DWORD irq=PLATFORM_IRQ;
MODULE_PARM(irq,"i");
MODULE_PARM_DESC(irq,"Force use of specific IRQ, (default: choosen by platform code)");

DWORD int_deas=0xFFFFFFFFUL;
MODULE_PARM(int_deas,"i");
MODULE_PARM_DESC(int_deas,"Interrupt Deassertion Interval in 10uS units");

DWORD irq_pol=PLATFORM_IRQ_POL;
MODULE_PARM(irq_pol,"i");
MODULE_PARM_DESC(irq_pol,"IRQ Polarity bit, see definition of INT_CFG register");

DWORD irq_type=PLATFORM_IRQ_TYPE;
MODULE_PARM(irq_type,"i");
MODULE_PARM_DESC(irq_type,"IRQ Buffer Type bit, see definition of INT_CFG register");

DWORD rx_dma=PLATFORM_RX_DMA;
MODULE_PARM(rx_dma,"i");
MODULE_PARM_DESC(rx_dma,"Receiver DMA Channel, 255=find available channel, 256=use PIO");

DWORD tx_dma=PLATFORM_TX_DMA;
MODULE_PARM(tx_dma,"i");
MODULE_PARM_DESC(tx_dma,"Transmitter DMA Channel, 255=find available channel, 256=use PIO");

DWORD dma_threshold=PLATFORM_DMA_THRESHOLD;
MODULE_PARM(dma_threshold,"i");
MODULE_PARM_DESC(dma_threshold,"Specifies the minimum packet size for DMA to be used.");

DWORD mac_addr_hi16=0xFFFFFFFFUL;
MODULE_PARM(mac_addr_hi16,"i");
MODULE_PARM_DESC(mac_addr_hi16,"Specifies the high 16 bits of the mac address");

DWORD mac_addr_lo32=0xFFFFFFFFUL;
MODULE_PARM(mac_addr_lo32,"i");
MODULE_PARM_DESC(mac_addr_lo32,"Specifies the low 32 bits of the mac address");

#ifdef USE_DEBUG
DWORD debug_mode=0x7UL;
#else
DWORD debug_mode=0x0UL;
#endif
MODULE_PARM(debug_mode,"i");
MODULE_PARM_DESC(debug_mode,"bit 0 enables trace points, bit 1 enables warning points, bit 2 enables gpios");

DWORD tx_fif_sz=0x00050000UL;
MODULE_PARM(tx_fif_sz,"i");
MODULE_PARM_DESC(tx_fif_sz,"Specifies TX_FIF_SZ of the HW_CFG register");

DWORD afc_cfg=0xFFFFFFFFUL;
MODULE_PARM(afc_cfg,"i");
MODULE_PARM_DESC(afc_cfg,"Specifies the setting for the AFC_CFG register");

DWORD tasklets=1UL;
MODULE_PARM(tasklets,"i");
MODULE_PARM_DESC(tasklets,"non-zero== use tasklets for receiving packets, zero==receive packets in ISR");

DWORD phy_addr=0xFFFFFFFFUL;
MODULE_PARM(phy_addr,"i");
MODULE_PARM_DESC(phy_addr,"phy_addr, 0xFFFFFFFF=use interal phy, 0-31=use external phy with specified address, else autodetect external phy addr");

DWORD max_throughput=0xFFFFFFFFUL;
MODULE_PARM(max_throughput,"i");
MODULE_PARM_DESC(max_throughput,"See readme.txt");

DWORD max_packet_count=0xFFFFFFFFUL;
MODULE_PARM(max_packet_count,"i");
MODULE_PARM_DESC(max_packet_count,"See Readme.txt");

DWORD packet_cost=0xFFFFFFFFUL;
MODULE_PARM(packet_cost,"i");
MODULE_PARM_DESC(packet_cost,"See Readme.txt");

DWORD burst_period=0xFFFFFFFFUL;
MODULE_PARM(burst_period,"i");
MODULE_PARM_DESC(burst_period,"See Readme.txt");

DWORD max_work_load=0xFFFFFFFFUL;
MODULE_PARM(max_work_load,"i");
MODULE_PARM_DESC(max_work_load,"See Readme.txt");

MODULE_LICENSE("GPL");

int Smsc911x_init_module(void);
void Smsc911x_cleanup_module(void);
int Smsc911x_init(struct net_device *dev);
int Smsc911x_open(struct net_device *dev);
int Smsc911x_stop(struct net_device *dev);
int Smsc911x_hard_start_xmit(struct sk_buff *skb, struct net_device *dev);
struct net_device_stats * Smsc911x_get_stats(struct net_device *dev);
void Smsc911x_set_multicast_list(struct net_device *dev);
int Smsc911x_do_ioctl(struct net_device *dev, struct ifreq *ifr,int cmd);
irqreturn_t Smsc911x_ISR(int irq,void *dev_id,struct pt_regs *regs);

#ifdef USING_LINT
struct net_device SMSC911x;
#else //not USING_LINT
struct net_device SMSC911x = {init: Smsc911x_init,};
#endif //not USING_LINT

int Smsc911x_init_module(void)
{
	int result=0;
	int device_present=0;
	SMSC_TRACE("--> init_module()");
	SMSC_TRACE("Driver Version = %lX.%02lX",
		(DRIVER_VERSION>>8),(DRIVER_VERSION&0xFFUL));
	SMSC_TRACE("Compiled: %s, %s",__DATE__,__TIME__);
	SMSC_TRACE("Platform: %s",PLATFORM_NAME);
	SMSC_TRACE("Driver Parameters");
	if(lan_base==0UL) {
		SMSC_TRACE("  lan_base         = 0x%08lX, driver will decide",lan_base);
	} else {
		SMSC_TRACE("  lan_base         = 0x%08lX",lan_base);
	}
	if((bus_width==16UL)||(bus_width==32UL)) {
		SMSC_TRACE("  bus_width        = %ld",bus_width);
	} else {
		SMSC_TRACE("  bus_width        = %ld, driver will autodetect",bus_width);
	}
	if(link_mode>0x7FUL) {
		SMSC_WARNING("  link_mode     = %ld, Unknown",link_mode);
		link_mode=0x7FUL;
		SMSC_WARNING("    resetting link_mode to %ld, 100FD,100HD,10FD,10HD,ASYMP,SYMP,ANEG",link_mode);
	} else if(link_mode==0UL) {
		SMSC_TRACE("  link_mode        = %ld, LINK_OFF",link_mode);
	} else {
		SMSC_TRACE("  link_mode        = 0x%lX, %s,%s,%s,%s,%s,%s,%s",
			link_mode,
			(link_mode&LINK_SPEED_10HD)?"10HD":"",
			(link_mode&LINK_SPEED_10FD)?"10FD":"",
			(link_mode&LINK_SPEED_100HD)?"100HD":"",
			(link_mode&LINK_SPEED_100FD)?"100FD":"",
			(link_mode&LINK_ASYMMETRIC_PAUSE)?"ASYMP":"",
			(link_mode&LINK_SYMMETRIC_PAUSE)?"SYMP":"",
			(link_mode&LINK_AUTO_NEGOTIATE)?"ANEG":"");
	}
	SMSC_TRACE(    "  irq              = %ld",irq);
	if(int_deas!=0xFFFFFFFFUL) {
		if(int_deas>0xFFUL) {
			SMSC_WARNING("  int_deas     = %ld, too high",int_deas);
			int_deas=0xFFFFFFFFUL;
			SMSC_WARNING("    resetting int_deas to %ld",int_deas);
		}
	}
	if(int_deas==0xFFFFFFFFUL) {
		SMSC_TRACE(    "  int_deas         = 0x%08lX, use platform default",int_deas);
	} else {
		SMSC_TRACE(    "  int_deas         = %ld, %lduS",int_deas,10UL*int_deas);
	}
	if(irq_pol) {