vnetusba.c

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

#include <linux/module.h>
#include <linux/wireless.h>
#include "vnetusba.h"
#include <linux/string.h>
#include "vnetioctl.h"

struct usb_device_id __devinitdata vnet_usb_id[] = {
		{USB_DEVICE(VNetVID, VNetPID)},
		{USB_DEVICE(VNetVID, VNetPID_RFMD)},
		{ }
};

struct usb_driver vnet_driver = {
 	name: 		"vnetusba",
	probe:		usb_vnet_probe,
	disconnect:	usb_vnet_disconnect,
	id_table:	vnet_usb_id,
};

void mod_use(UCHAR a, PVNet_ADAPTER Adapter)
{
	if(a)
	{
		Adapter->CallbacksPending++;
		MOD_INC_USE_COUNT;
	}
	else
	{
		Adapter->CallbacksPending--;
		MOD_DEC_USE_COUNT;
	}
}
void ChangeState(PVNet_ADAPTER Adapter, UCHAR State)
{
	if( (Adapter->StationState == STATION_STATE_READY)&&(Adapter->StationState!=State) )
		netif_stop_queue(Adapter->net);

	if( (Adapter->StationState != State) && (State == STATION_STATE_READY) )
  {
  	if(Adapter->StationState != STATION_STATE_ASSOCIATING)
			netif_wake_queue(Adapter->net);
		else
			netif_start_queue(Adapter->net);
	}
	Adapter->StationState = State;
}

void VNetwake_queue(struct net_device *dev)
{
	netif_wake_queue(dev);
}

static int usb_vnet_open(struct net_device *dev)
{	
	PVNet_ADAPTER 	Adapter = (PVNet_ADAPTER)dev->priv;
	UCHAR           i;	

	if( (Adapter->StationState == STATION_STATE_INITIALIZING)||
		(Adapter->StationState == STATION_STATE_FW_DOWNLOAD) )
		return -1;
	
	Adapter->flags |= VNET_RUNNING;
	
	if(Adapter->flags & STOPPED_RX)
		UsbRxInit(Adapter);
	
	if(Adapter->StationState == STATION_STATE_READY)
		netif_wake_queue(Adapter->net);
	return 0;
}

static int usb_vnet_close(struct net_device *dev)
{
	PVNet_ADAPTER Adapter = (PVNet_ADAPTER)dev->priv;
	dbgusbnl("")
	Adapter->flags &= ~VNET_RUNNING;
	netif_stop_queue(Adapter->net);
	return 0;
}

static struct net_device_stats * usb_vnet_net_stats(struct net_device *dev)
{
	if(!dev->priv)
		return NULL;
 	return &((PVNet_ADAPTER)dev->priv)->netstats;
}

static struct iw_statistics * wireless_stats(struct net_device *dev)
{
	PVNet_ADAPTER Adapter = (PVNet_ADAPTER)dev->priv;
	Adapter->w_stats.qual.qual 	= (40-Adapter->LinkQuality)*10/4;
	Adapter->w_stats.qual.level = ((Adapter->Rssi>40)?40:Adapter->Rssi)*10/4;
	Adapter->w_stats.qual.updated = 1;
	return (&Adapter->w_stats);
}

