vnetusba.c

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

			}	
			else
			{
				wrq->u.data.flags &= ~IW_ENCODE_DISABLED;
				wrq->u.data.flags |= (Adapter->WepInfo.WepKeyToUse+1);
				if(Adapter->WepInfo.AuthenticationType == C80211_MGMT_AAN_OPENSYSTEM)
					wrq->u.data.flags |= IW_ENCODE_OPEN;
				if(Adapter->WepInfo.ExcludeUnencrypted == WEP_MODE_MANDATORY)
					wrq->u.data.flags |= IW_ENCODE_RESTRICTED;
				wrq->u.data.length = (Adapter->WepInfo.EncryptionLevel==WEP_64BIT)?5:13;
			}				
			copy_to_user(wrq->u.data.pointer, (PUCHAR)&Adapter->WepInfo +(5+(Adapter->WepInfo.WepKeyToUse*13)),
				wrq->u.data.length);
			break;
		case SIOCGIWRATE: //Bitrate Used
			wrq->u.bitrate.fixed=0;
			switch(Adapter->TxRate)
			{
				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
			spin_unlock_irqrestore(&Adapter->lock, flags);
			return -EINVAL;			
 		case SIOCGIWRANGE:
 			spin_unlock_irqrestore(&Adapter->lock, flags);
 			return -EINVAL;			
		case SIOCSIWRATE: //Bitrate Used
			if(wrq->u.bitrate.fixed==0)
			{
				spin_unlock_irqrestore(&Adapter->lock, flags);
				DevConfig.TxRate = 4;
				ChangeConfiguration(Adapter, &DevConfig);
				return 0;
			}
			if((wrq->u.bitrate.value/1e6)>2)
			{
				if((wrq->u.bitrate.value/1e6)>6)
					DevConfig.TxRate = 3;
				else
					DevConfig.TxRate = 2;
			}
			else
				DevConfig.TxRate = (wrq->u.bitrate.value/1e6) - 1;
				ChangeConfiguration(Adapter, &DevConfig);
			break;			
		case SIOCSIWESSID://ESSID change
			memcpy(DevConfig.SSID, wrq->u.data.pointer, wrq->u.data.length);
			DevConfig.SSIDlength		=	wrq->u.data.length;
			ChangeConfiguration(Adapter, &DevConfig);
			break;
		case SIOCSIWRTS:
			DevConfig.RtsCtsThreshold=wrq->u.rts.value;
			ChangeConfiguration(Adapter, &DevConfig);
 			break;
 		case SIOCSIWFRAG:
			DevConfig.FragmentationThreshold=wrq->u.frag.value;
			ChangeConfiguration(Adapter, &DevConfig);
 			break;
 		case SIOCSIWMODE:
 			if ( (wrq->u.mode<0)||(wrq->u.mode>1) )
 			{
 				spin_unlock_irqrestore(&Adapter->lock, flags);
 				return -EINVAL;
 			}
			DevConfig.OperatingMode=2-wrq->u.mode;
			ChangeConfiguration(Adapter, &DevConfig);
 			break;
 		case SIOCSIWENCODE:
 			spin_unlock_irqrestore(&Adapter->lock, flags);
 			if(wrq->u.data.flags & IW_ENCODE_DISABLED)
 			{
 				Adapter->PrivacyInvoked = 0;
 				return 0;
 			}
 			if(wrq->u.data.flags & IW_ENCODE_OPEN)
 				Adapter->WepInfo.AuthenticationType = C80211_MGMT_AAN_OPENSYSTEM;
 			if(wrq->u.data.flags & IW_ENCODE_RESTRICTED)
				Adapter->WepInfo.ExcludeUnencrypted = WEP_MODE_MANDATORY;
								
 			if( (wrq->u.data.length != 5)||(wrq->u.data.length != 13) )
 				return -EINVAL;
 			if(wrq->u.data.length == 5)
 				Adapter->WepInfo.EncryptionLevel = WEP_64BIT;
 			else
	 			Adapter->WepInfo.EncryptionLevel = WEP_128BIT;
 			Adapter->WepInfo.WepKeyToUse = (wrq->u.data.flags & IW_ENCODE_INDEX)-1;
 			if(Adapter->WepInfo.WepKeyToUse>3)
 				return -EINVAL;
 			copy_from_user((PUCHAR)&Adapter->WepInfo + (5+(13*Adapter->WepInfo.WepKeyToUse)),
 				wrq->u.data.pointer, wrq->u.data.length);
 			SetWEPvalue(Adapter);
 			return 0;
	}
	spin_unlock_irqrestore(&Adapter->lock, flags);
	return 0;
}

