wt_ioctl.c

linux,red ,test,driver,need

	return 0;
}

/* Set the allowed Bitrates */

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

	WT_ADAPTER *priv = netdev_priv(ndev);
	 FN_ENTER;
	 
	/*rate valide check, check later*/ 
	priv->Ndis80211Parameter.TxRate = vwrq->value;
printk("TxRate = %02x\n",priv->Ndis80211Parameter.TxRate);
	 
	FN_EXIT(0,0);
	return 0;
}

/* Get the current bit rate */
static int
wt4_get_rate(struct net_device *ndev,
		 struct iw_request_info *info,
		 struct iw_param *vwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
	 FN_ENTER;
	 
	vwrq->value=priv->Ndis80211Parameter.TxRate *500000 ;
         
	FN_EXIT(0,0);
	return 0;
}

static int
wt4_set_rts(struct net_device *ndev, struct iw_request_info *info,
		struct iw_param *vwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
        FN_ENTER;
	FN_EXIT(0,0);
	/*rts threshold  valid check, check later*/
	priv->Ndis80211Parameter.RTS_THRESHOLD =vwrq->value ;

	return 0 ;

}

static int
wt4_get_rts(struct net_device *ndev, struct iw_request_info *info,
		struct iw_param *vwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
         FN_ENTER;
	FN_EXIT(0,0);
	vwrq->value= priv->Ndis80211Parameter.RTS_THRESHOLD;

	return 0;
}

static int
wt4_set_frag(struct net_device *ndev, struct iw_request_info *info,
		 struct iw_param *vwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
         FN_ENTER;
	 
	/*frag threshold valid check, check later*/
	priv->Ndis80211Parameter.FRAGMENTATION_THRESHOLD = vwrq->value;
           
	FN_EXIT(0,0);
	return 0;

}

static int
wt4_get_frag(struct net_device *ndev, struct iw_request_info *info,
		 struct iw_param *vwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
	 FN_ENTER;
	 
	vwrq->value=priv->Ndis80211Parameter.FRAGMENTATION_THRESHOLD ;
	 
	FN_EXIT(0,0);
	return 0;
}

/* Here we have (min,max) = max retries for (small frames, big frames). Where
 * big frame <=>  bigger than the rts threshold
 * small frame <=>  smaller than the rts threshold
 * This is not really the behavior expected by the wireless tool but it seems
 * to be a common behavior in other drivers.
 */

static int
wt4_set_retry(struct net_device *ndev, struct iw_request_info *info,
		  struct iw_param *vwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
         FN_ENTER;
	 
	/*retry valid check, check later*/
	if (vwrq->disabled)
		priv->Ndis80211Parameter.RetryNum=0;
	else
		priv->Ndis80211Parameter.RetryNum=vwrq->value; 
	 
	FN_EXIT(0,0);

	return 0;
}

static int
wt4_get_retry(struct net_device *ndev, struct iw_request_info *info,
		  struct iw_param *vwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
         FN_ENTER;
	 
	vwrq->value=priv->Ndis80211Parameter.RetryNum ;
	if(vwrq->value==0)
	{
		vwrq->disabled=1;
	}
	else
	{
		vwrq->disabled=0;
		vwrq->fixed=(unsigned char)IW_RETRY_TYPE;
	} 
	FN_EXIT(0,0);
	return 0;
}

