wt_init.c

mini-PCI driver for LHWT chipsets

/* Copyright (C) 2005 LHWT Inc. */ 
#include "wtprecomp.h"

#define  DUMP_BytesPerLine 16 //only for DUMP
/******************************************************************************
    Device Interface & Control functions
******************************************************************************/
#if 0
void Wt100nDelay(WT_ADAPTER *Adapter,UINT delay)
{
     unsigned long volatile i = jiffies + (delay*((HZ/1000000)/10));	
     Adapter->debugvar1 = jiffies;
     while(jiffies < i);
     Adapter->debugvar2 = jiffies;
}
#endif

/*WtDisableInterrupts - disable all interrupts*/
 void WtDisableInterrupts(WT_ADAPTER *Adapter)
{       
	//Adapter->CSRAddress = &Adapter->MainMemAddress->HwCSMem.CSRAddress;
	Adapter->CSRAddress->IntMaskCtrl |= MASK_INT_ALL;
}

void WtClearInterrupts(WT_ADAPTER *Adapter)
{ 
       // Adapter->CSRAddress = &Adapter->MainMemAddress->HwCSMem.CSRAddress;
	Adapter->IntStatus = Adapter->CSRAddress->IntStatus;
	*((volatile USHORT *)(&Adapter->CSRAddress->IntStatus) )= Adapter->IntStatus;
}

void WtEnableInterrupts(WT_ADAPTER *Adapter) 
{
	//Adapter->CSRAddress = &Adapter->MainMemAddress->HwCSMem.CSRAddress;
	Adapter->CSRAddress->IntMaskCtrl &= ~MASK_INT_ALL;
}

void Dump(CHAR* p, ULONG cb, BOOL fAddress, ULONG ulGroup)
{
        int cbLine;
	while(cb)
	{
	   cbLine = (cb < DUMP_BytesPerLine) ? cb : DUMP_BytesPerLine;
           DumpLine( p, cbLine, fAddress, ulGroup );
           cb -= cbLine;
           p  += cbLine;
	}
}

/* Display buffer */
void DumpLine(UCHAR* p, ULONG cb, BOOL fAddress, ULONG ulGroup)
{
        CHAR* pszDigits = "0123456789ABCDEF";
        CHAR  szHex[ ((2 + 1) * DUMP_BytesPerLine) + 1 ];
        CHAR* pszHex = szHex;
        CHAR  szAscii[ DUMP_BytesPerLine + 1 ];
        CHAR* pszAscii = szAscii;
        ULONG ulGrouped = 0;

        if (fAddress) 
        {
           printk( "WT40: %08x: ", (unsigned int)p );
        }
        else 
        {
           printk( "WT40: " );
        }

        while (cb)
        {
           *pszHex++ = pszDigits[ ((UCHAR )*p) / 16 ];
           *pszHex++ = pszDigits[ ((UCHAR )*p) % 16 ];

           if (++ulGrouped >= ulGroup)
           {
              *pszHex++ = ' ';
               ulGrouped = 0;
           }

           *pszAscii++ = (*p >= 32 && *p < 128) ? *p : '.';

           ++p;
           --cb;
        }

        *pszHex = '\0';
        *pszAscii = '\0';

	{
		int len_line;
		len_line =  (2 * DUMP_BytesPerLine) + (DUMP_BytesPerLine / ulGroup);
	         printk("%-*s|%-*s|\n", len_line, szHex,
			 	DUMP_BytesPerLine, szAscii );
	}
	
}

