wt_ioctl.c

linux2.6.11内核无线网卡驱动程序。支持802.11 abg

	char obj_freq_buf[(IW_MAX_BITRATES+2)*sizeof(u16)];
	u32 supportrates[IW_MAX_BITRATES];
        
	 FN_ENTER;
	  
	if( range == NULL )
		return 0;

	memset(range, 0, sizeof (struct iw_range));
	dwrq->length = sizeof (struct iw_range);

	/* set the wireless extension version number */
	range->we_version_source = SUPPORTED_WIRELESS_EXT;
	range->we_version_compiled = WIRELESS_EXT;

	/* Now the encoding capabilities */
	range->num_encoding_sizes = 3;
	/* 64(40) bits WEP */
	range->encoding_size[0] = 5;
	/* 128(104) bits WEP */
	range->encoding_size[1] = 13;
	/* 256 bits for WPA-PSK */
	range->encoding_size[2] = 32;
	/* 4 keys are allowed */
	range->max_encoding_tokens = 4;

	/* we don't know the quality range... */
	//range->max_qual.level = 100;
	//range->max_qual.noise = 100;
	//range->max_qual.qual = 100;
	range->max_qual.level = (unsigned char)(-20);
	range->max_qual.noise = (unsigned char)(-90);
	range->max_qual.qual = 70;
	/* these value describe an average quality. Needs more tweaking... */
	//range->avg_qual.level = 50;	
	//range->avg_qual.noise = 10;	
	//range->avg_qual.qual = 90;
	range->avg_qual.level = (unsigned char)(-40);	
	range->avg_qual.noise = (unsigned char)(-90);	
	range->avg_qual.qual = 50;

	range->sensitivity = 80;

	/* retry limit capabilities */
	range->retry_capa = IW_RETRY_LIMIT | IW_RETRY_LIFETIME;
	range->retry_flags = IW_RETRY_LIMIT;
	range->r_time_flags = IW_RETRY_LIFETIME;

	/* I don't know the range. Put stupid things here */
	// read from our life register
	range->min_retry = 1;
	range->max_retry = 15;
	range->min_r_time = 1024;
	range->max_r_time = 30 * 1024;

	/* txpower is supported in dBm's */
	range->txpower_capa = IW_TXPOW_DBM;

	range->min_rts = 256;
	range->max_rts = 2346;
	range->min_frag = 256;
	range->max_frag = 2346;

#if WIRELESS_EXT > 16
	/* Event capability (kernel + driver) */
	range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
	IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
	IW_EVENT_CAPA_MASK(SIOCGIWAP));
	range->event_capa[1] = IW_EVENT_CAPA_K_1;
	range->event_capa[4] = IW_EVENT_CAPA_MASK(IWEVCUSTOM);
#endif /* WIRELESS_EXT > 16 */


	freq = (struct obj_frequencies *)obj_freq_buf;

	wt4_get_support_freq(  priv,  freq );

	range->num_channels = freq->nr;
	range->num_frequency = freq->nr;

	m = min(IW_MAX_FREQUENCIES, (int) freq->nr);
	for (i = 0; i < m; i++) {
		range->freq[i].m = freq->mhz[i];
		range->freq[i].e = 6;
		range->freq[i].i = channel_of_freq(freq->mhz[i]);
	}

	memset( supportrates, 0, sizeof(supportrates) );
	wt4_get_support_rates(  priv,  (__u32 *)supportrates );

	/* We got an array of char. It is NULL terminated. */
	i = 0;
	while ((i < IW_MAX_BITRATES) && (supportrates[i] != 0)) {
		/*       the result must be in bps. The card gives us 500Kbps */
		range->bitrate[i] = (supportrates[i]&0x7f) * 500000;
		i++;
	}
	range->num_bitrates = i;
	//printk("in function %s i=%d\n",__FUNCTION__,i);
         
	FN_EXIT(0,0);
	return 0;
}

/* Set AP address*/