//added by hk 2006.6.19
static int set_wep_key(struct net_device *ndev, u16 index,
		       const char *key, u16 keylen, int perm, int lock ) 
{
	char Info[32];
	WT_ADAPTER *priv = netdev_priv(ndev);

	if (keylen > 0) 
	{
		switch(priv->MacParameter.mEncryptMode)
		{
		case ENCRYPT_WEP64://iv vector由硬件去添置
			memcpy(Info, "\0\0\0", IV_LEN);//fill iv 
			memcpy(Info + IV_LEN, key, keylen);
			memcpy_toio( priv->MainMemAddress->HwKeyTable[index].Key.KeyWEP.WepKey, Info, keylen + IV_LEN);
			printk(" key = %x%x%x%x%x%x%x\r\n",key[0],key[1],key[2],key[3],
				key[4],key[5],key[6]);
			
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DecryptModeMulticast =   ENCRYPT_WEP64;//组播解密方式
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DecryptModeUnicast =   ENCRYPT_WEP64;//单播解密方式
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DecryptKeyAddrUnicast =   ieee2host16(priv->MacHwCfg.KeyMapBaseAddr + index * sizeof(WTWLAN_HWKEYTABLE));
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DefaultAddrKey0 =   ieee2host16(priv->MacHwCfg.KeyMapBaseAddr);
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DefaultAddrKey1 =   ieee2host16(priv->MacHwCfg.KeyMapBaseAddr + sizeof(WTWLAN_HWKEYTABLE));
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DefaultAddrKey2 =   ieee2host16(priv->MacHwCfg.KeyMapBaseAddr + 2 * sizeof(WTWLAN_HWKEYTABLE));
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DefaultAddrKey3 =   ieee2host16(priv->MacHwCfg.KeyMapBaseAddr + 3 * sizeof(WTWLAN_HWKEYTABLE));
			priv->MainMemAddress->HwCSMem.CSRAddress.ChipCtrl.Bit_RegChipCtrl.IVEn = TRUE;
			priv->MainMemAddress->HwCSMem.CSRAddress.ChipCtrl.Bit_RegChipCtrl.OpenKeyMode = TRUE;
			priv->MainMemAddress->HwCSMem.CSRAddress.ChipCtrl.Bit_RegChipCtrl.TkipMicEn = FALSE;
			break;
		case ENCRYPT_WEP128:
			memcpy(Info, "\0\0\0", IV_LEN);//fill iv 
			memcpy(Info + IV_LEN, key, keylen);
			memmove( priv->MainMemAddress->HwKeyTable[index].Key.KeyWEP.WepKey, Info, keylen + IV_LEN);
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DecryptModeMulticast =   ENCRYPT_WEP128;
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DecryptModeUnicast =   ENCRYPT_WEP128;
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DecryptKeyAddrUnicast =   ieee2host16(priv->MacHwCfg.KeyMapBaseAddr + index * sizeof(WTWLAN_HWKEYTABLE));
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DefaultAddrKey0 =   ieee2host16(priv->MacHwCfg.KeyMapBaseAddr);
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DefaultAddrKey1 =  ieee2host16( priv->MacHwCfg.KeyMapBaseAddr + sizeof(WTWLAN_HWKEYTABLE));
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DefaultAddrKey2 =   ieee2host16(priv->MacHwCfg.KeyMapBaseAddr + 2 * sizeof(WTWLAN_HWKEYTABLE));
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DefaultAddrKey3 =  ieee2host16( priv->MacHwCfg.KeyMapBaseAddr + 3 * sizeof(WTWLAN_HWKEYTABLE));
			priv->MainMemAddress->HwCSMem.CSRAddress.ChipCtrl.Bit_RegChipCtrl.IVEn = TRUE;
			priv->MainMemAddress->HwCSMem.CSRAddress.ChipCtrl.Bit_RegChipCtrl.OpenKeyMode = TRUE;
            		priv->MainMemAddress->HwCSMem.CSRAddress.ChipCtrl.Bit_RegChipCtrl.TkipMicEn = FALSE;
			break;
		case ENCRYPT_WEP256:
			memcpy(Info, "\0\0\0", IV_LEN);//fill iv 
			memcpy(Info + IV_LEN, key, keylen);
			memmove( priv->MainMemAddress->HwKeyTable[index].Key.KeyWEP.WepKey, Info, keylen + IV_LEN);
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DecryptModeMulticast =   ENCRYPT_WEP256;
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DecryptModeUnicast =   ENCRYPT_WEP256;
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DecryptKeyAddrUnicast =   ieee2host16(priv->MacHwCfg.KeyMapBaseAddr + index * sizeof(WTWLAN_HWKEYTABLE));
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DefaultAddrKey0 =  ieee2host16( priv->MacHwCfg.KeyMapBaseAddr);
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DefaultAddrKey1 =  ieee2host16( priv->MacHwCfg.KeyMapBaseAddr + sizeof(WTWLAN_HWKEYTABLE));
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DefaultAddrKey2 =  ieee2host16( priv->MacHwCfg.KeyMapBaseAddr + 2 * sizeof(WTWLAN_HWKEYTABLE));
			priv->MainMemAddress->HwCSMem.EncyptCSMem.DefaultAddrKey3 =   ieee2host16(priv->MacHwCfg.KeyMapBaseAddr + 3 * sizeof(WTWLAN_HWKEYTABLE));
			priv->MainMemAddress->HwCSMem.CSRAddress.ChipCtrl.Bit_RegChipCtrl.IVEn = TRUE;
			priv->MainMemAddress->HwCSMem.CSRAddress.ChipCtrl.Bit_RegChipCtrl.OpenKeyMode = TRUE;
           		priv->MainMemAddress->HwCSMem.CSRAddress.ChipCtrl.Bit_RegChipCtrl.TkipMicEn = FALSE;		
			break;
		default:
			break;
		}
	}
	return 0;
}
static int
wt4_set_encode(struct net_device *ndev, struct iw_request_info *info,
		   struct iw_point *dwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
	int index, current_index;
	struct obj_key key;

	 FN_ENTER;
	/* Basic checking: do we have a key to set ?
	 * Note : with the new API, it's impossible to get a NULL pointer.
	 * Therefore, we need to check a key size == 0 instead.
	 * New version of iwconfig properly set the IW_ENCODE_NOKEY flag
	 * when no key is present (only change flags), but older versions
	 * don't do it. - Jean II */

	printk(" extra = %x%x%x%x%x%x%x\r\n",extra[0],extra[1],extra[2],extra[3],
				extra[4],extra[5],extra[6]);
	
	if (dwrq->length > 0) {
		index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
		current_index = priv->CurrentWepKeyIndex;
		/* Check the size of the key */
		if (dwrq->length > MAX_KEY_SIZE) {
			return -EINVAL;
		}
		/* Check the index (none -> use current) */
		if ((index < 0) || (index >= 4))//the maxium wep key supported is 4
			index = current_index;
					
		/* Check if the key is not marked as invalid */
		if(!(dwrq->flags & IW_ENCODE_NOKEY)) {
			if(dwrq->length == 5)
				priv->MacParameter.mEncryptMode = ENCRYPT_WEP64;
			else if(dwrq->length == 13)
				priv->MacParameter.mEncryptMode = ENCRYPT_WEP128;
			else if(dwrq->length == 29)
				priv->MacParameter.mEncryptMode = ENCRYPT_WEP256;
			/* Cleanup */
			memset(key.key, 0, MAX_KEY_SIZE);
			/* Copy the key in the driver */
			memcpy(key.key, extra, dwrq->length);
			key.length = dwrq->length;//added by hk 2006.7.15
			//set CurrentWepKeyIndex
			priv->CurrentWepKeyIndex = index;
			/* Send the key to the card */
			set_wep_key(ndev, index, key.key, key.length, 1, 1);
		}	
	} 
	else {
		/* Do we want to just set the transmit key index ? */
		index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
		if ((index >= 0) && (index < 4)) {
			//set_wep_key(ndev, index, NULL, 0, 1, 1);
			priv->CurrentWepKeyIndex = index;
		} else
			/* Don't complain if only change the mode */
			if(!dwrq->flags & IW_ENCODE_MODE) {
				return -EINVAL;
			}
	}
/*
	//added by hk 2006.7.13
	if(dwrq->flags & IW_ENCODE_DISABLED)
		priv->ic.ic_bss->ni_authmode = IEEE80211_AUTH_NONE;	// disable encryption
	if(dwrq->flags & IW_ENCODE_RESTRICTED)
		priv->ic.ic_bss->ni_authmode = IEEE80211_AUTH_SHARED;	// Only Both
	if(dwrq->flags & IW_ENCODE_OPEN)
		priv->ic.ic_bss->ni_authmode = IEEE80211_AUTH_OPEN;	// Only Wep
	if((dwrq->flags & IW_ENCODE_OPEN) || (dwrq->flags & IW_ENCODE_RESTRICTED))
		priv->ic.ic_flags |= IEEE80211_F_PRIVACY;
	else//added by hk 2006.7.17
	{
		priv->ic.ic_flags &= ~IEEE80211_F_PRIVACY;
		priv->MacParameter.mEncryptMode = ENCRYPT_NONE;//added by hk 2006.8.11
		priv->ic.ic_flags &= ~IEEE80211_F_WPA1;//added by hk 2006.8.11
	}

	printk("priv->ic.ic_bss->ni_authmod: %d index: %d dwrq->length: %d", 
		priv->ic.ic_bss->ni_authmode, index, dwrq->length);
	Dump( (char *)key.key,key.length, TRUE, 1 );	
*/
	FN_EXIT(0,0);
	return 0;
}

