fastvnet_cs.c

Atmel公司的USB无线局域网卡11 mbps Linux设备驱动

	IF_VERY_LOUD(DbgPrint("<- vnet_tx()\n");)
	return 0;	
}

/********************************************************************
 * INTERRUPT HANDLER
 */
static void vnet_interrupt (int irq, void *dev_id, struct pt_regs *regs)
{
	UCHAR				InterruptStatus;	
   	INTERRUPT_TYPE		InterruptType;			
	struct net_device *dev = (struct net_device *) dev_id;
	struct net_local *local = (struct net_local *) dev->priv;
	PVNet_ADAPTER Adapter = &local->Adapter;		

	int cnt;

	IF_VERY_LOUD(DbgPrint("-> vnet_interrupt(%d)\n", irq);)

	if(!Adapter->IsUp || !(local->link->state & DEV_PRESENT))
		return;
	// Check device
	if (!dev)
	{
		IF_LOUD(DbgPrint("%s: IRQ %d for unknown device!\n", dev_info, irq);)
		return;
	}

	DisableInterrupts(Adapter);
	if (test_and_set_bit(0, (void *)&local->interrupt))
		IF_LOUD(DbgPrint("%s: Warning: IRQ %d Reentering interrupt handler!\n", dev_info, irq);)
		
	ProcessInterrupt(Adapter);
	local->interrupt = 0;
	// Turn back interrupts on (unlock)
	EnableInterrupts(Adapter);
	IF_VERY_LOUD(DbgPrint("<- vnet_interrupt()\n");)
}


VOID UpdateSupportAppInfo(PVNet_ADAPTER Adapter, PDEVICE_CONFIGURATION pDevConfig)
{
	DEVICE_CONFIGURATION DevConfig;
	pDevConfig->StationState			=	Adapter->StationState;
	pDevConfig->OperatingMode			=	Adapter->OperatingMode;
	pDevConfig->Channel					=	Adapter->Channel;
	
	VNetMoveMemory(pDevConfig->SSID, Adapter->DesiredSSID, Adapter->SSID_Size);
	pDevConfig->SSIDlength				=	Adapter->SSID_Size;
	VNetMoveMemory(pDevConfig->BSSID, Adapter->CurrentBSSID, 6);

	pDevConfig->PreambleType			=	Adapter->PreambleType;
    pDevConfig->PowerMgmtMode			=	Adapter->PowerMgmtMode;
   	pDevConfig->TxRate					=	Adapter->DataFramesTxRate;
	pDevConfig->FragmentationThreshold	=	Adapter->FragmentationThreshold;
	pDevConfig->RtsCtsThreshold	 		= 	Adapter->RtsThreshold;
	pDevConfig->Rssi					= 	Adapter->Rssi;
	pDevConfig->LinkQuality				=	40 - Adapter->LinkQuality;
}	

// IO CONTROLS
#ifdef WIRELESS_EXT
#define SuP 	1
#define WeP		2