static int
wt4_set_wap(struct net_device *ndev, struct iw_request_info *info,
		struct sockaddr *awrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
         FN_ENTER;
	 
	if (awrq->sa_family != ARPHRD_ETHER)
		return -EINVAL;

	/* prepare the structure for the set object */
	memcpy(&priv->MacParameter.mBssid, awrq->sa_data, 6);
         
	FN_EXIT(0,0);
	return 0;	/* Call commit handler */
}

/* get AP address*/

static int
wt4_get_wap(struct net_device *ndev, struct iw_request_info *info,
		struct sockaddr *awrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
         FN_ENTER;
	 
	memcpy(awrq->sa_data, &priv->MacParameter.mBssid, 6);
	awrq->sa_family = ARPHRD_ETHER;
         
	FN_EXIT(0,0);
	return 0;
}

static int
wt4_set_scan(struct net_device *ndev, struct iw_request_info *info,
		 struct iw_param *vwrq, char *extra)
{

	WT_ADAPTER *priv = netdev_priv(ndev);
	 FN_ENTER;
	 
	ON_OID_802_11_BSSID_LIST_SCAN( priv );
	  
	FN_EXIT(0,0);
	return 0;
}

unsigned char 
wtwlan_get_level_from_dbm( IN PWT_ADAPTER priv, int level_dbm )
{
	unsigned char signal_level;
	
	FN_ENTER;

      signal_level = (unsigned char)(level_dbm&0xff);
	   
	FN_EXIT(0,0);
	
	return ( signal_level );
		
}

static int
wtwlan_get_bss_max_rate( IN PWT_ADAPTER priv, PWTWLAN_BSSID_DESC bss )
{
	
		/* Add basic and extended rates */
		int i;
		int max_rate = dot11rate1M;
		 FN_ENTER;
	 
		for( i = 0; i < bss->ie_rates.length; i++ )
			{
				if( ( bss->ie_rates.sup_rates[i] & 0x7f ) > max_rate )
					max_rate = ( bss->ie_rates.sup_rates[i] & 0x7f );
				
			}

		for( i = 0; i < bss->ie_extendrates.len; i++ )
			{
				if( ( bss->ie_extendrates.extrates[i] & 0x7f ) > max_rate )
					max_rate = ( bss->ie_extendrates.extrates[i] & 0x7f );
			}
                  
	        FN_EXIT(0,0);
		return max_rate;
		
}

