wt_eth.c

mini-PCI driver for LHWT chipsets

/* Copyright (C) 2005 LHWT Inc. */

#include "wtprecomp.h" 
 
/******************************************************************************
    Network Interface functions
******************************************************************************/
//////////////////////////////////////////////////////////////////////////////////////////////////////////

#if 0
void GenTxTestCase( WTWLAN_TXBUF *WtTxBuf, PUCHAR txauxbuf, PUCHAR pHead, PUCHAR pBody )
{       
	
	FN_ENTER;
	printk(LEVEL" Now we entered  function %s  !!!\n", __FUNCTION__);
	printk(LEVEL" The address of WtTxBuf is %08x\r\n",WtTxBuf);
	
	int temp = sizeof(WTWLAN_TAUXB) ;
	printk(LEVEL" The size of WTWLAN_TAUXB is %d\r\n",temp);
		
	memcpy( &WtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf, txauxbuf, sizeof(WTWLAN_TAUXB) );
	printk(LEVEL" &WtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf = %08x\r\n",&WtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf);
	
	memset(WtTxBuf->TXHwBuf.pHwTxBuf->dot11Head, 0,80);
	memcpy(WtTxBuf->TXHwBuf.pHwTxBuf->dot11Head, pHead, 24 );  // from hw cfg
	printk(LEVEL" WtTxBuf->TXHwBuf.pHwTxBuf->dot11Head = %08x\r\n",WtTxBuf->TXHwBuf.pHwTxBuf->dot11Head);
	
	memset(WtTxBuf->TXHwBuf.pHwTxBuf->Buffer, 0, 1600);
	memcpy( WtTxBuf->TXHwBuf.pHwTxBuf->Buffer, pBody, 48 );
	printk(LEVEL" WtTxBuf->TXHwBuf.pHwTxBuf->Buffer = %08x\r\n",WtTxBuf->TXHwBuf.pHwTxBuf->Buffer);

	
	FN_EXIT(0,0);
}

void GentxBeacon( WTWLAN_TXBUF *WtTxBuf )
{

	UCHAR TxAuxBuffer[] = {0x30,0x00,0x39,0x0e,0x1f,0x00,0xff,0x03,
			       0x18,0x0c,0x00,0x3f,0x0c,0x00,0x00,0x00,
			       0x00,0x3a,0x1c,0x04,0x14,0x03,0x00,0x01};

	UCHAR Head[] = { 0x80,0x00,0x00,0x00,
			 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
			 0x00,0x02,0x6F,0x20,0x51,0xA0,
			 0x00,0x02,0x6F,0x20,0x51,0xA0,
			 0xE0,0x33 };

	UCHAR Body[] = {0x37,0x50,0x60,0x04,0x00,0x00,0x00,0x00,
			0x64,0x00,0x01,0x00,0x00,0x0F,0x42,0x49,
			0x47,0x44,0x4F,0x54,0x74,0x74,0x5F,0x31,
			0x31,0x77,0x74,0x34,0x61,0x01,0x08,0x8C,
			0x12,0x98,0x24,0xB0,0x48,0x60,0x6C,0x03,
			0x01,0x24,0x05,0x04,0x00,0x01,0x00,0x00 };

	GenTxTestCase( WtTxBuf, TxAuxBuffer, Head, Body );
}



int TestSendPacket(WT_ADAPTER *Adapter, WTWLAN_TXBUF *WtTxBuf)
{ 

        UCHAR TxBank;
	int Length;
	int Status = 1;//NDIS_STATUS_SUCCESS;
	PWTWLAN_HWTXBUF  pHwTxBuf;
	//unsigned long flags;
	
	printk(LEVEL" The address of WtTxBuf is %08x\r\n",WtTxBuf);
	
	//FN_ENTER;
	printk(LEVEL" Now we entered  function %s  !!!\n", __FUNCTION__);
 
	//spin_lock_irqsave(&Adapter->slock, flags);
	
	TxBank = WtTxBuf->TxBank;
	//Length = WtTxBuf->skb->len < ETH_ZLEN  ? ETH_ZLEN : WtTxBuf->skb->len ;
	Length = 1600+sizeof(WTWLAN_TAUXB)+80;
	
	
	
        printk("In function %s before  GentxBeacon\r\n", __FUNCTION__);	
	GentxBeacon( WtTxBuf );
 		
        pHwTxBuf = WtTxBuf->TXHwBuf.pHwTxBuf;
		
        memcpy(&(Adapter->MainMemAddress->TxBufMap[TxBank].HwTxBuf), pHwTxBuf, Length);	
	//Dump( (char *)(&(Adapter->MainMemAddress->TxBufMap[TxBank].HwTxBuf)),Length, TRUE, 1 );
	printk(LEVEL" In function %s memcpy succed (:\r\n", __FUNCTION__);
	printk(LEVEL" %s the value of Length is %d !\r\n", __FUNCTION__,Length);
	
	//Dump( (char *)pHwTxBuf,Length, TRUE, 1 );	
        
    
	printk(LEVEL" In function %s Dump succeed !\r\n", __FUNCTION__);	
	
	 
	Adapter->WtTDB.pTxbuf[TxBank] = WtTxBuf;
		
	Adapter->CSRAddress->TxCtrl[TxBank] = MASK_TX_START;

       
	//spin_unlock_irqrestore(&Adapter->slock, flags);
	printk(" In function %s the last step succeed (:  \r\n", __FUNCTION__);
 		
	//FN_EXIT(0,0);
	return Status;

}
#endif

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

