⭐ 欢迎来到虫虫下载站！ | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站
📤 上传资源

📄 smsc9118.c

📁 基于pxa270的linux下smsc9118的网卡驱动源码
💻 C
📖 第 1 页 / 共 5 页
字号:
🔍
12345 
				 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_CancelInterrupt(PPRIVATE_DATA privateData);
void Gpt_CancelCallBack(
	PPRIVATE_DATA privateData,
	void (*callBackFunction)(PPRIVATE_DATA privateData));
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_RxCompleteMulticast(PPRIVATE_DATA privateData);
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 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);

void Rx_CompleteMulticastUpdate (PPRIVATE_DATA privateData);
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);
void Rx_BeginMulticastUpdate (PPRIVATE_DATA privateData);

unsigned long Rx_TaskletParameter=0;

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

BOOLEAN RxStop_HandleInterrupt(
	PPRIVATE_DATA privateData,
	DWORD dwIntSts);
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, VL_KEY callerKeyCode);


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)==0x01180000UL)&& \
								 ((privData->dwFpgaRev)>=0x01)&& \
								 ((privData->dwFpgaRev)<=0x25))

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_OFF  (0x00UL)
#define GP_ISR	GP_OFF
#define GP_RX	GP_OFF
#define GP_TX	GP_OFF
#define GP_BEGIN_MULTICAST_UPDATE		GP_OFF
#define GP_COMPLETE_MULTICAST_UPDATE	GP_OFF

#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++;					\
	}								\
}
#ifdef USE_LED1_WORK_AROUND
volatile DWORD g_GpioSettingOriginal;
#endif

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_118.h"

DWORD lan_base=0x0UL;
MODULE_PARM(lan_base,"i");
MODULE_PARM_DESC(lan_base,"Base Address of LAN9118, (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 Smsc9118_init_module(void);
void Smsc9118_cleanup_module(void);
int Smsc9118_init(struct net_device *dev);
int Smsc9118_open(struct net_device *dev);
int Smsc9118_stop(struct net_device *dev);
int Smsc9118_hard_start_xmit(struct sk_buff *skb, struct net_device *dev);
struct net_device_stats * Smsc9118_get_stats(struct net_device *dev);
void Smsc9118_set_multicast_list(struct net_device *dev);
int Smsc9118_do_ioctl(struct net_device *dev, struct ifreq *ifr,int cmd);
irqreturn_t Smsc9118_ISR(int irq,void *dev_id,struct pt_regs *regs);

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

int Smsc9118_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("Date Code: %s",date_code);
	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) {
		SMSC_TRACE("  irq_pol          = %ld, IRQ output is active high",irq_pol);
	} else {
		SMSC_TRACE("  irq_pol          = %ld, IRQ output is active low",irq_pol);
	}
	if(irq_type) {
		SMSC_TRACE("  irq_type         = %ld, IRQ output is Push-Pull driver",irq_type);
	} else {
		SMSC_TRACE("  irq_type         = %ld, IRQ output is Open-Drain buffer",irq_type);
	}
	if(rx_dma<TRANSFER_REQUEST_DMA) {
		if(Platform_IsValidDmaChannel(rx_dma)) {
			SMSC_TRACE(
				   "  rx_dma           = %ld, DMA Channel %ld",rx_dma,rx_dma);
		} else {
			SMSC_WARNING("  rx_dma        = %ld, Invalid Dma Channel",rx_dma);
			rx_dma=TRANSFER_PIO;
			SMSC_WARNING("    resetting rx_dma to %ld, RX will use PIO",rx_dma);
		}
	} else if(rx_dma==TRANSFER_REQUEST_DMA) {
		SMSC_TRACE("  rx_dma           = %ld, RX will try to find available channel",rx_dma);
	} else {
		SMSC_TRACE("  rx_dma           = %ld, RX will use PIO",rx_dma);
	}
	if(tx_dma<TRANSFER_REQUEST_DMA) {
		if(Platform_IsValidDmaChannel(tx_dma)) {
			if(tx_dma!=rx_dma) {
				SMSC_TRACE(
				   "  tx_dma           = %ld, DMA Channel %ld",tx_dma,tx_dma);
			} else {
				SMSC_WARNING("  tx_dma == rx_dma");
				tx_dma=TRANSFER_PIO;
				SMSC_WARNING("    resetting tx_dma to %ld, TX will use PIO",tx_dma);
			}
		} else {
			SMSC_WARNING("  tx_dma        = %ld, Invalid Dma Channel",tx_dma);
			tx_dma=TRANSFER_PIO;
			SMSC_WARNING("    resetting tx_dma to %ld, TX will use PIO",tx_dma);
		}
	} else if(tx_dma==TRANSFER_REQUEST_DMA) {
		SMSC_TRACE("  tx_dma           = %ld, TX will try to find available channel",tx_dma);
	} else {
		SMSC_TRACE("  tx_dma           = %ld, TX will use PIO",tx_dma);
	}
	SMSC_TRACE(    "  dma_threshold    = %ld",dma_threshold);
12345

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -