wt_stmac.c

mini-PCI driver for LHWT chipsets

#include "wtprecomp.h"

#if DBG
#define _FILENUMBER     'CAMS'
#endif


BOOL StaMgmtSend(IN PWT_ADAPTER Adapter, IN PWTWLAN_TXBUF pWtTxBuf)
{
	PrePareMgmtMPDU( Adapter, pWtTxBuf);
	pWtTxBuf->pQueue = &Adapter->TxFrmQMgmt;
	//printk("\nTxFrameControl: %02x%02x\n", pWtTxBuf->TXHwBuf.pHwTxBuf->dot11Head[1], pWtTxBuf->TXHwBuf.pHwTxBuf->dot11Head[0]);


	//printk("<0> TxFrame TxFrameControl: %02x%02x\n", pWtTxBuf->TXHwBuf.pHwTxBuf->dot11Head[1], pWtTxBuf->TXHwBuf.pHwTxBuf->dot11Head[0]);
	//printk("<0>Dump TxBuf line %d\r\n", __LINE__);
	//Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );
			
	InsertTailQueue( pWtTxBuf->pQueue, WT_GET_TX_BUFFER_SLIST(pWtTxBuf));
	Adapter->TxQMgmt++;

	//printk("File %s Function %s Line %d \n", __FILE__, __FUNCTION__,__LINE__);	
	
	StaMacSend( Adapter );

	return TRUE;
}


BOOL StaMacPcfSend(IN PWT_ADAPTER Adapter )
{
	//TXSTATUS        WtTxStatus;
	//PQUEUE_ENTRY    pEntry;
	PWTWLAN_TXBUF   pWtTxBuf;
	UCHAR		TxBank;
	UCHAR           TxBankStatus;
	PWTWLAN_TXBUF   pWtSentBuf = NULL;


	LONG  TxQueueLen;
        /////////////////////////////////////////////
	//struct sk_buff* Packet;//PNDIS_PACKET Packet;
	/////////////////////////////////////////////

		FN_ENTER;

	//	if there is a data in tx buffer change data type
	if( WtWlanIsDataInHwBank( Adapter , &TxBank) )
	{
		Adapter->MacParameter.bNeedCFACK = FALSE;
		Adapter->CSRAddress->TxCtrl[TxBank] &= ~MASK_TX_START;
		WtWlanChangeDataToDataCFAckInHwBank( Adapter, TxBank );
		Adapter->CSRAddress->TxCtrl[TxBank] = MASK_TX_START;
	}
	else
	{
		TxQueueLen = ( Adapter->TxQLen[AC_BE] + Adapter->TxQLen[AC_BK] + 
			Adapter->TxQLen[AC_VI] + Adapter->TxQLen[AC_VO] );

		if( TxQueueLen )
		{
			pWtTxBuf = WtWlanGetSendPacket( Adapter );
		}
		else
		{
			WtWlanBuildCFAck( Adapter, &pWtTxBuf );
		}
		//
		//prepare CFACK or data CFACK other field later here
		//
		TxBank = WtWlanGetUrgentFreeBank( Adapter );

		TxBankStatus = MASK_TX_BANK & (  Adapter->CSRAddress->TxStatus.RegTxStatus >> (TxBank*3) );
		if( TxBankStatus != TX_STATUS_BANK_EMPTY )
		{
			ASSERT( Adapter->WtTDB.pTxbuf[TxBank] );
			pWtSentBuf = Adapter->WtTDB.pTxbuf[TxBank];
			Adapter->WtTDB.pTxbuf[TxBank]->TxStatus = TxBankStatus;
			Adapter->CSRAddress->TxCtrl[TxBank] &= ~MASK_TX_START;
		}

		pWtTxBuf->TxBank = TxBank;

		NICSendPacket(Adapter, pWtTxBuf);

	}

	if( pWtSentBuf )//?
	{
		switch ( pWtSentBuf->TxStatus )
		{
		case TX_STATUS_SUCCESS_DONE:
			pWtSentBuf->SendStatus = NDIS_STATUS_SUCCESS;
			break;
		case TX_STATUS_FAILURE_DONE:
		case TX_STATUS_FAILURE_TTL:
			pWtSentBuf->SendStatus = NDIS_STATUS_FAILURE;  
			break;
		case TX_STATUS_UNDERGO:
		case TX_STATUS_WAITSEND:
			pWtTxBuf->ReQueueCount = 0;
			pWtSentBuf->SendStatus = NDIS_STATUS_FAILURE;  
			break;
		default :
			pWtSentBuf->SendStatus = NDIS_STATUS_FAILURE;  
			break;
		}
		TxDoneHandle( Adapter, pWtSentBuf);
	}

	FN_EXIT(0, 0);

	return TRUE;
}