static int usb_vnet_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
	PVNet_ADAPTER 				Adapter = (PVNet_ADAPTER)dev->priv;
	struct iwreq					*wrq = (struct iwreq *)ifr;
	UCHAR									old_EncL = Adapter->WepInfo.EncryptionLevel;
 	DEVICE_CONFIGURATION	DevConfig;
 	VERSION_INFO					VersionInfo;
 	unsigned							flags;
 	int										AP_Selected;
	
 	if(	(Adapter->StationState == STATION_STATE_INITIALIZING)||
 		(Adapter->StationState == STATION_STATE_FW_DOWNLOAD))
 		return -EIO;
 	
 	if(Adapter->flags & IOCTL_SLEEPING)
		return -EINPROGRESS;
 	spin_lock_irqsave(&Adapter->lock, flags);
	UpdateAppInfo(Adapter, &DevConfig);
    switch(cmd)
    {
    	case SIOCGIWNAME:
    		if(Adapter->BoardType == Normal_Board)
	    		strcpy(wrq->u.name, "ATMEL USB503A");
	    	else
	    		strcpy(wrq->u.name, "ATMEL RFMD503A");
    		break;
	 	case SIOCDEVPRIVATE:
	 		switch(wrq->u.data.flags)
	 		{
	 			case GET_SUPPORT_INFO:
	 			// Give our configuration to the user
				  	wrq->u.data.length = sizeof(DEVICE_CONFIGURATION);
				  	copy_to_user(wrq->u.data.pointer, &DevConfig, wrq->u.data.length);
	 				break;
				case SET_SUPPORT_INFO:
				// Set config we got from the user
					copy_from_user(&DevConfig, wrq->u.data.pointer, wrq->u.data.length);
					if(!ValidateChannel(Adapter, DevConfig.Channel))
					{
						dbgusbnl("Trying to set invalid channel")
						return -EINVAL;
					}
					ChangeConfiguration(Adapter, &DevConfig);
					break;
	 			case GET_WEP_INFO:
	 				{	 			
	 					WEP_INFO TmpWep;
	 					wrq->u.data.length = sizeof(WEP_INFO);
	 					memcpy(&TmpWep, &Adapter->WepInfo, wrq->u.data.length);
	 					if(Adapter->PrivacyInvoked==0)
	 						TmpWep.EncryptionLevel = 0;
						copy_to_user(wrq->u.data.pointer, &TmpWep, wrq->u.data.length);
					}
	 				break;
 				case SET_WEP_INFO:
 					copy_from_user(&Adapter->WepInfo, wrq->u.data.pointer, wrq->u.data.length);
  					if(Adapter->WepInfo.EncryptionLevel==0)
 					{
 						Adapter->PrivacyInvoked = 0;
 						Adapter->WepInfo.EncryptionLevel= old_EncL;
 					}
 					else
 						Adapter->PrivacyInvoked = 1;
 					dbgusbnl("%d %02x", Adapter->WepInfo.AuthenticationType, Adapter->WepInfo.WepKey1[0])
 					Adapter->flags &= ~WepIsSet;

					if(Adapter->StationState==STATION_STATE_SCANNING)
						break;
					
					spin_unlock_irqrestore(&Adapter->lock, flags);
					if(Adapter->flags & GetCommandPedding)
					{
						DECLARE_WAITQUEUE(wait, current);
						add_wait_queue(&Adapter->ctrl_wait, &wait);
						set_current_state(TASK_INTERRUPTIBLE);
						Adapter->flags |= IOCTL_SLEEPING;						
						schedule();						
						set_current_state(TASK_RUNNING);
						remove_wait_queue(&Adapter->ctrl_wait, &wait);
					}
					dbgusbnl("Setting Wep")
					SetWEPvalue(Adapter);
 					return 0;
	 			case GET_VERSION_INFO:
					VersionInfo.DriverMajorVersion	= USB_VNET_MAJOR_VERSION;
					VersionInfo.DriverMinorVersion	= USB_VNET_MINOR_VERSION;
					VersionInfo.DriverSubVersion	= USB_VNET_SUB_VERSION;
					VersionInfo.DriverBuild			= USB_VNET_BUILD;
					VersionInfo.FwMajorVersion		= (USHORT)Adapter->FwVersion[0];
					VersionInfo.FwMinorVersion		= (USHORT)Adapter->FwVersion[1];
					VersionInfo.FwSubVersion 		= (USHORT)0;
					VersionInfo.FwBuild				= (USHORT)Adapter->FwVersion[3];
	 				wrq->u.data.length = sizeof(VERSION_INFO);
	 				copy_to_user(wrq->u.data.pointer, &VersionInfo, wrq->u.data.length);
	 				break;
				case CLEAR_PACKETS:
					memset((PUCHAR)&Adapter->Stats, 0, sizeof(STATISTICS));
					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 = 6;
					copy_to_user(wrq->u.data.pointer, Adapter->StationAddress, wrq->u.data.length);
					break;
				case SITE_SURVEY:
					spin_unlock_irqrestore(&Adapter->lock, flags);
					if(Adapter->flags & GetCommandPedding)
					{
						DECLARE_WAITQUEUE(wait, current);
						add_wait_queue(&Adapter->ctrl_wait, &wait);
						set_current_state(TASK_INTERRUPTIBLE);
						Adapter->flags |= IOCTL_SLEEPING;						
						schedule();						
						set_current_state(TASK_RUNNING);
						remove_wait_queue(&Adapter->ctrl_wait, &wait);
					}
					ChangeState(Adapter, STATION_STATE_SCANNING);
					Adapter->flags |= SITE_SURVEY_REQUEST;
					DropPendingTxPackets(Adapter);
					UsbScan(Adapter);
					return;
				case SITE_SURVEY_STATE:
					if(Adapter->StationState != STATION_STATE_SCANNING)
						*wrq->u.data.pointer = 2;//SITE_SURVEY_COMPLETED
					break;
				case GET_AP_INFO:
					wrq->u.data.length = Adapter->SiteS.BSSInList * sizeof(BSS_INFO);
					if(Adapter->SiteS.BSSInList == 0)
						return 0;
					copy_to_user(wrq->u.data.pointer, Adapter->SiteS.BssInfo, wrq->u.data.length);
					break;
				case STOP_SITE_SURVEY:
					Adapter->StationState = STATION_STATE_JOINING;
					UsbJoin(Adapter);
					break;
				case SELECT_AP_BY_INDEX:
					AP_Selected = *wrq->u.data.pointer-1;
					spin_unlock_irqrestore(&Adapter->lock, flags);
					if(Adapter->flags & GetCommandPedding)
					{
						DECLARE_WAITQUEUE(wait, current);
						add_wait_queue(&Adapter->ctrl_wait, &wait);
						set_current_state(TASK_INTERRUPTIBLE);
						Adapter->flags |= IOCTL_SLEEPING;
						schedule();						
						set_current_state(TASK_RUNNING);
						remove_wait_queue(&Adapter->ctrl_wait, &wait);
					}
					Adapter->SSID_size = Adapter->SiteS.BssInfo[AP_Selected].SSIDsize;
					Adapter->DesiredSSIDsize = Adapter->SSID_size;
					memcpy(Adapter->SelectedSSID,
						Adapter->SiteS.BssInfo[AP_Selected].SSID, Adapter->SSID_size);
					memcpy(Adapter->DesiredSSID,
						Adapter->SiteS.BssInfo[AP_Selected].SSID, Adapter->SSID_size);
					memcpy((PUCHAR)Adapter->CurrentBSSID,
						(PUCHAR)Adapter->SiteS.BssInfo[AP_Selected].BSSID, 6);
					Adapter->StationState = STATION_STATE_JOINING;
					UsbJoin(Adapter);
					return 0;
	 		}
	 		break;
		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->SelectedSSID, 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
			spin_unlock_irqrestore(&Adapter->lock, flags);
			return -EINVAL;  //wt(wireless tools) won't print a network ID	
		case SIOCGIWNICKN: //same as above, for the nickname
			wrq->u.essid.length = Adapter->SSID_size;
			copy_to_user(wrq->u.essid.pointer, Adapter->SelectedSSID,Adapter->SSID_size);
			spin_unlock_irqrestore(&Adapter->lock, flags);
			return 0;
		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
			memcpy(wrq->u.ap_addr.sa_data, Adapter->CurrentBSSID, 6);
			break;
		case SIOCGIWPOWER: //Power Management
			spin_unlock_irqrestore(&Adapter->lock, flags);
			return -EINVAL;
		case SIOCGIWENCODE:
			if(Adapter->PrivacyInvoked==0)
			{
				wrq->u.data.flags  |= IW_ENCODE_DISABLED;
				wrq->u.data.length = 0;