static char *
wt4_translate_bss(struct net_device *ndev, char *current_ev,
		      char *end_buf, PWTWLAN_BSSID_DESC bss, char noise)
{
	struct iw_event iwe;	/* Temporary buffer */
	WT_ADAPTER *priv = netdev_priv(ndev);
	int max_rate;
         FN_ENTER;
	 
	/* The first entry must be the MAC address */
	iwe.cmd = SIOCGIWAP;//get access point mac address
	iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
	memcpy(iwe.u.ap_addr.sa_data, bss->ndisbssidex.MacAddress, ETH_ALEN );//sa_data:protocol address
	current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_ADDR_LEN);

	/* The following entries will be displayed in the same order we give them */

	/* The ESSID. */
	iwe.cmd = SIOCGIWESSID;
	iwe.u.data.flags = 1;
	if( bss->ndisbssidex.Ssid.SsidLength == 0 )
		{
			iwe.u.data.length = sizeof("<hidden>");
			current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, "<hidden>");
		}
	else
		{
			iwe.u.data.length = min( bss->ndisbssidex.Ssid.SsidLength, (ULONG)32 );
			current_ev = iwe_stream_add_point(current_ev, end_buf,  &iwe, bss->ndisbssidex.Ssid.Ssid);
	}

	/* Add name*/
	iwe.cmd = SIOCGIWNAME;
	if( bss->ndisbssidex.NetworkTypeInUse == Ndis802_11OFDM5 )
		{
			snprintf(iwe.u.name, IFNAMSIZ, "WT4abg %s", "a mode");
		}
	else if( bss->ndisbssidex.NetworkTypeInUse == Ndis802_11OFDM24 )
		{
			snprintf(iwe.u.name, IFNAMSIZ, "WT4abg %s", "g mode");
		}
	else
		{
			snprintf(iwe.u.name, IFNAMSIZ, "WT4abg %s", "b mode");
		}
	current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_CHAR_LEN);

	/* Mode */
        iwe.cmd = SIOCGIWMODE;//get operation mode
        if ( bss->ie_fixed.Capabilities & (cIbss | cEss)) 
	{
		if (bss->ie_fixed.Capabilities & cEss)
			iwe.u.mode = IW_MODE_INFRA;  //IW_MODE_MASTER ?
		else
			iwe.u.mode = IW_MODE_ADHOC;

		current_ev =
		    iwe_stream_add_event(current_ev, end_buf, &iwe,
					 IW_EV_UINT_LEN);
	}

	/* Encryption capability */
	iwe.cmd = SIOCGIWENCODE;
	if (bss->ie_fixed.Capabilities & cPrivacy )
		iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
	else
		iwe.u.data.flags = IW_ENCODE_DISABLED;
	iwe.u.data.length = 0;
	current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, NULL);

	/* Add frequency. (short) bss->channel is the frequency in MHz */
	iwe.cmd = SIOCGIWFREQ;
	iwe.u.freq.m = bss->ie_ds.curr_channel;
	iwe.u.freq.e = 0;
	iwe.u.freq.i = 0;
	current_ev =
	    iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_FREQ_LEN);

	/* Add quality statistics */
	iwe.cmd = IWEVQUAL;

	iwe.u.qual.level = wtwlan_get_level_from_dbm( priv, bss->ndisbssidex.Rssi );


	iwe.u.qual.noise = noise;
	/* do a simple SNR for quality */
	iwe.u.qual.qual = iwe.u.qual.level  - noise;
	current_ev =
	    iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_QUAL_LEN);



	/*  rates */
	iwe.cmd = SIOCGIWRATE;
	iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
	max_rate = wtwlan_get_bss_max_rate( priv, bss );
	iwe.u.bitrate.value = max_rate * 500000;
	current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe,
				     IW_EV_PARAM_LEN);

	/*Add  wpa_ie later*/	
          
	FN_EXIT(0,0);
	return current_ev;
}

u32 wtwlan_get_noice(  IN PWT_ADAPTER priv )
{

       FN_ENTER;
	   
	FN_EXIT(0,0);
	return 10;
}

int
wt4_get_scan(struct net_device *ndev, struct iw_request_info *info,
		 struct iw_point *dwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
	int i, rvalue = 0;
	u32 noise = 0;
	char *current_ev = extra;
         FN_ENTER;
	 
// sem should use later in scan db

	if( priv->MlmeParameter.bScanOngoing )
	{
		dwrq->length = 0;
		return -EAGAIN;
	}
	
	if( priv->Ndis80211Parameter.pWlanScanDb->NumberOfItems == 0)
	{
		dwrq->length = 0;
		return -ENODATA;
	}

	/* first get the noise value. We will use it to report the link quality */
	noise = wtwlan_get_noice(priv);

	/* ok now, scan the list and translate its info */
	//printk(LEVEL"  Scan db size is %d \r\n",priv->Ndis80211Parameter.pWlanScanDb->NumberOfItems);
	for (i = 0; i < priv->Ndis80211Parameter.pWlanScanDb->NumberOfItems ; i++) 
	{
		current_ev = wt4_translate_bss(ndev, current_ev,
						   extra + dwrq->length,
						   &(priv->Ndis80211Parameter.pWlanScanDb->wlandesc[i]),
						   noise);
#if WIRELESS_EXT > 16
		/* Check if there is space for one more entry */
		if((extra + dwrq->length - current_ev) <= IW_EV_ADDR_LEN) {
			/* Ask user space to try again with a bigger buffer */
			rvalue = -E2BIG;
			break;
		}
#endif /* WIRELESS_EXT > 16 */
	}

	dwrq->length = (current_ev - extra);
	dwrq->flags = 0;	/* todo */
         
	FN_EXIT(0,0);
	return rvalue;
}