BOOL StaMacSend(IN PWT_ADAPTER Adapter)
{
	//TXSTATUS        WtTxStatus;
	PQUEUE_ENTRY    pEntry;
	PWTWLAN_TXBUF   pWtTxBuf;

	LONG            TxQueueLen;

	/////////////////////////////////////////////
	struct sk_buff* Packet;//PNDIS_PACKET Packet;
	/////////////////////////////////////////////

	// check available Hw Tx buffer
	/*
	send 

	1.check available Hw tx buffer
	2.check mgmt queue to send
	3.check Tx Queue 0-4 to send
	4.check SendwaitQueue to send

	send bank 4 is only used for mgmt and ctrl frame only;can be optimize later when hw change.
	*/
	//check later for mgmt frm

	FN_ENTER;

	//printk(" function %s Line = %d, \r\n",__FUNCTION__, __LINE__);	   
	
	while( !IsQueueEmpty( &Adapter->TxFrmQMgmt ) )
	{
		pEntry = RemoveHeadQueue(&Adapter->TxFrmQMgmt); 
		//pWTTxBuf = (PWTWLAN_TXBUF)(pEntry);//for Entry is the first element in our structure!
		pWtTxBuf =(PWTWLAN_TXBUF)list_entry( (struct list_head *)pEntry, WTWLAN_TXBUF, List );
		MpSend(Adapter, pWtTxBuf, TRUE);	//send mgmt
		Adapter->TxQMgmt--;

	}


	TxQueueLen = ( Adapter->TxQLen[AC_BE] + Adapter->TxQLen[AC_BK] + 
		       Adapter->TxQLen[AC_VI] + Adapter->TxQLen[AC_VO] + Adapter->AnQLen + Adapter->PsQLen );

	//DBGPRINT(WT_TRACE, ("TxQueueLen is %d\n", TxQueueLen));

	//printk(" function %s Line = %d, \r\n",__FUNCTION__, __LINE__);	   

	while( TxQueueLen>0 )
	{

		//should send to hw directly ?
		if( WT_TXHW_RESOURCES_AVAIABLE( ieee2host16( Adapter->CSRAddress->TxStatus.RegTxStatus ) )) 
		{
	  // printk(" function %s Line = %d, \r\n",__FUNCTION__, __LINE__);	   
		
			pWtTxBuf = WtWlanGetSendPacket( Adapter );
			
	 //  printk(" function %s Line = %d, \r\n",__FUNCTION__, __LINE__);	   
			
			ASSERT( pWtTxBuf );
			if( pWtTxBuf == NULL )
			{
				break;
			}
			
			MpSend( Adapter,  pWtTxBuf, FALSE);
		}
		else
		{
			break;
		}

		TxQueueLen = ( Adapter->TxQLen[AC_BE] + Adapter->TxQLen[AC_BK] + 
			Adapter->TxQLen[AC_VI] + Adapter->TxQLen[AC_VO] + Adapter->AnQLen + Adapter->PsQLen );

	}

	//while( !IsQueueEmpty( &Adapter->SendWaitQueue ) )
	while( !skb_queue_empty( &Adapter->SendWaitQueue ) )	{
		pEntry = (PQUEUE_ENTRY)(skb_dequeue(&Adapter->SendWaitQueue)); 
                /////////////////////////////////////////////////////////////////////////////////////////
		ASSERT(pEntry);
		Adapter->nWaitSend--;
		Packet = (struct sk_buff*)pEntry;//the skb buffer we want?
		if( NDIS_STATUS_FAILURE == WtSendPacket( Adapter, Packet, TRUE ))
		/////////////////////////////////////////////////////////////////////////////////////////
			break;
	}
	
	   //printk(" function %s Line = %d, \r\n",__FUNCTION__, __LINE__);	   
	
	FN_EXIT(0,0);

        return TRUE;
}

