wt_ioctl.c

mini-PCI driver for LHWT chipsets

    
#include "wtprecomp.h"



#define dbg_info_str(x) printk("<0>In function %s in line %d the pramater x = %s \n\r",__FUNCTION__,__LINE__,x);
#define dbg_info_num(x) printk("<0>In function %s in line %d the pramater x = %d \n\r",__FUNCTION__,__LINE__,x);



const int frequency_list_bg[] = { 2412, 2417, 2422, 2427, 2432, 2437, 2442,
	2447, 2452, 2457, 2462, 2467, 2472, 2484
};

const int frequency_list_a[] = { 5170, 5180, 5190, 5200, 5210, 5220, 5230,
	5240, 5260, 5280, 5300, 5320
};


int
wt4_mib_mode_helper(WT_ADAPTER *priv, u32 iw_mode)
{
	WTWLAN_MACMODE mode;

	FN_ENTER;
	/*check valide check */
	if (iw_mode == IW_MODE_REPEAT  || iw_mode == IW_MODE_SECOND 
		|| iw_mode == IW_MODE_MONITOR  || iw_mode == IW_MODE_MASTER ) {
		printk(KERN_DEBUG
		       "%s(): Sorry, Repeater mode , Secondary mode, Master mode and  Monitor mode"
		       "are not yet supported by this driver.\n", __FUNCTION__);
		return -EOPNOTSUPP;
	}

	/*swap linux mode to our define*/
	switch (iw_mode) {
	case IW_MODE_AUTO:
		mode = WLAN_MACMODE_NONE;
		break;
	case IW_MODE_ADHOC:
		mode = WLAN_MACMODE_IBSS_STA;
		break;
	case IW_MODE_INFRA:
		mode = WLAN_MACMODE_ESS_STA;
		break;
	case IW_MODE_MASTER:
		mode = WLAN_MACMODE_ESS_AP;
		break;
	case IW_MODE_SECOND:
		mode = WLAN_MACMODE_SECOND;
		break;
	case IW_MODE_MONITOR:
		mode = WLAN_MACMODE_MONITOR;
		break;
	default:
		return -EINVAL;
	}

 	/*commit to global*/
	if( mode != priv->MacParameter.macmode )
	{		
		// init mac stat when change mode
		InitMacStat( priv );
		LoadDefaultFlag( priv );

		priv->MacParameter.macmode = mode;
		priv->Ndis80211Parameter.ABGMode = priv->RegMacParameter.ABGMode;
	}
	
	//RegParaDefault.TxRate
	
	FN_EXIT(0,0);
	return 0;
	
}


/* map this function to register restore in windows */

void
wt4_mib_init(WT_ADAPTER *priv)
{
	REG_MAC_PARAMETER RegParaDefault;
        FN_ENTER;
	 
	memset( 	&RegParaDefault, 0, sizeof( REG_MAC_PARAMETER ) );
	
	RegParaDefault.ABGMode = CARD_DEFAULT_ABGMODE;
	RegParaDefault.AIFS = CARD_DEFAULT_AIFS;
	RegParaDefault.BeaconPeriod = CARD_DEFAULT_BEACON_PEROID;
	RegParaDefault.Channel = CARD_DEFAULT_CHANNEL;
	RegParaDefault.CWMax = CARD_DEFAULT_CWMAX;
	RegParaDefault.CWMin = CARD_DEFAULT_CWMIN;
	RegParaDefault.EncryptionType = CARD_DEFAULT_CRYPTTYPE;
	RegParaDefault.FragThreshold = CARD_DEFAULT_FRAGTHRESHOLD;
	RegParaDefault.IsPassiveScan = CARD_DEFAULT_ISPASSIVESCAN;
	RegParaDefault.IsProtectionEnable = CARD_DEFAULT_PROTECTION_MODE;
	RegParaDefault.IsQosEnable = CARD_DEFAULT_QOSMODE;
	RegParaDefault.PreambleType = CARD_DEFAULT_PREAMBLETYPE;
	RegParaDefault.ProtectionMode = CARD_DEFAULT_PROTECTION_MODE;
	RegParaDefault.RetryNum = CARD_DEFAULT_RETRYNUM;
	RegParaDefault.RfType = CARD_DEFAULT_RFTYPE;
	RegParaDefault.RtsThreshold = CARD_DEFAULT_RTSTHRESHOLD;
	RegParaDefault.TxPower = CARD_DEFAULT_TXPOWER;
	RegParaDefault.TxRate = CARD_DEFAULT_TXRATE;
	RegParaDefault.Country = CARD_DEFAULT_COUNTRY;
	

	/*swap to macparameter*/
	memcpy( &priv->RegMacParameter,  &RegParaDefault, sizeof( REG_MAC_PARAMETER ) );

	/* This sets all of the mode-dependent values */
	//printk("In File %s Function %s Line %d abgmode  = %d\n",  __FILE__, __FUNCTION__, __LINE__, priv->RegMacParameter.ABGMode);
	
	wt4_mib_mode_helper(priv, IW_MODE_INFRA );

	FN_EXIT(0,0);
	
}