static int vnet_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
{
 	struct net_local 	*local=(struct net_local *) dev->priv;
 	struct iwreq 	*wrq = (struct iwreq *) rq;
	USHORT 		subcmd;
 	PVNet_ADAPTER 	Adapter = &local->Adapter;
 	ULONG			GenericULong;
 	UCHAR			ApInfoList[MAX_BSS_ENTRIES*sizeof(BSS_INFO)];
 	char 			buff[256];
 	int 			rc=0, update=0, WEP_OR_SUPPORT=0, APindex;
 	DEVICE_CONFIGURATION	DevConfig;
 	
	// check the user. if not superuser return no perm.
	if (IW_IS_SET(cmd) && cmd >= SIOCSIWNAME && !suser())
		return -EPERM;

 	DisableInterrupts(Adapter);
 	UpdateSupportAppInfo(Adapter, &DevConfig);
 	IF_LOUD(DbgPrint("Calling ioctl\n");)
 	switch(cmd)
 	{
	 	case SIOCGIWNAME:	
	 		strcpy(wrq->u.name,"ATMEL WLAN.");
	 		break;	
	 	case SIOCDEVPRIVATE:
	 		subcmd=wrq->u.data.flags;
	 		switch(subcmd)
	 		{
	 			case GET_SUPPORT_INFO:
				  	wrq->u.data.length = sizeof(DEVICE_CONFIGURATION);
				  	copy_to_user(wrq->u.data.pointer, &DevConfig, wrq->u.data.length);
	 				break; 		
				case SET_SUPPORT_INFO:
					copy_from_user(&DevConfig, wrq->u.data.pointer, wrq->u.data.length);
					ChangeConfiguration(Adapter, &DevConfig);
					break;
	 			case GET_WEP_INFO:
	 				wrq->u.data.length = sizeof(WEP_INFO);
	 				copy_to_user(wrq->u.data.pointer, &Adapter->WepInfo, wrq->u.data.length);
	 				break;
 				case SET_WEP_INFO:
	 				copy_from_user(&Adapter->WepInfo,wrq->u.data.pointer,wrq->u.data.length);
	 				ConfigureWEP(Adapter);
	 				ResetAdapter(Adapter);
	 				break;
	 			case GET_VERSION_INFO:
					Adapter->VersionInfo.DriverMajorVersion	= FAST_VNET_MAJOR_VERSION;
					Adapter->VersionInfo.DriverMinorVersion	= FAST_VNET_MINOR_VERSION;
					Adapter->VersionInfo.DriverSubVersion		= FAST_VNET_SUB_VERSION;
					Adapter->VersionInfo.DriverBuild			= FAST_VNET_BUILD;
					Adapter->VersionInfo.FwMajorVersion		= Adapter->HostInfo.MajorVer;
					Adapter->VersionInfo.FwMinorVersion		= Adapter->HostInfo.MinorVer;
					Adapter->VersionInfo.FwSubVersion 		= 0;
					Adapter->VersionInfo.FwBuild				= Adapter->HostInfo.BuildVer;
	 				wrq->u.data.length = sizeof(VERSION_INFO);
	 				copy_to_user(wrq->u.data.pointer, &Adapter->VersionInfo, wrq->u.data.length);
	 				break;
	 			case RESET_CARD:
	 				ResetAdapter(Adapter);break;
				case CLEAR_PACKETS:
					copy_from_user(buff, wrq->u.data.pointer, wrq->u.data.length);
					VNetZeroMemory((PUCHAR)&Adapter->Stats, sizeof(STATISTICS));
					update = 0;
					break;
				case GET_AP_INFO:
					wrq->u.data.length = sizeof(BSS_INFO)*Adapter->BSSListEntries;
					copy_to_user(wrq->u.data.pointer, &Adapter->BSSinfo, wrq->u.data.length);
					break;
				case SITE_SURVEY:
					if(Adapter->SiteSurveyState == SITE_SURVEY_IDLE || Adapter->SiteSurveyState == SITE_SURVEY_COMPLETED)
					{
						Adapter->SiteSurveyState = SITE_SURVEY_IN_PROGRESS;
						Adapter->BSSListEntries = 0;
						Scan(Adapter);
					}
					GenericULong 	 = 0;
					wrq->u.data.length = 0;
					break;
				case STOP_SITE_SURVEY:
					Adapter->SiteSurveyState = SITE_SURVEY_IDLE;
					SelectBSS(Adapter, 0xff); //ff indicates no AP selected
					break;
				case SELECT_AP_BY_INDEX:
					copy_from_user(&APindex, wrq->u.data.pointer, wrq->u.data.length);
					SelectBSS(Adapter, APindex-1);
      				Adapter->SiteSurveyState = SITE_SURVEY_IDLE;
					break;

				case SITE_SURVEY_STATE:
					wrq->u.data.length = sizeof(UCHAR);					
					copy_to_user(wrq->u.data.pointer, &Adapter->SiteSurveyState, wrq->u.data.length);
					break;

				case GET_STATISTICS:
					wrq->u.data.length = sizeof(STATISTICS);
					copy_to_user(wrq->u.data.pointer, &Adapter->Stats, wrq->u.data.length);
					break;

				case GET_MAC_ADDRESS:
					wrq->u.data.length = VNet_LENGTH_OF_ADDRESS;
					copy_to_user(wrq->u.data.pointer, &Adapter->StationAddress, wrq->u.data.length);
					update=0;
					break;					
	 		}
	 		break;

	 		// GETS
	 		case SIOCGIWESSID: // Return Current ESSID to wireless tools
	 			wrq->u.data.flags=1;
	 			wrq->u.data.length=Adapter->SSID_Size;
	 			copy_to_user(wrq->u.data.pointer, Adapter->DesiredSSID, wrq->u.data.length);
	 			break;

			case SIOCGIWMODE:
				switch(Adapter->OperatingMode)
				{
					case AD_HOC_MODE:
						wrq->u.mode=Adapter->OperatingMode;break;
					case INFRASTRUCTURE_MODE:
						wrq->u.mode=0;break;
				// For compatibility with wireless tools
				// AdHoc in wt is 1 and for infrastructure return 0 (Auto in wt)
				}
				break;
			case SIOCGIWNWID: //return -1. This is if ioctl failed and as a result
				return -1;  //wt(wireless tools) won't print a network ID
				break;
			case SIOCGIWNICKN: //same as above, for the nickname
				return -1;
				break;
			case SIOCGIWFRAG: //fragmentation threshold
				wrq->u.frag.value=Adapter->FragmentationThreshold;
				wrq->u.frag.fixed=1;
				break;
			case SIOCGIWRTS: //RTS threshold
				wrq->u.rts.value=Adapter->RtsThreshold;
				wrq->u.rts.fixed=1;
				break;
			case SIOCGIWFREQ: //Return m,e
	            wrq->u.freq.m = Adapter->Channel;
				wrq->u.freq.e = 0;
				break;
			case SIOCGIWAP: //Access Point Address
				VNetMoveMemory(wrq->u.ap_addr.sa_data, Adapter->CurrentBSSID, 6);
				wrq->u.ap_addr.sa_family = ARPHRD_ETHER;
				break;
			case SIOCGIWPOWER: //Power Management
				return -1;
				break;
			case SIOCGIWENCODE:
				wrq->u.data.length=sizeof(WEP_INFO);
				wrq->u.data.flags=IW_ENCODE_DISABLED; //Wrong...for the moment
				copy_to_user(wrq->u.data.pointer, &Adapter->WepInfo, wrq->u.data.length);
				break;
			case SIOCGIWRATE: //Bitrate Used
				wrq->u.bitrate.fixed=0;
				switch(Adapter->DataFramesTxRate)
				{
					case 0:
						wrq->u.bitrate.value=1e6;
						break;
					case 1:
						wrq->u.bitrate.value=2e6;
						break;
					case 2:
						wrq->u.bitrate.value=5.5e6;
						break;
					case 3:
						wrq->u.bitrate.value=11e6;
						break;
					default:
						wrq->u.bitrate.value=2e9;
						break;
				}
				break;	
			case SIOCGIWSENS://AP Density. Currently not supported
				return -1;
				break;
 			// Sets
 			case SIOCSIWESSID://ESSID change
				VNetMoveMemory(DevConfig.SSID, wrq->u.data.pointer, wrq->u.data.length);
				DevConfig.SSIDlength		=	wrq->u.data.length;
 				IF_VERY_LOUD(DbgPrint("New ESSID %s.\n",DevConfig.SSID);)
 				update=1;
 				WEP_OR_SUPPORT=SuP;
 				break;
 			case SIOCSIWRTS:
 				DevConfig.RtsCtsThreshold=wrq->u.rts.value;
 				update=1;
				WEP_OR_SUPPORT=SuP;
 				break;
 			case SIOCSIWFRAG:
				DevConfig.FragmentationThreshold=wrq->u.frag.value;
 				update=1;
 				WEP_OR_SUPPORT=SuP;
 				break;
 			case SIOCSIWMODE:
 				if ( (wrq->u.mode<0)||(wrq->u.mode>1) )
 					return -3;
				DevConfig.OperatingMode=2-wrq->u.mode;
 				update=1;
 				WEP_OR_SUPPORT=SuP;
 				break;
 			case SIOCGIWRANGE:
 				return -1;
				break;
 	}
	// After Getting Request Check if Updates are Needed and if so
	// Run Configure_WEP(1) or ChangeConfiguration(2)
 	if (update==1)
	{
 		switch(WEP_OR_SUPPORT)
		{
 			case WeP:
				ConfigureWEP(Adapter);
 				ResetAdapter(Adapter);
				break;
 			case SuP:
				ChangeConfiguration(Adapter, &DevConfig);
				//Reset ?
				break;
 			default:
				//Case of error
 				return -1;
				break;
 		}
		update=0;
	}
 	EnableInterrupts(Adapter);
	return rc;
}