BOOL StaMacRecv(IN PWT_ADAPTER Adapter,  IN PWTWLAN_RXBUF pWtRxBuf)
{

	return TRUE;
}



BOOL Compare(UCHAR *A, UCHAR *B, int length)
{
	int i;

	for (i=0; i<length; i++)
		if (*(A+i) != *(B+i))
			return FALSE;
	return TRUE;
}
PsState PowerCheck(IN PWT_ADAPTER Adapter, IN PWTWLAN_TXBUF pWtTxBuf) //edited by wl 202.6.22 enum
{
	// if in IBSS check power stat and set DA to PWTWLAN_TXBUF->DA for further update queue
	// set pWtTxBuf->PsMode
	int index;
	MacAddr address;
	MacCache *tmpCache;
	BOOL result = FALSE;
	
	addr2((UCHAR *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->dot11Head), address);
	/* computing hash table index */
	index = ((address[4] << 8) + address[5]);
	index -= index & 0x3ffc0;  //"index" < 64

	tmpCache = Adapter->HashList.HashTab[index];


	while (tmpCache)
	{
		result = Compare((UCHAR *)(&address), (UCHAR *)(tmpCache->TA), 6);
		if (result == TRUE)
			if (tmpCache->PowerState == 0)
				return awake;
			else
				return doze;  //??????
		else
			tmpCache = tmpCache->next;

	}

	return awake;
}


BOOL PrePareMgmtMPDU(IN PWT_ADAPTER Adapter, IN PWTWLAN_TXBUF pWtTxBuf)
{
	PWTWLAN_HWTXBUF pHwTxbuf ;
	pHwTxbuf = pWtTxBuf->TXHwBuf.pHwTxBuf;

//			printk("<0>*******Dump TxBuf line %d********\r\n", __LINE__);
//	Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );
	WtWlanSetFragment( Adapter, pWtTxBuf);
//			printk("<0>Dump TxBuf line %d\r\n", __LINE__);
//	Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );
	WtWlanSetRtsThreshold( Adapter, pWtTxBuf);
//			printk("<0>Dump TxBuf line %d\r\n", __LINE__);
//	Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );
	WtWlanSetEncrypt( Adapter,  pWtTxBuf);
//			printk("<0>Dump TxBuf line %d\r\n", __LINE__);
//	Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );
	WtWlanSetSeq( Adapter,  pWtTxBuf);
//			printk("<0>Dump TxBuf line %d\r\n", __LINE__);
//	Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );
	WtWlanSetDurID( Adapter,  pWtTxBuf);
//			printk("<0>Dump TxBuf line %d\r\n", __LINE__);
//	Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );
	WtWlanSetRate( Adapter,  pWtTxBuf);
	WtWlanSetMgmtRate( Adapter,  pWtTxBuf);
//	Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );
	WtWlanSetPowerMgmt( Adapter,  pWtTxBuf);
//			printk("<0>Dump TxBuf line %d\r\n", __LINE__);
//	Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );
	WtWlanSetPreFrame( Adapter,  pWtTxBuf);
//			printk("<0>Dump TxBuf line %d\r\n", __LINE__);
//	Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );
	WtWlanSetTxPower( Adapter,  pWtTxBuf);
//			printk("<0>Dump TxBuf line %d\r\n", __LINE__);
//	Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );
	WtWlanSetCWIN( Adapter,  pWtTxBuf);
//			printk("<0>Dump TxBuf line %d\r\n", __LINE__);
//	Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );
	WtWlanSetRetryNum( Adapter,  pWtTxBuf);
//			printk("<0>Dump TxBuf line %d\r\n", __LINE__);
//	Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );


	// change later
	WtWlanSetRetryNumMgmt( Adapter,  pWtTxBuf);

	WtWlanSetAifs( Adapter,  pWtTxBuf);
//			printk("<0>Dump TxBuf line %d\r\n", __LINE__);
//	Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );
	WtWlanSetQosLevel( Adapter,  pWtTxBuf);
//			printk("<0>Dump TxBuf line %d\r\n", __LINE__);
//	Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );
	WtWlanSetService( Adapter,  pWtTxBuf);
//		printk("<0>Dump TxBuf line %d\r\n", __LINE__);
//	Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );

	WtWlanSetFrameCfg( Adapter,  pWtTxBuf);
//		printk("<0>Dump TxBuf line %d\r\n", __LINE__);
//	Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );

	WtWlanSetCtrl( Adapter,  pWtTxBuf);
//		printk("<0>Dump TxBuf line %d\r\n", __LINE__);
//	Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );

	WtWlanSetMisc( Adapter,  pWtTxBuf);

	//	printk("<0>Dump TxBuf line %d\r\n", __LINE__);
	//Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),300, TRUE, 1 );

	return TRUE;
}