static int
wt4_get_encode(struct net_device *ndev, struct iw_request_info *info,
		   struct iw_point *dwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
	struct obj_key *key;
	u32 devindex, index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
	u32 authen = 0, invoke = 0, exunencrypt = 0;
	int rvalue = 0;
	union oid_res_t r;
//	printk("command arrive");
         FN_ENTER;
	FN_EXIT(0,0);
	dwrq->length=0x0;
	dwrq->flags=0x8001;
	*extra=0x0;
	
	return rvalue;
}

static int
wt4_get_txpower(struct net_device *ndev, struct iw_request_info *info,
		    struct iw_param *vwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
	 FN_ENTER;
	 
	vwrq->value =WtWlanGetTxPower(priv); //priv->Ndis80211Parameter.TxPower ;
	vwrq->fixed = 1;
	vwrq->disabled = 0;
	  
	FN_EXIT(0,0);
	return 0;
}

static int
wt4_set_txpower(struct net_device *ndev, struct iw_request_info *info,
		    struct iw_param *vwrq, char *extra)
{
	WT_ADAPTER *Adapter = netdev_priv(ndev);
         FN_ENTER;

	 /*using dbm to 0-oxff swap, check later,using fix now*/
	Adapter->Ndis80211Parameter.TxPower =vwrq->value;