NDIS_STATUS WtSendPacket(IN PWT_ADAPTER Adapter, IN struct sk_buff* Packet, IN BOOL bFromQueue)
{
	NDIS_STATUS     Status = NDIS_STATUS_SUCCESS;
	PWTWLAN_TXBUF   pWtTxBuf = NULL;
	ULONG           BytesCopied;
	

	FN_ENTER;

	AllocTxBuff(Adapter, &pWtTxBuf);
	
	//printk(" In File %s function %s line %d \r\n", __FILE__,  __FUNCTION__, __LINE__);

	if( NULL == pWtTxBuf )
	{/* No send buf available, put it to SendwaitQueue */

		printk(" In File %s function %s line %d \r\n", __FILE__,  __FUNCTION__, __LINE__);
	
		if(bFromQueue)
		{
		   //InsertTailQueue(&Adapter->SendWaitQueue, WT_GET_PACKET_MR(Packet));//???
		   //skb_queue_tail( &Adapter->SendWaitQueue, Packet );//should be locked
		   // Adapter->nWaitSend++;
		   Status = NDIS_STATUS_FAILURE;
		   goto out;

		}
		else
		{
			if( Adapter->nWaitSend > MAX_SENDWAITQUEUE_LEN )
			{ 
			    //resource protocol lay
			    //spin_lock(&Adapter->SendLock);
                            //spin_unlock(&Adapter->SendLock);  

			    Status = NDIS_STATUS_RESOURCE;
			    goto out;
			              

			}
			else
			{
		   	    skb_queue_tail( &Adapter->SendWaitQueue, Packet );
			    Adapter->nWaitSend++;

						
			}
		}
	}
	else
	{
		ASSERT(pWtTxBuf);
		pWtTxBuf->skb = Packet;
		
	//printk(" In File %s function %s line %d \r\n", __FILE__,  __FUNCTION__, __LINE__);
		
                BytesCopied = Wt802_3to802_11( Adapter, pWtTxBuf ); 

	//printk(" In File %s function %s line %d BytesCopied = %d\r\n", __FILE__,  __FUNCTION__, __LINE__,BytesCopied);
				
		Adapter->nBusySend++;
		
		//if(Adapter->nBusySend > 10)
		//Adapter->nBusySend = Adapter->nBusySend;

	//printk(" In File %s function %s line %d \r\n", __FILE__,  __FUNCTION__, __LINE__);

		WtTxQosPreProcess(pWtTxBuf); // Get priority  and swap to out queue num @ QosTag
		PowerCheck( Adapter,  pWtTxBuf);	 
		PrePareMPDU( Adapter, pWtTxBuf); //fill Tx AUX buffer
                
	//printk(" In File %s function %s line %d \r\n", __FILE__,  __FUNCTION__, __LINE__);

		if((pWtTxBuf->PsMode != awake) && ( Adapter->MacParameter.mIbss))
		{
			printk(" In File %s function %s line %d \r\n", __FILE__,  __FUNCTION__, __LINE__);
			
			pWtTxBuf->pQueue = &Adapter->PsFrmQ;
	      		InsertTailQueue( pWtTxBuf->pQueue, WT_GET_TX_BUFFER_SLIST(pWtTxBuf));
			Adapter->PsQLen++;
			
		}
		else
		{
			switch ( pWtTxBuf->QosTag )
			{
				case AC_BE:
				           pWtTxBuf->pQueue = &Adapter->TxFrmQBE;
					   break;
				case AC_BK:
					   pWtTxBuf->pQueue = &Adapter->TxFrmQBK;
					   break;
				case AC_VI:
					   pWtTxBuf->pQueue = &Adapter->TxFrmQVI;
					   break;
				case AC_VO:
					   pWtTxBuf->pQueue = &Adapter->TxFrmQVO;
					   break;
				default :
					   pWtTxBuf->QosTag = AC_BE;
					   pWtTxBuf->pQueue = &Adapter->TxFrmQBE;
					   break;
			}
			
		      	InsertTailQueue( pWtTxBuf->pQueue, WT_GET_TX_BUFFER_SLIST(pWtTxBuf));
			Adapter->TxQLen[pWtTxBuf->QosTag]++;
		
		}

		pWtTxBuf->ReQueueCount = 0;


	}

	
	FN_EXIT(0,0);
	
out:
		return Status;

}  