// Iwconfig statistics...
struct iw_statistics *vnet_get_wireless_stats (struct net_device *dev)
{
	struct net_local *local = (struct net_local *) dev->priv;
	PVNet_ADAPTER Adapter = &local->Adapter;
	local->wstats.status=0;
	IF_VERY_LOUD(DbgPrint("-> vnet_get_wireless_stats(%s)\n", dev->name);)

	if (Adapter->OperatingMode == INFRASTRUCTURE_MODE)
	{
       	local->wstats.qual.qual 		= 40 - Adapter->LinkQuality;
       	local->wstats.qual.level 		= Adapter->Rssi;
		local->wstats.qual.noise 		= 0;//max(min(ltv.noise_lvl, 0x8a), 0x2f) - 0x95;
		local->wstats.qual.updated 		= 7;
	}
	else
	{
		// Quality levels cannot be determined in ad-hoc mode,
		// because we can 'hear' more that one remote station.
		local->wstats.qual.qual		= 0;
		local->wstats.qual.level	= 0;
		local->wstats.qual.noise	= 0;
		local->wstats.qual.updated	= 0;
	}
	// Packets discarded in the wireless adapter due to wireless specific problems
	local->wstats.discard.nwid = 0;
	local->wstats.discard.code = 0;
	local->wstats.discard.misc = 0;
	IF_VERY_LOUD(DbgPrint("<- vnet_get_wireless_stats()\n");)
	return (&local->wstats);
}
#endif