/* this will be executed outside of atomic context thanks to
 * schedule_work(), thus we can as well use sleeping semaphore
 * locking */
void
wt4_update_stats(WT_ADAPTER *priv)
{

         FN_ENTER;
	
	if (down_interruptible(&priv->stats_sem))
	return;
	
/* Noise floor.
 * I'm not sure if the unit is dBm.
 * Note : If we are not connected, this value seems to be irrelevant. */

	 //printk("In wt4_update_stats\n");

	priv->local_iwstatistics.qual.noise = 0;  // maybe configure of RSSI_L_Threash or RSSI_L_Threash, check later

/* Get the rssi of the link. To do this we need to retrieve a bss. */

	priv->local_iwstatistics.qual.level = wtwlan_get_level_from_dbm( priv, priv->Ndis80211Parameter.RSSI );

#if 0
	if( ( priv->Ndis80211Parameter.RSSI <= 0 ) || (( priv->Ndis80211Parameter.RSSI > 100 )) )
	{
		priv->local_iwstatistics.qual.level = 80;
	}
	else
	{
		priv->local_iwstatistics.qual.level = priv->Ndis80211Parameter.RSSI;	
	}
#endif

	priv->local_iwstatistics.qual.qual = priv->local_iwstatistics.qual.level  - priv->iwstatistics.qual.noise;

	/* report that the stats are new */
	priv->local_iwstatistics.qual.updated = 0x7;    // updated

	priv->local_iwstatistics.discard.nwid = 0;   
	priv->local_iwstatistics.discard.code = 0;    // unable code/decode need soft counter,check later
	priv->local_iwstatistics.discard.fragment = 0;    // defrag error counter ,soft counter check later
	priv->local_iwstatistics.discard.retries = 0;  // need soft counter in txsenddone, check later
	priv->local_iwstatistics.discard.misc = priv->MainMemAddress->HwCSMem.HwStatistic.RcvMissedCounter;


	priv->local_iwstatistics.miss.beacon = 0;  // should be 0 in our system.
		
	up(&priv->stats_sem);

	 
	FN_EXIT(0,0);
	return;
}

struct iw_statistics *
wt4_get_wireless_stats(struct net_device *ndev)
{
	WT_ADAPTER *priv = netdev_priv(ndev);

	 FN_ENTER;
	// printk("<0>  In function %s Line %d ",__FUNCTION__,__LINE__);
	/* If the stats are being updated return old data */
	if (down_trylock(&priv->stats_sem) == 0) 
	{
		memcpy(&priv->iwstatistics, &priv->local_iwstatistics,
		       sizeof (struct iw_statistics));
		/* They won't be marked updated for the next time */
		priv->local_iwstatistics.qual.updated = 0;
		
		up(&priv->stats_sem);
		
	} 
	else
		priv->iwstatistics.qual.updated = 0;

	/* Update our wireless stats, but do not schedule to often 
	 * (max 1 HZ) */
	if ((priv->stats_timestamp == 0) ||
	    time_after(jiffies, priv->stats_timestamp + 1 * HZ)) {
		//schedule_work(&priv->stats_work);
		priv->stats_timestamp = jiffies;
	}
        
	FN_EXIT(0,0);
	return &priv->iwstatistics;
}