NDIS_STATUS NICSendPacket(IN PWT_ADAPTER Adapter, IN PWTWLAN_TXBUF pWtTxBuf)
{
	UCHAR              TxBank;
	int                Length, Length1, Length2;
	NDIS_STATUS        Status = NDIS_STATUS_SUCCESS;
	PWTWLAN_HWTXBUF    pHwTxBuf;
	ULONG              LenLlc;
	
	FN_ENTER;
        
	//Dump( (char *)(0xea000000),300, TRUE, 1 );
	
	TxBank = pWtTxBuf->TxBank;
	//printk("\nThe TxBank is %d\n", TxBank);
	
        //printk("%s LEVEL  in step1  \r\n", __FUNCTION__);
        Length1 = sizeof( WTWLAN_TAUXB ) + MAX_HW_HEAD_LEN;
	
	//printk("File %s Line %d : pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf.DataLen= %04x \n", __FILE__, __LINE__, pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf.DataLen);
        Length2 = ieee2host16(pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf.DataLen) +3;
	
	Length  = Length1 + Length2; 
		
	pHwTxBuf = pWtTxBuf->TXHwBuf.pHwTxBuf;
	
        //printk("%s LEVEL  in step2  \r\n", __FUNCTION__);
        //printk("<0>*********************************************\n\r");
	//Dump( (char *)pHwTxBuf,Length, TRUE, 1 );

	//printk("File %s Line %d : Length1= %04x \n", __FILE__, __LINE__, Length1);
		
	Length1 = (Length1 & (~0x3)) + ( (Length1&0x3)? 4:0 );
		
	//printk("File %s Line %d : Length1= %04x \n", __FILE__, __LINE__, Length1);
	//Dump( (char *)(&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf),Length, TRUE, 1 );
	memcpy( 
		&(Adapter->MainMemAddress->TxBufMap[TxBank].HwTxBuf),
		&pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf,
		Length1
		);
	//Dump( (char *)(&(Adapter->MainMemAddress->TxBufMap[TxBank].HwTxBuf)),Length, TRUE, 1 );
	//printk("File %s Line %d : Length1= %04x \n", __FILE__, __LINE__, Length1);
	
	
/*
	i = 0;
	while(i<Length1 )
	{
		*((unsigned short *)(&(Adapter->MainMemAddress->TxBufMap[TxBank].HwTxBuf)) + i/2 ) =  *((unsigned short *)(&(pWtTxBuf->TXHwBuf.pHwTxBuf->TxAUXBuf)) + i/2 );		 
		i+=2;
	}
			
*/		
		
		
        //Dump( (char*)(&(Adapter->MainMemAddress->TxBufMap[TxBank].HwTxBuf)), Length, TRUE, 1 );			

	//*((unsigned short *)(&Adapter->MainMemAddress->TxBufMap[TxBank].HwTxBuf.dot11Head[6])) = 0x4E79;
		
	//printk("(Adapter->MainMemAddress->TxBufMap[TxBank].HwTxBuf.Buffer) = %08x\r\n",(Adapter->MainMemAddress->TxBufMap[TxBank].HwTxBuf.Buffer));
	
	//printk("");
		
	//printk("%s LEVEL  in step3  \r\n", __FUNCTION__);	
	
	//printk("File %s Line %d : Length2= %04x \n", __FILE__, __LINE__, Length2);

	Length2 = (Length2 & (~0x3)) + ( (Length2&0x3)? 4:0 );	

	//printk("File %s Line %d : Length2= %04x \n", __FILE__, __LINE__, Length2);
	
	if( pWtTxBuf->bMgmtFrm )
	{

	
	memcpy( 
		((char*)((Adapter->MainMemAddress->TxBufMap[TxBank].HwTxBuf.Buffer))),
		pWtTxBuf->TXHwBuf.pHwTxBuf->Buffer,
		Length2
	       );
	 
	/* 
		i = 0;
		while(i<Length2 )
		{
			*((unsigned short *)(&(Adapter->MainMemAddress->TxBufMap[TxBank].HwTxBuf.Buffer)) + i/2 ) =  *((unsigned short *)(&(pWtTxBuf->TXHwBuf.pHwTxBuf->Buffer)) + i/2 );		 
			i+=2;
		}
	   */
	   
	}
	else
	{

		LenLlc	=  pWtTxBuf->LlcHeadLen ;
		
		//printk(LEVEL" Llc Len = %d DataLen = %d\r\n",LenLlc, Length2);
		
		
		if( ( LenLlc != 0 ) &&
		(( Length2 + pWtTxBuf->LlcHeadLen) <  Adapter->MacHwCfg.BodyLen) )
		{ 
			
			memcpy( 
				((char*)(&(Adapter->MainMemAddress->TxBufMap[TxBank].HwTxBuf.Buffer))),
				pWtTxBuf->TXHwBuf.pHwTxBuf->Buffer,
				pWtTxBuf->LlcHeadLen
			);
		/*
			i = 0;
			while(i<pWtTxBuf->LlcHeadLen )
			{
				*((unsigned short *)(&(Adapter->MainMemAddress->TxBufMap[TxBank].HwTxBuf.Buffer)) + i/2 ) =  *((unsigned short *)(&(pWtTxBuf->TXHwBuf.pHwTxBuf->Buffer)) + i/2 );		 
				i+=2;
			}
		*/
				
		//printk(LEVEL"  Function %s Line %d \r\n", __FUNCTION__, __LINE__);
		}
		else
		{
			//printk(LEVEL"  Function %s Line %d \r\n", __FUNCTION__, __LINE__);			
			LenLlc = 0;
		}
		

		if( (Length2 - LenLlc) < 0 )
		return -1;
		
		//printk(LEVEL"  Function %s Line %d \r\n", __FUNCTION__, __LINE__);
		
		memcpy( 
				((char*)(&(Adapter->MainMemAddress->TxBufMap[TxBank].HwTxBuf.Buffer))+LenLlc),
				( pWtTxBuf->skb )->data + WLAN_ETHHDR_LEN,
				Length2 - LenLlc
			);
		
		/*
		
		i = 0;
		while(i<Length2 - LenLlc )
		{
			*((unsigned short *)(((char*)(&(Adapter->MainMemAddress->TxBufMap[TxBank].HwTxBuf.Buffer))+LenLlc)) + i/2 ) =  *((unsigned short *)(( pWtTxBuf->skb )->data + WLAN_ETHHDR_LEN) + i/2 );		 
			i+=2;
		}
		
		*/
	 }      

#if 0	 
	printk("<0> Tx Buffer in Hw Bank %d \n", TxBank);
	Dump( (char*)(&(Adapter->MainMemAddress->TxBufMap[TxBank].HwTxBuf)), Length, TRUE, 1 );	
	printk("%s LEVEL  in step4  \r\n", __FUNCTION__);      
#endif

	Adapter->CSRAddress->TxCtrl[TxBank] = host2ieee32(MASK_TX_START);
	Adapter->WtTDB.pTxbuf[TxBank] = pWtTxBuf;
 
	//printk("%s LEVEL  in step5 \r\n", __FUNCTION__);
        FN_EXIT(0,0);
	
	return Status;
}