	//set ackpower. added by hk 2006.9.15
	WRITE_WT4( 0x174, vwrq->value, 1);

	FN_EXIT(0,0);
	return 0 ;
}


void
wt4_acl_init(struct wt_acl *acl)
{
	sema_init(&acl->sem, 1);
	INIT_LIST_HEAD(&acl->mac_list);
	acl->size = 0;
	acl->policy = MAC_POLICY_OPEN;
}


static void
wt4_clear_mac(struct wt_acl *acl)
{
	struct list_head *ptr, *next;
	struct mac_entry *entry;

	FN_ENTER;
	 
	if (down_interruptible(&acl->sem))
		return;

	if (acl->size == 0) {
		up(&acl->sem);
		return;
	}

	for (ptr = acl->mac_list.next, next = ptr->next;
	     ptr != &acl->mac_list; ptr = next, next = ptr->next) {
		entry = list_entry(ptr, struct mac_entry, _list);
		list_del(ptr);
		kfree(entry);
	}
	acl->size = 0;
	up(&acl->sem);
	 
	FN_EXIT(0,0);
}

void
wt4_acl_clean(struct wt_acl *acl)
{    
        FN_ENTER;
	 
	wt4_clear_mac(acl);
	 
	FN_EXIT(0,0);
}


void
wt4_wpa_ie_init(WT_ADAPTER *priv)
{
	INIT_LIST_HEAD(&priv->bss_wpa_list);
	sema_init(&priv->wpa_sem, 1);
}

void
wt4_wpa_ie_clean(WT_ADAPTER *priv)
{
	return;
}

int
wt4_set_mac_address(struct net_device *ndev, void *addr)
{
	WT_ADAPTER *priv = netdev_priv(ndev);

	FN_ENTER;
	
	if (ndev->addr_len != 6)
		return -EINVAL;

	/*check later	*/
	
	memcpy(priv->ndev->dev_addr,
		       &((struct sockaddr *) addr)->sa_data, 6);

	memcpy( priv->CurrentAddress,
		  &((struct sockaddr *) addr)->sa_data, 6);
	
	//added by hk 2006.6.12
	memcpy( priv->MainMemAddress->HwCSMem.NetMacAddress.MacAddress,
			priv->CurrentAddress,6);
	memcpy( priv->MacParameter.dot11MacAddress,  priv->CurrentAddress, 6 );

	//printk("<0>Function %s Dev_Addr Dump\r\n", __FUNCTION__);
	//Dump( &((struct sockaddr *) addr)->sa_data, 6, TRUE, 1 );

	FN_EXIT(0,0);

	return 0;

}


///////////////////////////////////////////////////////////////////////////////////////////////////////////////
//modify for wt4 driver

//new struct for operation with wt4 regs
//send date to reg
typedef struct _Write_infoTodriverStruct{
	unsigned int value;
	unsigned int offset;
	unsigned int opmode;
} Write_infoTodriverStruct;

//get date from reg
typedef struct _Read_infotodriverStruct{
	int offset;
	int opmode;
} Read_infotodriverStruct;

//get block from reg
typedef struct _Read_blocktodriverStruct{
	int offset;
	int length;
} Read_blocktodriverStruct;

typedef struct _Debug_importStruct{
	int type;
	union{
		Write_infoTodriverStruct WrParam;
		
	} u;
} Debug_importStruct;

#define TYPE0	0x0
#define TYPE1	0x1
#define TYPE2	0x2
#define TYPE3	0x3
#define TYPE4	0x4
#define OpenXmitInt	0x5
#define OpenRecvInt	0x6
#define SetXmitToTestMode	0x07
#define ResetXmitToCommonMode	0x08
#define SetRcvToTestMode	0x09
#define ResetRcvToCommonMode	0x0a
//new additional function
//void wt4_fetch_block(WT_ADAPTER *priv)

void wt4_fetch_block(WT_ADAPTER *priv,int t_offset,int t_length,long *t_buffer);

int//read value in memory block
wt4_fetchblock(WT_ADAPTER *priv,int t_offset,int t_length,char *t_buffer)
{
	wt4_fetch_block(priv,t_offset,t_length,(long *)t_buffer);