BOOL PrePareMPDU(IN PWT_ADAPTER Adapter, IN PWTWLAN_TXBUF pWtTxBuf)
{
	PWTWLAN_HWTXBUF pHwTxbuf ;
	pHwTxbuf = pWtTxBuf->TXHwBuf.pHwTxBuf;

	WtWlanSetFragment( Adapter, pWtTxBuf);
	WtWlanSetRtsThreshold( Adapter, pWtTxBuf);
	WtWlanSetEncrypt( Adapter,  pWtTxBuf);
	WtWlanSetSeq( Adapter,  pWtTxBuf);
	WtWlanSetDurID( Adapter,  pWtTxBuf);
	WtWlanSetRate( Adapter,  pWtTxBuf);
	WtWlanSetPowerMgmt( Adapter,  pWtTxBuf);
	WtWlanSetPreFrame( Adapter,  pWtTxBuf);
	WtWlanSetTxPower( Adapter,  pWtTxBuf);
	WtWlanSetCWIN( Adapter,  pWtTxBuf);
	WtWlanSetRetryNum( Adapter,  pWtTxBuf);
	WtWlanSetAifs( Adapter,  pWtTxBuf);
	WtWlanSetQosLevel( Adapter,  pWtTxBuf);
	WtWlanSetService( Adapter,  pWtTxBuf);
	WtWlanSetFrameCfg( Adapter,  pWtTxBuf);
	WtWlanSetCtrl( Adapter,  pWtTxBuf);
	WtWlanSetMisc( Adapter,  pWtTxBuf);

	return TRUE;
}

 

PWTWLAN_TXBUF  WtWlanGetSendPacket(IN PWT_ADAPTER Adapter)
{
	PWTWLAN_TXBUF pWtTxBuf = NULL;

        FN_ENTER;
	
	//printk(LEVEL" In function %s Adapter->MacParameter.macmode = %08x\n\r ",__FUNCTION__,Adapter->MacParameter.macmode );
	
	switch ( Adapter->MacParameter.macmode )
	{
	case WLAN_MACMODE_IBSS_STA:
	case WLAN_MACMODE_ESS_STA:

		switch( Adapter->MacParameter.CurrentState )
		{
		case IBSS_IDLE:
		case IBSS_ACTIVE:
			{
				PWTWLAN_TXBUF   pWtTxBufAtim;
				PQUEUE_ENTRY    pEntry;

				// dequeue AnQ to PsQ at begin of ATIM window
				//if( Adapter->MacParameter.mAtimW )
				if( (Adapter->MacParameter.mAtimW) &&(Adapter->dot11Mib.dot11PowerMangementMode == power_save))
				{

					if( !IsQueueEmpty( &Adapter->PsFrmQ ) )
					{

						pEntry = RemoveHeadQueue(&Adapter->PsFrmQ); 
						////////////////////////////////////////////////////
						pWtTxBuf = (PWTWLAN_TXBUF)list_entry( (struct list_head *)pEntry, WTWLAN_TXBUF, List );
						////////////////////////////////////////////////////
						Adapter->PsQLen--;

						AllocTxMgmt(Adapter,  &pWtTxBufAtim);
						ASSERT(pWtTxBufAtim);

						if( pWtTxBufAtim == NULL )
						{

							pWtTxBuf->SendStatus = NDIS_STATUS_FAILURE;
							//dev_kfree_skb(pWtTxBuf->skb);
							WT_FREE_SEND_PACKET( Adapter, pWtTxBuf);
							pWtTxBuf = NULL;
							break;
						}
						else
						{

							pWtTxBufAtim->pAtimPsBuf = pWtTxBuf;
							WtWlanBuildAtim(Adapter, pWtTxBuf, &pWtTxBufAtim);
							return pWtTxBufAtim;
						}
					}


				}
				else
				{