static int usb_vnet_tx(struct sk_buff *skb,  struct net_device *dev)
{
	PVNet_ADAPTER Adapter = (PVNet_ADAPTER)dev->priv;
	USHORT		len;
	ULONG		flags;
	PTX_LIST 	NewTxL;

	if(!Adapter)
	{
		Adapter->Stats.TxDataPacketsError++;
		Adapter->netstats.tx_dropped++;	
	  	netif_stop_queue(dev);
	  	return NET_XMIT_DROP;
	}
	if(!netif_device_present(Adapter->net)||!(Adapter->flags & VNET_RUNNING))
	{
		Adapter->Stats.TxDataPacketsError++;
		Adapter->netstats.tx_dropped++;	
	  	netif_stop_queue(dev);
	  	return NET_XMIT_DROP;
	}
	
	if(Adapter->StationState != STATION_STATE_READY)
 		return -EAGAIN;

	len = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
	spin_lock_irqsave(&Adapter->lock, flags);
	EnQueuePacket(Adapter, &NewTxL, len, 1);
	NewTxL->skb 	= skb;
	// add the packet in the buffer (the first 12 bytes are going to be used in the
	// wireless header.
	memcpy((PUCHAR)&NewTxL->tx_buff->WirelessPacket[18],(PUCHAR)skb->data, len);
	// add the wireless header.....
	Ethernet2Wireless(Adapter, NewTxL);
	DeQueueTxPacket(Adapter);
	// remember time of transmit
	Adapter->net->trans_start = jiffies;
	spin_unlock_irqrestore(&Adapter->lock, flags);
	// packet used. Wait until callback to free sk_buff....
	return NET_XMIT_SUCCESS;
}

static void * usb_vnet_probe(struct usb_device *dev, UINT interface, const struct usb_device_id *id_table)
{
	PVNet_ADAPTER 		Adapter;
	UCHAR				BoardType;
	
	if( (dev->descriptor.idVendor == 0x03eb) && (dev->descriptor.idProduct == 0x7605) )
		BoardType = RFMD_Board;
	else if( (dev->descriptor.idVendor == 0x03eb) && (dev->descriptor.idProduct == 0x7603) )
		BoardType = Normal_Board;
	else
	{
		err("Device Descriptors not matching");
		return NULL;
	}
	dbgusbnl("BoardType = %d", BoardType)

	if(!(Adapter = (PVNet_ADAPTER)kmalloc(sizeof(VNet_ADAPTER), GFP_KERNEL)))
	{
		err("Not enough memory");
		return NULL;
	}
	MOD_INC_USE_COUNT;
 	memset((PUCHAR)Adapter, 0, sizeof(VNet_ADAPTER));
	ChangeState(Adapter, STATION_STATE_INITIALIZING);
	Adapter->BoardType = BoardType;
	Adapter->config = &dev->config[0];
	Adapter->usb = dev;
	
	if(InitDevice(Adapter)!=0)
	{
	  err("device initialization failed");
	  usb_dec_dev_use(dev);
	  MOD_DEC_USE_COUNT;
	  kfree(Adapter);
	  return NULL;
	}	
	
	usb_inc_dev_use(dev);
	//	Start Polling In Bulk In Endpoint
	if(UsbRxInit(Adapter)!=0)
		return NULL;

	Adapter->flags |= VNET_RUNNING;

	if( !(Adapter->net = init_etherdev(NULL, 0)))
	{	
		kfree(Adapter);
		return NULL;
	}

	Adapter->net->open  			= usb_vnet_open;
	Adapter->net->stop  			= usb_vnet_close;
	Adapter->net->hard_start_xmit	= usb_vnet_tx;		
	Adapter->net->do_ioctl			= usb_vnet_ioctl;	
	Adapter->net->priv				= Adapter; 		
	Adapter->net->get_stats      	= usb_vnet_net_stats;
	Adapter->net->get_wireless_stats= wireless_stats;
	Adapter->net->mtu 				= 1500;
	Adapter->net->addr_len 			= 6;
	memcpy(Adapter->net->dev_addr, Adapter->StationAddress, Adapter->net->addr_len);	

	ChangeState(Adapter, STATION_STATE_SCANNING);
	if(UsbScan(Adapter)!=0)
	{
		err("Scan Command failed");
		return NULL;
	}
	if(!register_netdev(Adapter->net))
	{
		err("register_netdev failed");
		kfree(Adapter);
		return NULL;
	}
	info( "usb %s initialized and register", Adapter->net->name);
	return Adapter;
}