static int
wt4_commit(struct net_device *ndev, struct iw_request_info *info,
	       char *cwrq, char *extra)
{
	//WT_ADAPTER *priv = netdev_priv(ndev);
	
	// we donot need commit
	// set ssid proc set here
	FN_ENTER;
	FN_EXIT(0,0);
	return 0;
}

/***********************
***get name from driver***
***********************/

static int
wt4_get_name(struct net_device *ndev, struct iw_request_info *info,
		 char *cwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
	char *capabilities;

	 FN_ENTER;
 
	switch ( priv->Ndis80211Parameter.ABGMode )
	{

		case IEEE80211A_ONLY:
			capabilities = "WT4abg a mode";
			break;
		case IEEE80211B_AND_G:
			capabilities = "WT4abg bg mode";
			break;
		case IEEE80211G_ONLY:
			capabilities = "WT4abg g mode";
			break;
		case IEEE80211B_ONLY:
		default:
			capabilities = "WT4abg b mode";	/* Default */
			break;
	}
	strncpy(cwrq, capabilities, IFNAMSIZ);
	
//	dbg_info_str(cwrq)
	 
	FN_EXIT(0,0);
	return 0;
}

// for ibss use only
static int
wt4_set_freq(struct net_device *ndev, struct iw_request_info *info,
		 struct iw_freq *fwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
	u32 c = 0;

	 FN_ENTER;
	 
	dbg_info_num(fwrq->m)
		 
	if (fwrq->m < 1000)
		/* we have a channel number */
		c = fwrq->m;
	else
		c = (fwrq->e == 1) ? channel_of_freq(fwrq->m / 100000) : 0;

	priv->RegMacParameter.Channel = c ;
//	printk(" <0>  priv->RegMacParameter.Channel= %d \r\n",c);
	 
	//added by hk 2006.7.12
	SwChnl( priv,  c);

	FN_EXIT(0,0);
	return 0;
}

static int
wt4_get_freq(struct net_device *ndev, struct iw_request_info *info,
		 struct iw_freq *fwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
         FN_ENTER;
//	printk("<0>In function %s in line %d\n\r",__FUNCTION__,__LINE__); 
	fwrq->i = priv->NdisCurNet.WlanDesc.ie_ds.curr_channel ;
	if((fwrq->i>=14)&&(fwrq->i<36))
		fwrq->i=1;
	
//	printk("<0> Function %s Line %d CurrChannel = %d\r\n",__FUNCTION__,__LINE__,fwrq->i);
	fwrq->m = freq_of_channel(fwrq->i );
	fwrq->e = 6;

//	printk(" <0>  priv->RegMacParameter.Channel= %d ,fwrq->m = =%d\r\n",fwrq->i, fwrq->m  );

	//dbg_info_num(fwrq->m)
			  
	FN_EXIT(0,0);
	return 0;
}


static int
wt4_set_mode(struct net_device *ndev, struct iw_request_info *info,
		 __u32 * uwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
	u32 iw_mode;
	int result = 0;
	
	iw_mode = *uwrq;
	
	//dbg_info_num(iw_mode)

	result = ( wt4_mib_mode_helper( priv,  iw_mode ) );
	
	return result;
}

static int wt_swap_mode( __u32 mode )
{
	return mode;
}
/* Use mib cache */
static int
wt4_get_mode(struct net_device *ndev, struct iw_request_info *info,
		 __u32 * uwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
	u32 iw_mode;

	*uwrq=	wt_swap_mode(priv->MacParameter.macmode);
	iw_mode = *uwrq;
	 
	//dbg_info_num(iw_mode)

	return 0;
}

/* we use DOT11_OID_EDTHRESHOLD. From what I guess the card will not try to
 * emit data if (sensitivity > rssi - noise) (in dBm).
 * prism54_set_sens does not seem to work.
 */

static int
wt4_set_sens(struct net_device *ndev, struct iw_request_info *info,
		 struct iw_param *vwrq, char *extra)
{
//	WT_ADAPTER *priv = netdev_priv(ndev);

	u32 sens;
        FN_ENTER;
	 
	/* by default  the card sets this to 20. */
	sens = vwrq->disabled ? 20 : vwrq->value;

       //dbg_info_num(sens)
	// can use this value to set rssi_thresh, need swap, check later
	//priv->MainMemAddress->HwCSMem.BBCSMem.RGBRSSILThresh= vwrq->value;	
	// 
	 