static int
wt4_set_essid(struct net_device *ndev, struct iw_request_info *info,
		  struct iw_point *dwrq, char *extra)//extra name
{
	WT_ADAPTER *priv = netdev_priv(ndev);
	NDIS_802_11_SSID reqssid;
	int length = 0;

         FN_ENTER;
	//dbg_info_str(extra)
	//WT_SPIN_LOCK(&priv->SsidSetLock);
	if (dwrq->flags && dwrq->length) 
	{
		if (dwrq->length > min(33, IW_ESSID_MAX_SIZE + 1))
			return -E2BIG;
	} 
	else
	{
		// donot support 'any' here, check later
			return -EINVAL;
	}

	memset( &reqssid, 0, sizeof( NDIS_802_11_SSID ) ); 
	length = dwrq->length - 1;
	reqssid.SsidLength = length;
	memcpy(reqssid.Ssid, extra, dwrq->length);

//	printk("mode = %d\n",priv->MacParameter.macmode);//值为2,即IW_MODE_INFRA


	SSIDSetProc( priv, (PVOID)(&reqssid) );
         
	//WT_SPIN_UNLOCK(&priv->SsidSetLock);
	FN_EXIT(0,0);
	return 0;
}


static int
wt4_get_essid(struct net_device *ndev, struct iw_request_info *info,
		  struct iw_point *dwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
//	union oid_res_t r;

	/* if link return essid else 'any'*/
	
	/*
	Adapter->MacParameter.CurrentState
	or
	mdisable
	*/
	 FN_ENTER;
	 
	 //WT_SPIN_LOCK(&priv->SsidGetLock);
	 
	if( ( priv->MacParameter.CurrentState == ASOC_PASS ) ||
		( priv->MacParameter.CurrentState == IBSS_ACTIVE ) ||
		( priv->MacParameter.CurrentState == IBSS_IDLE ) )
		{
			dwrq->flags = 1;	/* set ESSID to ON for Wireless Extensions */
			/* if it is to big, trunk it */
			dwrq->length = min(IW_ESSID_MAX_SIZE, (int)(priv->NdisCurNet.WlanDesc.ndisbssidex.Ssid.SsidLength + 1));		
		}
	else
		{
			dwrq->flags = 0;
			dwrq->length = 0;
		}
		memcpy(extra, priv->NdisCurNet.WlanDesc.ndisbssidex.Ssid.Ssid, dwrq->length);
		extra[priv->NdisCurNet.WlanDesc.ndisbssidex.Ssid.SsidLength] = '\0';
	 
	//WT_SPIN_UNLOCK(&priv->SsidGetLock); 
	FN_EXIT(0,0);
	return 0;
}


/* Provides no functionality, just completes the ioctl. In essence this is a 
 * just a cosmetic ioctl.
 */
static int
wt4_set_nick(struct net_device *ndev, struct iw_request_info *info,
		 struct iw_point *dwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
         FN_ENTER;
	 
	//printk("<0>*******Function %s Line %d******** \n\r",__FUNCTION__,__LINE__);
	//return; 
	
	if (dwrq->length > IW_ESSID_MAX_SIZE)
		return -E2BIG;
	//dbg_info_str(extra)
	
//	down_write(&priv->mib_sem);
	memset(priv->nickname, 0, sizeof (priv->nickname));
	memcpy(priv->nickname, extra, dwrq->length);
//	up_write(&priv->mib_sem);
         
	FN_EXIT(0,0);
	return 0;
}

static int
wt4_get_nick(struct net_device *ndev, struct iw_request_info *info,
		 struct iw_point *dwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
         FN_ENTER;
	 
	 //printk("<0>*******Function %s Line %d******** \n\r",__FUNCTION__,__LINE__); 
	 
	dwrq->length = 0;

//	down_read(&priv->mib_sem);
	dwrq->length = strlen(priv->nickname) + 1;
	memcpy(extra, priv->nickname, dwrq->length);
//	up_read(&priv->mib_sem);
	
	//dbg_info_str(extra)
	
	FN_EXIT(0,0);
	return 0;