// Show CardServices error message (syslog)
static void cs_error (client_handle_t handle, int func, int ret)
{
	error_info_t err = { func, ret };
	CardServices(ReportError, handle, &err);
}


// Kernel Specific Functions

VOID SetMgmtTimer(PVNet_ADAPTER Adapter)
{
#if (LINUX_VERSION_CODE < VERSION(2,3,0))
    	if(Adapter->MgmtTimer.prev == (struct timer_list *) NULL)
	{
      		/* set timer to expire in WATCHDOG_JIFFIES */
      		Adapter->MgmtTimer.expires = jiffies + MGMT_JIFFIES;
      		add_timer(&Adapter->MgmtTimer);
    	}
#else
    if(Adapter->MgmtTimer.list.prev == (struct list_head *) NULL)
	{
      		/* set timer to expire in WATCHDOG_JIFFIES */
      		Adapter->MgmtTimer.expires = jiffies + MGMT_JIFFIES;
      		add_timer(&Adapter->MgmtTimer);
	}
#endif
}

VOID VnetSleep(ULONG stime)
{
	ULONG j = jiffies + HZ;
	while(jiffies < j)
	{
		schedule();
	}
}

VOID 
VNet_netif_wake_queue(PVNet_ADAPTER Adapter)
{
	netif_wake_queue(Adapter->dev);
}

VOID RxIndicatePacket(PVNet_ADAPTER Adapter, PUCHAR pRxBuf, ULONG PacketLength, ULONG IndicateLen)
{
	struct net_device *dev = (struct net_device *) Adapter->dev;
	struct sk_buff 	*skb;
	
	skb = dev_alloc_skb(PacketLength+2);	
	if(!skb)
    {		
		Adapter->Stats.RxLost++;
      	return;
	}
	skb_reserve(skb, 2);
	VNetMoveMemory(skb_put(skb, PacketLength), pRxBuf, PacketLength);
	Adapter->dev->last_rx=jiffies;
	skb->dev = dev;
	skb->protocol = eth_type_trans(skb, dev);
	skb->ip_summed = CHECKSUM_NONE;	
	netif_rx(skb);
	return;
}

#ifdef RFMD
#include "rfmd\fw.h"
#else
#include "fw.h"
#endif
BOOLEAN OpenFwFile(PVNet_ADAPTER Adapter)
{
	ULONG	SoFw = sizeof(BasicFW);
	
	IF_LOUD(DbgPrint("--=+>OpenFwFile BasicFW : %d, \n",SoFw);)

	Adapter->MappedFirmwareBuffer = kmalloc(SoFw, GFP_ATOMIC);
	IF_LOUD(DbgPrint("Fw Mapped in : 0x%08X\n",Adapter->MappedFirmwareBuffer);)
	VNetZeroMemory(Adapter->MappedFirmwareBuffer, SoFw);;
	VNetMoveMemory(Adapter->MappedFirmwareBuffer, BasicFW, SoFw);
	Adapter->FirmwareFileLength = SoFw;
	IF_LOUD(DbgPrint("<=- Out of OpenFwFile\n");)
	return TRUE;
}