wt_ioctl.c

mini-PCI driver for LHWT chipsets

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);

	//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
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);
	printk("wt4_fetchblock function is ok\n");
	return 0;
}

//wt4_read_reg(WT_ADAPTER *priv, unsigned long offset, Mode mode)
int 
wt4_readmem(WT_ADAPTER *priv, Read_infotodriverStruct *t_info)
{
	int t_tmp;
	t_tmp=wt4_read_reg( priv, t_info->offset, (Op_Mode) t_info->opmode);
	//printk("wt4_readmem function is ok\n");
	return t_tmp;
}

//void wt4_write_reg(WT_ADAPTER *priv, long value, long offset, Mode mode)
int
wt4_writemem(WT_ADAPTER *priv, Write_infoTodriverStruct *t_info)
{
	wt4_write_reg( priv, t_info->value, t_info->offset, (Op_Mode) t_info->opmode );
	//printk("wt4_writemem function is ok\n");
	return 0;
}

int
subioctl_readmem_s_addr(struct net_device *ndev, struct iw_request_info *info,
		      struct iw_point *data, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
	
	Read_infotodriverStruct t_info;
	memcpy( &t_info, extra, sizeof(Read_infotodriverStruct));
	
	printk("%s: subioctl_readmem 0x%08X\tlen: %d\n", ndev->name, priv->priv_oid,
	       data->length);
	
	printk("offset= 0x%04x\n opmode= 0x%04x\n ",t_info.offset,t_info.opmode);
	
	priv->readmem_val=wt4_readmem(priv,&t_info);		//read wt4 memory function	
	       
	printk("priv->readmem_val = %x\n",priv->readmem_val);
	
	return 0;
}

int  
subioctl_change_rf_type(struct net_device *ndev, struct iw_request_info *info,
		      struct iw_point *data, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
	
	int RF_Type; 
	memcpy( &RF_Type, extra, sizeof(int));
	
	printk("<0>RF_Type 0x%08X RF_Type: %d\n", RF_Type, RF_Type);
#if 0
#define RF2827 0
#define RF2829 1
#define RFMD   2
#define RFAiroha 3
#endif	
	switch( RF_Type )
		{
		case RF2827:
				priv->RegMacParameter.RfType = RF2827;
				printk("change Rf type to RF2827\n" );
			break;
		case RF2829:
				priv->RegMacParameter.RfType = RF2829;
				printk("change Rf type to RF2827\n" );
			break;
		case RF2230:
				priv->RegMacParameter.RfType = RF2230;
				printk("change Rf type to RF2827\n" );
			break;
		case RFMD:
				priv->RegMacParameter.RfType = RFMD;
				printk("change Rf type to RF2827\n" );
			break;
		case RFAiroha:
				priv->RegMacParameter.RfType = RFAiroha;
				printk("change Rf type to RF2827\n" );
			break;
		default:
				priv->RegMacParameter.RfType = RF2829;
				printk("change Rf type to RF2827\n" );
			break;
		}
	
		printk(" test function only\n" );

	return 0;
}

int
subioctl_readmem_g_val(struct net_device *ndev, struct iw_request_info *info,
		      struct iw_point *data, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
	
	printk("%s: subioctl_readmem_g_val 0x%08X\tlen: %d\n", ndev->name, priv->priv_oid,
	       data->length);
	
	printk("priv->readmem_val = 0x%x\n",priv->readmem_val);
	*((unsigned int*)extra) = priv->readmem_val;
	data->length=1;
	printk("extra = 0x%x\n",*((unsigned int*)extra));
	
	return 0;
}


int
subioctl_writemem(struct net_device *ndev, struct iw_request_info *info,
		      struct iw_point *data, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
	Write_infoTodriverStruct *t_info;
	
	t_info=((Write_infoTodriverStruct *) extra);
	
	printk("%s: subioctl_writemem 0x%08X\tlen: %d\n", ndev->name, priv->priv_oid,
	       data->length);
	
	printk("value= 0x%08x\n offset= 0x%04x\n opmode= 0x%04x\n ",t_info->value,t_info->offset,t_info->opmode);
	
	wt4_writemem(priv,t_info);				//write wt4 memory function
	return 0;
}