	FN_EXIT(0,0);
	return 0;
}

static int
wt4_get_sens(struct net_device *ndev, struct iw_request_info *info,
		 struct iw_param *vwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
         FN_ENTER;
	//printk("<0>*******Function %s Line %d******** \n\r",__FUNCTION__,__LINE__);
	 
	vwrq->value=priv->MainMemAddress->HwCSMem.BBCSMem.RGBRSSILThresh ;
	vwrq->disabled = (vwrq->value == 0);
	vwrq->fixed = 1;

	//dbg_info_num(vwrq->value)	  
	FN_EXIT(0,0);
	return 0;
}


static int 
wt4_get_support_freq( IN PWT_ADAPTER priv,  struct obj_frequencies *freq )
{
	u16 nr_a, nr_b, nr;
	int i;
         FN_ENTER;
	 
	nr_b = sizeof( frequency_list_bg )/sizeof( frequency_list_bg[0]);
	nr_a = sizeof( frequency_list_a ) / sizeof( frequency_list_a[0] );
	nr = nr_a + nr_b;
	
	nr = min( IW_MAX_FREQUENCIES, ( int )nr );
	
	freq->nr = nr;
	
	for( i = 0; i < nr ; i++ )
	{
		if( i < nr_b )
			{
				freq->mhz[ i ] = frequency_list_bg[i];
			}
		else
			{
				freq->mhz[  i ] = frequency_list_a[ i - nr_b];
			}
	}
	 
	FN_EXIT(0,0);
	return 0;
}

static int rates_string[]={ 2,4,11,22, 12, 18, 24,36, 48,72,96,108 };


static int 
wt4_get_support_rates( IN PWT_ADAPTER priv,  u32 *rates )
{
	u32 n_rates ;
	int i;
	int result = -EINVAL;
        
	 FN_ENTER;
	 
	do{
		if( priv->NdisCurNet.WlanDesc.ie_rates.length != 0 )
		{
			if( ( priv->NdisCurNet.WlanDesc.ie_rates.length >= ELE_LEN_SUPPORT_RATES ) ||
				( priv->NdisCurNet.WlanDesc.ie_extendrates.len >= MAX_EXTEND_RATES ) )
				break;
				
			if( IW_MAX_BITRATES < ( priv->NdisCurNet.WlanDesc.ie_rates.length +
				priv->NdisCurNet.WlanDesc.ie_extendrates.len ) )
				break;
		n_rates = 0;
		for( i = 0; i < priv->NdisCurNet.WlanDesc.ie_rates.length ; i++ )
		{
			rates[ n_rates++] = priv->NdisCurNet.WlanDesc.ie_rates.sup_rates[ i ];
//			printk("in function %s rates[%d]=%d \n",__FUNCTION__,i,rates[ n_rates ]);
		}
		
		for( i = 0; i < priv->NdisCurNet.WlanDesc.ie_extendrates.len; i++ )
		{
			rates[ n_rates++] = priv->NdisCurNet.WlanDesc.ie_extendrates.extrates[ i ];
		}

		result = 0;
			
		}
	   }while( 0 );
//	printk("in function %s ie_rates.length=%d \n",__FUNCTION__,priv->NdisCurNet.WlanDesc.ie_rates.length);
//	printk("in function %s ie_rates.length=%d \n",__FUNCTION__,priv->NdisCurNet.WlanDesc.ie_extendrates.len);
//	printk("in function %s n_rates=%d \n",__FUNCTION__,n_rates );
	   if( result != 0 )
	   	{// default rates, or not in net
//			printk("in function %s using default rates \n",__FUNCTION__ );
			memcpy( rates, rates_string, (sizeof(rates_string)/sizeof(rates_string[0]))*sizeof(u32)); 
	   	}

          
	FN_EXIT(0,0);
	return 0;
}


static int
wt4_get_range(struct net_device *ndev, struct iw_request_info *info,
		  struct iw_point *dwrq, char *extra)
{
	struct iw_range *range = (struct iw_range *) extra;
	WT_ADAPTER *priv = netdev_priv(ndev);
	//u8 *data;
	int i, m/*, rvalue*/;
	struct obj_frequencies *freq;
	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)