// update  information in the structure statistics of wt_adapter
NDIS_STATUS Wt4UpdateTx_bytes (IN PWT_ADAPTER Adapter,ULONG len)
{

	NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
	Adapter->statistics.tx_bytes +=len;
	return  Status;

}


int
WtTransmit(struct sk_buff *skb, struct net_device *ndev)
{

	unsigned long    flags;
	PWT_ADAPTER      Adapter = netdev_priv(ndev);
	//PWT_ADAPTER      Adapter = ndev->Adapter;

      

	struct sk_buff*  Packet;
	NDIS_STATUS      Status;
	int              err = 0;
	

        FN_ENTER;	
		
	//printk("<0> In Function %s Line %d\r\n",__FUNCTION__,__LINE__);
	
	spin_lock_irqsave(&Adapter->slock, flags);
	
	//printk(LEVEL" function %s Line = %d, WtSendPacket Readyflag = %08x\r\n",__FUNCTION__, __LINE__,Adapter->Flags);
	//printk("<0> In Function %s Line %d\r\n",__FUNCTION__,__LINE__);
	if(WT_IS_NOT_READY(Adapter)||(!WTWlanCheckMACSendReady( Adapter ))) //defined in wt_stmac.c
        {
           //Status = WT_GET_STATUS_FROM_FLAGS(Adapter);
	   
	 // printk("<0> netif_stop_queue In Function %s Line %d\r\n",__FUNCTION__,__LINE__);
		netif_stop_queue(ndev);

		spin_unlock_irqrestore(&Adapter->slock, flags);
	   
		err = -EIO;
	   
	   goto DROP;
 
        }
        else
	{
	   Packet = skb;
	
	  // printk("<0> In Function %s Line %d\r\n",__FUNCTION__,__LINE__);
	   
	   Wt4UpdateTx_bytes(Adapter,skb->len);

	  // printk("<0> call WtSendPacket In Function %s Line %d\r\n",__FUNCTION__,__LINE__);
	   
	   Status = WtSendPacket(Adapter, Packet, FALSE);
	    
	  // printk(" function %s Line = %d, WtSendPacket status = %08x\r\n",__FUNCTION__, __LINE__,Status);
	   
           switch ( Status )
	   {
		case NDIS_STATUS_SUCCESS:
		                //netif_stop_queue;
				 //dev_kfree_skb(Packet);
				 break;
				 
		case NDIS_STATUS_FAILURE:
		default :
			netif_stop_queue( ndev );
			//printk("device busy so  WtSendPacket fails \n");
		        //dev_kfree_skb_any(Packet);//removed by hk 2006.10.20
			err = -EBUSY;
			//printk("Not success\n");
		spin_unlock_irqrestore(&Adapter->slock, flags);
			goto DROP;
	   }
	

	   StaMacSend( Adapter );
	
	   spin_unlock_irqrestore(&Adapter->slock, flags);
	   
	   err = 0;

	}
 
	
	//printk(LEVEL" function %s Line = %d, err = %08x\r\n",__FUNCTION__, __LINE__, err);	   	
DROP:
        FN_EXIT(0,0);
		return err;
	
	      
}