int
subioctl_fetchblock(struct net_device *ndev, struct iw_request_info *info,
		      struct iw_point *data, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
	Read_blocktodriverStruct *t_info;
	unsigned int t_offset;
	unsigned int t_length;
	void *t_buffer;
	
	t_info =((Read_blocktodriverStruct *) extra);	
	t_offset=t_info->offset;
	t_length=t_info->length;
	t_buffer=kmalloc(t_length,GFP_KERNEL); 
		
	printk("offset=%d ,length=%d\n", t_offset,t_length );
	printk("%s: subioctl_fetchblock 0x%08X\tlen: %d\n", ndev->name, priv->priv_oid,
	       data->length);  
	printk("info= 0x%04x\n",*((u32 *) extra));
	
	wt4_fetchblock(priv,t_offset,t_length,t_buffer);				//fetch wt4 block function
	
	Dump((char *)t_buffer,t_length,TRUE,1);			//print the block
	
	kfree(t_buffer);
	
	return 0;
}

int
wt4_debug_export(struct net_device *ndev, struct iw_request_info *info,
		  __u32 * uwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
	Debug_importStruct *t_dbgimp = (Debug_importStruct *)extra;
	//char *t_extra = (char *)(&t_dbgimp->u.WrParam);
	
	t_dbgimp->type = (int)priv->Cmd_Type;
	subioctl_readmem_g_val(ndev, info,(struct iw_point *)uwrq, extra);
 
	return 0;
}

//////////////////////////////////////////////////////////////////////////////////////////////////
extern void SwitchWirelessMode( IN PWT_ADAPTER Adapter,IN MAC_TYPE ABGMode);


void wt4_changeMode(WT_ADAPTER *priv,int Mode)
{

	switch(Mode)
	{
		case 1:
		{
			priv->Ndis80211Parameter.ABGMode = IEEE80211B_ONLY;
			
			priv->RegMacParameter.ABGMode = IEEE80211B_ONLY;
			priv->RegMacParameter.Channel = 1;
			priv->RegMacParameter.TxRate = 2;
			printk("<0>Current Setting Mode is 80211B");
			break;
		}
		case 2:
		{
			priv->Ndis80211Parameter.ABGMode = IEEE80211G_ONLY;
			
			priv->RegMacParameter.ABGMode = IEEE80211G_ONLY;
			priv->RegMacParameter.Channel = 1;
			priv->RegMacParameter.TxRate = 2;
			printk("<0>Current Setting Mode is 80211G");
			break;
		}
		case 3:
		{
			priv->Ndis80211Parameter.ABGMode = IEEE80211A_ONLY;
			
			priv->RegMacParameter.ABGMode = IEEE80211A_ONLY;
			//priv->RegMacParameter.ABGMode = CARD_DEFAULT_ABGMODE;
			//priv->RegMacParameter.Channel = CARD_DEFAULT_CHANNEL;
			priv->RegMacParameter.Channel = 36;
			//priv->RegMacParameter.TxRate = CARD_DEFAULT_TXRATE;
			priv->RegMacParameter.TxRate = 12;
			printk("<0>Current Setting Mode is 80211A");
			break;
		}
		default:
		        priv->Ndis80211Parameter.ABGMode = IEEE80211B_ONLY;
			
			priv->RegMacParameter.ABGMode = IEEE80211B_ONLY;
			//priv->Ndis80211Parameter.ABGMode = IEEE80211G_ONLY;
			//priv->RegMacParameter.ABGMode = IEEE80211G_ONLY;
			priv->RegMacParameter.Channel = 1;
			priv->RegMacParameter.TxRate = 2;
			printk("<0>Current Setting Mode is a invalid Mode");
	}
	
	InitMacStat(priv);
	WtDisableInterrupts( priv );
	udelay(1000);//delay time must less than 10000 in arm platform ???
	SwitchWirelessMode( priv, priv->Ndis80211Parameter.ABGMode);
	LoadDefaultParameter(priv );
	WtEnableInterrupts( priv );
	
}

void 
Wt4ChangeRate(WT_ADAPTER *priv, int rate)
{
	priv->RegMacParameter.TxRate = 2*rate;
	udelay(100);
	LoadDefaultParameter(priv );	
} 
/////////////////////////////////////////////////////////////////////////////////////////////////////////