static void usb_vnet_disconnect(struct usb_device *dev, void *ptr)
{
	PVNet_ADAPTER	Adapter = (PVNet_ADAPTER)ptr;
	DECLARE_WAITQUEUE(wait, current);
	UCHAR			DeviceMode = Adapter->DevMode;
	ULONG			flags;
	UCHAR			BitUp=0;
	char			*argv[4];
	
	argv[0]="/sbin/modprobe";
	argv[1]="-r";
	argv[2]="vnetusba";
	argv[3]=0;
	
	if(!Adapter)
		return;
	info("disconnecting %d %d\n", Adapter->rx_urb->status, Adapter->ctrl_urb->status);
	spin_lock_irqsave(&Adapter->lock, flags);
	Adapter->flags &= ~VNET_RUNNING;
	
	DropPendingTxPackets(Adapter);
	Adapter->StationState = STATION_STATE_EXITING;
	del_timer_sync(&Adapter->CtrlTimer);
	
	Adapter->rx_urb->transfer_flags |= USB_ASYNC_UNLINK;
	Adapter->tx_urb->transfer_flags |= USB_ASYNC_UNLINK;
	Adapter->ctrl_urb->transfer_flags |= USB_ASYNC_UNLINK;

	usb_unlink_urb(Adapter->rx_urb);
	usb_unlink_urb(Adapter->tx_urb);
	usb_unlink_urb(Adapter->ctrl_urb);

   	spin_unlock_irqrestore(&Adapter->lock, flags);	
	if(Adapter->CallbacksPending)
	{
		add_wait_queue(&Adapter->remove_wait, &wait);
		set_current_state(TASK_INTERRUPTIBLE);
		schedule();
		set_current_state(TASK_RUNNING);
		remove_wait_queue(&Adapter->remove_wait, &wait);	
	}
	
	while(MOD_IN_USE)
		MOD_DEC_USE_COUNT;
		
	unregister_netdev( Adapter->net );
	Adapter->net->priv = NULL;	
	usb_driver_release_interface(&vnet_driver, Adapter->config->interface);	
	Adapter->net->name[0] = '\0';
	usb_dec_dev_use( dev );
	
	VnetReleaseResources(Adapter);
	info("device disconnected (total bytes in :%ld, out %ld --%d--)",
		Adapter->netstats.rx_bytes, Adapter->netstats.tx_bytes, DeviceMode);
	call_usermodehelper(argv[0], argv, NULL);
}

static int __init usb_vnet_init(void)
{
	return usb_register( &vnet_driver );
}

static void __exit usb_vnet_exit(void)
{
	wait_ms(250);//wait for call_usermodehelper to finish.
	usb_deregister( &vnet_driver );
}

/**************************************************************/
MODULE_DESCRIPTION("ATMEL 503A usb Card");
MODULE_AUTHOR("ATMEL Drivers Group");
MODULE_DEVICE_TABLE(usb, vnet_usb_id);

module_init( usb_vnet_init ); // initialization function
module_exit( usb_vnet_exit ); // exit function
/**************************************************************/