static inline int
wt4_monitor_rx(WT_ADAPTER *priv, struct sk_buff **skb)
{
 
	FN_ENTER;
	 
	FN_EXIT(0,0);
	return 0;
}

#if 0

int NICRecv( PWT_ADAPTER Adapter, unsigned int RcvBank, PWTWLAN_RXBUF pWtRxBuf)
{
        printk(LEVEL" Now we entered  function %s  !!!\n", __FUNCTION__);
	struct net_device *ndev = Adapter->ndev;
	PWTWLAN_HWRXBUF pHwRxbuf = NULL;
	ULONG Length;
	
        FN_ENTER;
#if 0	
	pHwRxbuf = &Adapter->MainMemAddress->RxBufMap[RcvBank].HwRxBuf;
	//Length = sizeof(WTWLAN_RSB) + MAX_HW_HEAD_LEN + pHwRxbuf->RxStatus.RecvBodyLen;
	Length = MAX_RX_CELL_LEN; //length of etherent
	pWtRxBuf->skb = dev_alloc_skb(Length);
	if(pWtRxBuf->skb == NULL){
	  printk("Error when alocating skb_buff\n");
	}
	
	memcpy(skb_put(pWtRxBuf->skb,Length), pHwRxbuf, Length);
	
	Dump((char*)pWtRxBuf->skb->data, Length, TURE, 1);
	
	pWtRxBuf->skb->dev = ndev;
	pWtRxBuf->skb->ip_summed = CHECKSUM_NONE;
	
	netif_rx(pWtRxBuf->skb);
	FN_EXIT(0,0);


        printk(LEVEL" Our RCV function worked !!!\n");
	return 0;
#endif
        	FN_EXIT(0,0);
		return 1;
       
}
#endif

void
islpci_do_reset_and_wake(void *data)
{       
        FN_ENTER;
 
	FN_EXIT(0,0);
}