int
wt4_debug_import(struct net_device *ndev, struct iw_request_info *info,
		  __u32 * uwrq, char *extra)
{
	WT_ADAPTER *priv = netdev_priv(ndev);
	Debug_importStruct *t_dbgimp = (Debug_importStruct *)extra;
	Write_infoTodriverStruct *t_info;
	char *t_extra;
	priv->Cmd_Type=t_dbgimp->type;
     
	
	
	switch(t_dbgimp->type){
		case TYPE0:
			t_extra= (char *)&t_dbgimp->u.WrParam;
			subioctl_readmem_s_addr(ndev, info,( struct iw_point *)uwrq, t_extra);
			break;
		case TYPE1:
			t_extra= (char *)&t_dbgimp->u.WrParam;
			subioctl_writemem(ndev, info,( struct iw_point *)uwrq, t_extra);
			break;
		case TYPE2:
			t_extra= (char *)&t_dbgimp->u.WrParam;
			subioctl_fetchblock(ndev, info,( struct iw_point *)uwrq, t_extra);
			break;
		case TYPE3:
			{
			t_info=&t_dbgimp->u.WrParam;
		        wt4_changeMode(priv,t_info->value);
				//printk(LEVEL"   test Adapter->debugvar1 = %08x\n",  priv->debugvar1);
				
				//printk(LEVEL"   test Adapter->debugvar2 = %08x\n" ,  priv->debugvar2);
				
				//printk(LEVEL"   test Adapter->debugvar3 = %08x\n" ,  priv->debugvar3);
			}

			break;
		case TYPE4:

			break;
		case OpenXmitInt://5
			{	
		        WTWLAN_TXBUF   *WtTxBuf = NULL;
		        WTWLAN_HWTXBUF *HwTxBuf = NULL;	
	                
						priv->MainMemAddress->HwCSMem.CSRAddress.IntMaskCtrl &= ~(MASK_INT_TXEND);

						priv->MainMemAddress->HwCSMem.CSRAddress.IntMaskCtrl &= ~(MASK_INT_TXEND);
	                HwTxBuf = kmalloc((1600+sizeof(WTWLAN_TAUXB)+80), GFP_ATOMIC);
	                if(HwTxBuf == NULL){
                        //printk(LEVEL"  kmalloc for HwTxBuf failed !\n");
	                }
	
                        WtTxBuf = kmalloc(sizeof(WTWLAN_TXBUF), GFP_ATOMIC);
	                if(WtTxBuf == NULL){
                        //printk(LEVEL"  kmalloc for WtTxBuf failed !\n");
	                }
 
	                else{
	
                        //printk(LEVEL"  kmalloc for HwTxBuf succeed !\n");
	                //printk(LEVEL"  kmalloc for WtTxBuf succeed !\n");
 
	                memset(HwTxBuf, 0, 1600+sizeof(WTWLAN_TAUXB)+80);
	                memset(WtTxBuf, 0, sizeof(WTWLAN_TXBUF));
 
	                priv->WtTDB.pTxbuf[1]  = WtTxBuf;
	                WtTxBuf->TXHwBuf.pHwTxBuf = HwTxBuf;
	                WtTxBuf->TxBank = 1;
	                NICSendPacket(priv,WtTxBuf);
	                //printk(LEVEL"  we left function NICSendPacket successfully (: !\n");
                        }
 
			}
			
			break;
		case OpenRecvInt:		//6
			priv->MainMemAddress->HwCSMem.CSRAddress.IntMaskCtrl &= ~(MASK_INT_RXEND);

			break;
		case SetXmitToTestMode:		//0x07
			priv->bSend_Test=TRUE;
			break;
		case ResetXmitToCommonMode:	//0x08
			priv->bSend_Test=FALSE;
			break;
		case SetRcvToTestMode:		//0x09
			priv->bRecv_Test=TRUE;
			break;
		case ResetRcvToCommonMode:	//0x0a
			priv->bRecv_Test=FALSE;
			break;	
		default:
			printk("<0>the parameter not right\n\r");
			printk("<0>Read Register : iwpriv ethx dbg_import 0 offset width \n\r");
			printk("<0>Write Register: iwpriv ethx dbg_import 1 value  offset width \n\r");
			printk("<0>fetch block   : iwpriv ethx dbg_import 2 offset length \n\r");
			printk("<0>Change mode   : iwpriv ethx dbg_import 3 mode  \n\r");
			printk("<0>	Noting   : mode=0 is 11b \n\r");
			printk("<0>	           mode=1 is 11g \n\r");
			printk("<0>	           mode=2 is 11a \n\r");
			break;
	}

 
	return 0;
}


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////