void WtInitList(WT_ADAPTER *Adapter)
{

        // Init lists, spinlocks, etc.
	FN_ENTER;
        //send queue
	do{
		
	INIT_LIST_HEAD(&Adapter->SendBufList);
        INIT_LIST_HEAD(&Adapter->SendMgmtList);

        //InitializeQueueHeader(&Adapter->SendWaitQueue);
	skb_queue_head_init(&Adapter->SendWaitQueue);		
        InitializeQueueHeader(&Adapter->SendCancelQueue);  
		
        InitializeQueueHeader(&Adapter->TxFrmQMgmt);
        InitializeQueueHeader(&Adapter->TxFrmQCtl);
		
        InitializeQueueHeader(&Adapter->TxFrmQBE);
        InitializeQueueHeader(&Adapter->TxFrmQBK);
        InitializeQueueHeader(&Adapter->TxFrmQVI);
        InitializeQueueHeader(&Adapter->TxFrmQVO);

		
        InitializeQueueHeader(&Adapter->AnFrmQ);
        InitializeQueueHeader(&Adapter->PsFrmQ);
        InitializeQueueHeader(&Adapter->CfFrmQ);

	//rcv queue
        INIT_LIST_HEAD(&Adapter->RecvList);
        INIT_LIST_HEAD(&Adapter->RecvMgmtList);
		
        INIT_LIST_HEAD(&Adapter->RecvFragList);
		
        INIT_LIST_HEAD(&Adapter->RxFrmQBE);
        INIT_LIST_HEAD(&Adapter->RxFrmQBK);
        INIT_LIST_HEAD(&Adapter->RxFrmQVI);
        INIT_LIST_HEAD(&Adapter->RxFrmQVO);
		
        INIT_LIST_HEAD(&Adapter->RxFrmQMgmt);
        INIT_LIST_HEAD(&Adapter->RxFrmQCtl);
		
        //spin_lock_init(&Adapter->Lock);
        //spin_lock_init(&Adapter->SendLock);
        //spin_lock_init(&Adapter->RcvLock);
        //spin_lock_init(&Adapter->MacLock);

    } while (FALSE);

      FN_EXIT(0,0);
    return ;

}

void WtSoftParaInit( IN  PWT_ADAPTER  Adapter)
{
	FN_ENTER;

	Adapter->NumRxBuf = MAX_RX_DESC; //32
	Adapter->NumTxBuf = MAX_TX_DESC; //32	
	
	Adapter->NumTxMgmtBuf = MAX_NUM_TX_MGMT_BUF; //8
	Adapter->NumRxMgmtBuf = MAX_NUM_RX_MGMT_BUF; //8

	Adapter->AlignSize = 0;  

	Adapter->MacHwCfg.ulHwHeadLen   = MAX_HW_HEAD_LEN; //80
	Adapter->MacHwCfg.ulHwTxCellLen = MAX_TX_CELL_LEN; //1600
	Adapter->MacHwCfg.ulHwRxCellLen = MAX_RX_CELL_LEN; //1600

	FN_EXIT(0,0);
	return;
}


BOOL WtInitSend(WT_ADAPTER *Adapter)
{

	PUCHAR          pMem;
	BOOL 		Status = TRUE;

  	PWTWLAN_TXBUF   pWtTxBuf;
        LONG            index;
	UINT		ErrorIndex = 0;
	BOOL		ErrorFlag = FALSE;
	
	//spin_lock(&Adapter->SendLock);
	

	FN_ENTER;

	do{
		Adapter->WtWlanTxBufMemSize = (Adapter->NumTxBuf + Adapter->NumTxMgmtBuf) * sizeof(WTWLAN_TXBUF);
		pMem = kmalloc(Adapter->WtWlanTxBufMemSize, GFP_ATOMIC);

		if( !pMem )
		{
			Status = FALSE;
		   	break;
		}
		   
		memset(pMem, 0, Adapter->WtWlanTxBufMemSize);
	        Adapter->WtWlanTxBufMem = pMem;

		 
		//tx desc
		
		pWtTxBuf = (PWTWLAN_TXBUF)Adapter->WtWlanTxBufMem;
	        for (index = 0; index < Adapter->NumTxBuf ; index++)
	        {
			pWtTxBuf->TXHwBuf.pBuffer = (PUCHAR)pWtTxBuf->AuxHeadBuf;
			
			list_add_tail((struct list_head *)pWtTxBuf, &Adapter->SendBufList);
			
			pWtTxBuf++;
		}

	// tx mgmt desc
		
	        for (index = 0; index < Adapter->NumTxMgmtBuf ; index++)
	        {
			
		        if ((pWtTxBuf->skb = dev_alloc_skb(Adapter->MacHwCfg.ulHwHeadLen + Adapter->MacHwCfg.ulHwTxCellLen)) != NULL)
			{
				pWtTxBuf->TXHwBuf.pBuffer =( pWtTxBuf->skb )->data;
				list_add_tail( (struct list_head *)pWtTxBuf, &Adapter->SendMgmtList);
				pWtTxBuf++;
			}
			else
			{
			 	ErrorIndex = index;
				ErrorFlag = TRUE;
				break;
			}
		}


	        if ( ErrorFlag )
		{
			for (index = 0; index < ErrorIndex ; index++)
			{
				AllocTxMgmt( Adapter, &pWtTxBuf );
				if( pWtTxBuf && (pWtTxBuf->skb) )
				dev_kfree_skb_any(pWtTxBuf->skb);
			}

			kfree(Adapter->WtWlanTxBufMem);
			Status = FALSE;		
			break;
		}

	}while( FALSE );
	
	//spin_unlock(&Adapter->SendLock);
	
	FN_EXIT(0,0);
	return Status;

}