static const iw_handler wt4_handler[] = {
	(iw_handler) wt4_commit,	/* SIOCSIWCOMMIT */
	(iw_handler) wt4_get_name,	/* SIOCGIWNAME */
	(iw_handler) NULL,	/* SIOCSIWNWID */
	(iw_handler) NULL,	/* SIOCGIWNWID */
	(iw_handler) wt4_set_freq,	/* SIOCSIWFREQ */
	(iw_handler) wt4_get_freq,	/* SIOCGIWFREQ */
	(iw_handler) wt4_set_mode,	/* SIOCSIWMODE */
	(iw_handler) wt4_get_mode,	/* SIOCGIWMODE */
	(iw_handler) wt4_set_sens,	/* SIOCSIWSENS */
	(iw_handler) wt4_get_sens,	/* SIOCGIWSENS */
	(iw_handler) NULL,	/* SIOCSIWRANGE */
	(iw_handler) wt4_get_range,	/* SIOCGIWRANGE */
	(iw_handler) NULL,	/* SIOCSIWPRIV */
	(iw_handler) NULL,	/* SIOCGIWPRIV */
	(iw_handler) NULL,	/* SIOCSIWSTATS */
	(iw_handler) NULL,	/* SIOCGIWSTATS */
	iw_handler_set_spy,	/* SIOCSIWSPY */
	iw_handler_get_spy,	/* SIOCGIWSPY */
	iw_handler_set_thrspy,	/* SIOCSIWTHRSPY */
	iw_handler_get_thrspy,	/* SIOCGIWTHRSPY */
	(iw_handler) wt4_set_wap,	/* SIOCSIWAP */
	(iw_handler) wt4_get_wap,	/* SIOCGIWAP */
	(iw_handler) NULL,	/* -- hole -- */
	(iw_handler) NULL,	/* SIOCGIWAPLIST depreciated */
	(iw_handler) wt4_set_scan,	/* SIOCSIWSCAN */
	(iw_handler) wt4_get_scan,	/* SIOCGIWSCAN */
	(iw_handler) wt4_set_essid,	/* SIOCSIWESSID */
	(iw_handler) wt4_get_essid,	/* SIOCGIWESSID */
	(iw_handler) wt4_set_nick,	/* SIOCSIWNICKN */
	(iw_handler) wt4_get_nick,	/* SIOCGIWNICKN */
	(iw_handler) NULL,	/* -- hole -- */
	(iw_handler) NULL,	/* -- hole -- */
	(iw_handler) wt4_set_rate,	/* SIOCSIWRATE */
	(iw_handler) wt4_get_rate,	/* SIOCGIWRATE */
	(iw_handler) wt4_set_rts,	/* SIOCSIWRTS */
	(iw_handler) wt4_get_rts,	/* SIOCGIWRTS */
	(iw_handler) wt4_set_frag,	/* SIOCSIWFRAG */
	(iw_handler) wt4_get_frag,	/* SIOCGIWFRAG */
	(iw_handler) wt4_set_txpower,	/* SIOCSIWTXPOW */
	(iw_handler) wt4_get_txpower,	/* SIOCGIWTXPOW */
	(iw_handler) wt4_set_retry,	/* SIOCSIWRETRY */
	(iw_handler) wt4_get_retry,	/* SIOCGIWRETRY */
	(iw_handler) wt4_set_encode,	/* SIOCSIWENCODE */
	(iw_handler) wt4_get_encode,	/* SIOCGIWENCODE */
	(iw_handler) NULL,	/* SIOCSIWPOWER */
	(iw_handler) NULL,	/* SIOCGIWPOWER */
};

/* The low order bit identify a SET (0) or a GET (1) ioctl.  */


#define WT4_DBG_IMPORT	SIOCIWFIRSTPRIV+0
#define WT4_DBG_EXPORT	SIOCIWFIRSTPRIV+1

//#define PRISM54_DBG_OID	SIOCIWFIRSTPRIV+14
//#define PRISM54_DBG_GET_OID	SIOCIWFIRSTPRIV+15
//#define PRISM54_DBG_SET_OID	SIOCIWFIRSTPRIV+16

/* Note : limited to 128 private ioctls (wireless tools 26) */

static const struct iw_priv_args wt4_private_args[] = {
/*{ cmd, set_args, get_args, name } */
	 
	{WT4_DBG_EXPORT, 0, IW_PRIV_TYPE_INT | 256, "dbg_export"},
	{WT4_DBG_IMPORT, IW_PRIV_TYPE_INT | 256, 0, "dbg_import"},
	 

};

static const iw_handler wt4_private_handler[] = {
	(iw_handler) wt4_debug_import,
	(iw_handler) wt4_debug_export,

};


const struct iw_handler_def wt4_handler_def = {
	.num_standard = sizeof (wt4_handler) / sizeof (iw_handler),
	.num_private = sizeof (wt4_private_handler) / sizeof (iw_handler),
	.num_private_args =
	    sizeof (wt4_private_args) / sizeof (struct iw_priv_args),
	.standard = (iw_handler *) wt4_handler,
	.private = (iw_handler *) wt4_private_handler,
	.private_args = (struct iw_priv_args *) wt4_private_args,
#if WIRELESS_EXT == 16
	.spy_offset = offsetof(WT_ADAPTER, spy_data),
#endif /* WIRELESS_EXT == 16 */
};