BOOL NICInitRecv(IN PWT_ADAPTER Adapter)

{

        BOOL            Status = TRUE;

        PWTWLAN_RXBUF   pWtRxBuf;      
        LONG            index;
	UINT 	        ErrorIndex = 0;
	BOOL 		ErrorFlag = FALSE;
	
        PUCHAR          pMem;
	
	//spin_lock(&Adapter->RcvLock);


	FN_ENTER;
	
	do{

		Adapter->WtWlanRxBufMemSize = (Adapter->NumRxBuf + Adapter->NumRxMgmtBuf) * sizeof(WTWLAN_RXBUF);
		pMem = kmalloc(Adapter->WtWlanRxBufMemSize, GFP_ATOMIC);

		if( !pMem )
		{
		   Status = FALSE;
		   break;
		}
		   
		memset(pMem, 0, Adapter->WtWlanRxBufMemSize);
	        Adapter->WtWlanRxBufMem = pMem;

		 
		//Rx desc
		
		pWtRxBuf = (PWTWLAN_RXBUF)Adapter->WtWlanRxBufMem;
	        for(index = 0; index < Adapter->NumRxBuf ; index++)
		{
                   list_add_tail( (struct list_head *)pWtRxBuf, &Adapter->RecvList);
		   pWtRxBuf++;
	        }


	        // rx mgmt desc
		
	        for (index = 0; index < Adapter->NumRxMgmtBuf ; index++)
	        {
			
		        if ((pWtRxBuf->skb = dev_alloc_skb(Adapter->MacHwCfg.ulHwHeadLen +                Adapter->MacHwCfg.ulHwRxCellLen)) != NULL)
			{
				pWtRxBuf->RXHwBuf.pRxBuffer  = ( pWtRxBuf->skb )->data;
				list_add_tail( (struct list_head *)pWtRxBuf, &Adapter->RecvMgmtList);
				pWtRxBuf++;
			}
			else
			{
			 	ErrorIndex = index;
				ErrorFlag = TRUE;
				break;
			}
		}


	        if ( ErrorFlag )
		{
		
			printk("Error Alloc Rcv mem\n");
			
			for (index = 0; index < ErrorIndex ; index++)
			{
				AllocRxMgmtBuff( Adapter, &pWtRxBuf );
				if( pWtRxBuf && (pWtRxBuf->skb) )
				dev_kfree_skb_any(pWtRxBuf->skb);
			}

			kfree(Adapter->WtWlanRxBufMem);
			Status = FALSE;		
			break;
		}
			
	

	}while( FALSE );
	
	//spin_unlock(&Adapter->RcvLock);
	
	FN_EXIT(0,0);
	return Status;
	
}


BOOL NICReadAdapterInfo(
    IN  PWT_ADAPTER     Adapter)
{
	int             i;
	UCHAR          MacAddr_default[6] = {0x00,0x05,0x5d,0xb8,0x98,0x68};
	UCHAR          *MacAddr;
	struct sockaddr  addr;
		
	FN_ENTER;
//add our own mac addr read router later

	//if( memcmp(MacAddr_zero, Adapter->CurrentAddress, 6))
	{
		memcpy( Adapter->CurrentAddress, MacAddr_default,6);
	}
	
	MacAddr =(PUCHAR)MacAddr_default;
	
	//printk(" LEVEL  Function %s Dev_Addr Dump\r\n", __FUNCTION__);
	
	//Dump( MacAddr, 6, TRUE, 1 );

	memcpy(&addr.sa_data, MacAddr, 6 );
	
	wt4_set_mac_address( Adapter->ndev, (unsigned char *)(&addr));

	//printk(" LEVEL  Function %s Dev_Addr Dump\r\n", __FUNCTION__);
	
	//Dump( Adapter->ndev->dev_addr, 6, TRUE, 1 );
	
	for (i=0; i<6; i ++)
	{
       	 Adapter->PermanentAddress[i] = MacAddr[i];
    	}
	
	FN_EXIT(0,0);
    return 0;
}