hsm.c

It is something about net security also.Maybe useful.Hope you like it.

/*****************************************************************************
*h*
*   Name:       hsm.c
*
*   Description:
*               Initialization , Send and Receive routines, ISR,
*               Power management and Miscellaneous routines
*               for the Hardware Specific Module (HSM) .
*   Author:
*
*   History:
*
*h*
******************************************************************************/

/*
 *	Defines for the features.
 *
 *		1. Intr Hold off  	INTR_HOLD_OFF
 *		2. Pause Frames		PAUSE_FRAMES
 *		3. PHY interrupt	PHY_INTR
 *
 *		These flags should be defined in the Makefile for testing 
 *			these features.
 */

/*** Include files ***/

#include "nsmtypes.h"
#include "ga622t.h"                            
#include "hsm.h"
#include "nsm.h"

/*** External Global Vars ***/
/*extern UINT    AutoNegFlg; */

/*** External Global Func ***/

/*** Local Constant Definitions ***/

/*
 * Defines for FreeResources()
 */
#define	PRI_QUE_FAILED          1
#define	DP_ALLOC_FAILED         2
#define	TCB_ALLOC_FAILED        3
#define	RCB_ALLOC_FAILED        4
#define	RXINIT_FAILED           5
#define	UNINITIALIZE            6

#define	RCB_ARRAY_ALLOC_FAILURE 100

/*
 * Defines for power management routines.
 */
#define	OFFSET		0       
#define	APAT_MASK	1       
#define	WKPAT_MASK	2

/*
 * Defines for TxDp and RxDp arrays.
 */
#define	REG_OFFSET      0       /* Register offset */
#define	MINDESCCNT      1       /* Minimum desc. reqd. for the current prio */
#define	DESCCNT         2       /* Number of desc. for the current prio */
#define	PRIQSEL         3       /* Priority queue selection bit in CR */

/*** Local Typedefs ***/

#define	SET_OWN(Desc, Value)	\
		( (Value) ? ((Desc)->CmdSts |= OWN) : ((Desc)->CmdSts &= ~(OWN)) ) 

/*
 * Increment the current descriptor - used for HsmIsr() and HsmRxPackets().
 */
#define	INC_CURR_DESC(pAdapter, Priority, pDesc,count,base)	\
	((base) +	\
		(((UINT)(pDesc) - (UINT)(base))/sizeof(DevDesc) + (count)) %	\
			(pAdapter)->PriQue[(Priority)].iMaxTxDesc)

/*
 * Defines to Load the TXDP and RXDP registers.
 */

#define	HsmLoadTxDp(pAdapter, priIdx)	\
	NsmRegWrite32((pAdapter)->pNsmContext,	\
		((pAdapter)->RegAddr + pAdapter->TxDp[(priIdx)][REG_OFFSET]),	\
		(UINT) ((HsmTCB *)(pAdapter)->PriQue[(priIdx)].pTcbListHead)->pStartDescPa)

#define	HsmLoadRxDp(pAdapter, priIdx)	\
	NsmRegWrite32((pAdapter)->pNsmContext,	\
		((pAdapter)->RegAddr + pAdapter->RxDp[(priIdx)][REG_OFFSET]),	\
		(UINT)((HsmRCB *)((pAdapter)->PriQue[(priIdx)].pRcbListNext))->pRxDpPa )

/*
 * Defines to enable TXE and RXE .
 */


#ifdef PM_WOL
UCHAR IsPowerPatternExsts(AdapterContext *pAdapter, UCHAR *PowerPattern, UCHAR *pPatternIdx, UINT PatternLen) 
{ 
	UCHAR	ptrnIdx;	
	UCHAR 	status;
	for(ptrnIdx = 0; ptrnIdx < pAdapter->PatternCnt; ptrnIdx++) 
	{ 
		status = NsmCompare(PowerPattern, 
			&pAdapter->PowerPattern[ptrnIdx][0], PatternLen); 
		if (status == SUCCESS) 
		{ 
			*pPatternIdx = ptrnIdx;
			return SUCCESS; 
		} 
	} 
	*pPatternIdx = ptrnIdx;
	return FAILURE;
} 


static int PATTERN[MAX_POWER_PTRN][3] = 
{ 
	{ 0x0006, 	APAT0, WKPAT0}, 
	{ 0x0006,	APAT1, WKPAT1},
	{ 0x0008,	APAT2, WKPAT2},
	{ 0x0008,	APAT3, WKPAT3} 
};

#endif
/*
 *	TxDp/RxDp Array : Reg_Offset, Minimum descriptor, 
 *					Current no.of Desc, Priority Queue Value.
 */ 
/* Ramit : in AdapterContext
#ifdef _GA622T_
static int TxDp[4][4] =
{
	{ TXDP,  0 , 0, TXDP0_PRISEL} ,
	{ TXDP1, 0 , 0, TXDP1_PRISEL} , 
	{ TXDP2, 0 , 0, TXDP2_PRISEL} , 
	{ TXDP3, 0 , 0, TXDP3_PRISEL} 
};

static int RxDp[4][4] =
{
	{ RXDP,  0 , 0, RXDP0_PRISEL} , 
	{ RXDP1, 0 , 0, RXDP1_PRISEL} , 
	{ RXDP2, 0 , 0, RXDP2_PRISEL} , 
	{ RXDP3, 0 , 0, RXDP3_PRISEL}  
};
#elif _FA31X_
static int TxDp[1][4] =
{
	{ TXDP, 0 , 0, TXDP0_PRISEL} 
};

static int RxDp[1][4] =
{
	{ RXDP, 0 , 0, RXDP0_PRISEL} 
};

UINT phyConfigData[] = { 0x0005e000,
                         0x00044000,
                         0x00040000,
                         0x0005a000,
                         0x00058000 };

#endif
*/
/*** Local Function Prototypes ***/

VOID getHashValue ( UCHAR *MulticastAddr, USHORT *wordindex, 
						USHORT *bitindex, USHORT *hashbit);

INT  search_mca_tbl ( UCHAR *MulticastAddr, mca_hash_t **prevEntry,
                    	mca_hash_t **hashEntry);

VOID refresh_mca_tbl( AdapterContext *pAdapter);
VOID clear_mca_tbl( AdapterContext *pAdapter);

USHORT AddPattern(AdapterContext *pAdapter, UCHAR PatternIdx, 
                        UCHAR *PowerPattern, UINT PatternLen, UINT MatchLen, 
                        UCHAR *MaskPtrn );


/*** Function Definitions ***/

/******************************************************************************
*f*
*   Name:               
*                       HsmTxStart
*
*   Description:        
*                       Start the transmit engine . 
*
*   Parameters:     
*                       pAdapter        - Pointer to the adapter context.
*                       Priority        - Priority.
*
*   Return Value:   
*                       NONE.
*
*f*
******************************************************************************/
VOID
HsmTxStart(AdapterContext *pAdapter, UINT Priority)
{
        UINT    Cr_val; 
        NsmRegRead32(pAdapter->pNsmContext, (pAdapter->RegAddr + CR), &Cr_val); 
        Cr_val |= TXE;
        Cr_val |= (pAdapter->TxDp[Priority][PRIQSEL]) ; 
        NsmRegWrite32(pAdapter->pNsmContext, (pAdapter->RegAddr + CR), Cr_val);

}       /*      end of HsmTxStart()     */

/******************************************************************************
*f*
*   Name:               
*                       HsmRxStart
*
*   Description:        
*                       Start the Receive Engine . 
*
*   Parameters:     
*                       pAdapter        - Pointer to the adapter context.
*                       Priority        - Priority.
*
*   Return Value:   
*                       NONE.
*
*f*
******************************************************************************/
VOID
HsmRxStart(AdapterContext *pAdapter, UINT Priority)
{
        UINT    Cr_val; 
        NsmRegRead32(pAdapter->pNsmContext, (pAdapter->RegAddr + CR), &Cr_val); 
        Cr_val |= RXE;
        Cr_val |= (pAdapter->RxDp[Priority][PRIQSEL]) ; 
        NsmRegWrite32(pAdapter->pNsmContext, (pAdapter->RegAddr + CR), Cr_val);

}       /*      end of HsmRxStart()     */

/******************************************************************************
*f*
*   Name:               
*                       HsmOpen
*
*   Description:        
*                       Open the adapter. 
*
*   Parameters:     
*                       pAdapter        - Pointer to the adapter context.
*
*   Return Value:   
*                       SUCCESS - If device is already opened / Open succeded.
*                       FAILURE - Adapter is in reset. 
*
*f*
******************************************************************************/
UCHAR 
HsmOpen(AdapterContext *pAdapter)
{
        UINT    Cr_val;
        UINT    priIdx;
		UINT	HoldDpc = 0;
#ifdef NSCDEBUG
    NsmDbgMsg("HsmOpen : Opening the Device\n");
#endif
/*
 *      If adapter is already opened then return SUCCESS.
 */
    	HsmDisableInterrupts(pAdapter);
		if ( ((pAdapter->AdapterStatus & ADAPTER_RESETTING) && (pAdapter->interruptStatus & SWI_INTR)) )
			HoldDpc = 1;
		if (!HoldDpc)
        NsmAcquireLock(pAdapter->pNsmContext, pAdapter->AdapterLock);
		else
        NsmAcquireDPCLock(pAdapter->pNsmContext, pAdapter->AdapterLock);

        if (pAdapter->AdapterStatus & ADAPTER_OPEN) { 
		if (!HoldDpc)
                NsmReleaseLock(pAdapter->pNsmContext, pAdapter->AdapterLock);
		else
        		NsmReleaseDPCLock(pAdapter->pNsmContext, pAdapter->AdapterLock);
                return (SUCCESS);
        } 
/*
 *      Initialize the registers (HsmInitRegs()) 
 *      Enable interrupts from the adapter(setting IE bit in IER ) 
 */
#ifdef NSCDEBUG
    NsmDbgMsg("HsmOpen: Initializing the registers & enabling interrupts \n");
#endif

    	HsmInitRegs(pAdapter);
		
		/*Ramit : Do not enable interrupts if called from HsmReset*/
		if ( !((pAdapter->AdapterStatus & ADAPTER_RESETTING) || (pAdapter->interruptStatus & SWI_INTR) || (pAdapter->interruptStatus & ADAPTER_SLEEPING)) )
    	HsmEnableInterrupts(pAdapter);

#ifdef NSCDEBUG
    NsmDbgMsg("HsmOpen: Loading RXDP and starting the receive engine. \n");
#endif
/*
 * 		Load the TXDP 
 */
        for (priIdx = 0; priIdx < pAdapter->TxNumPrio; priIdx++)
                HsmLoadTxDp(pAdapter, priIdx);


/*
 * 		Load the RXDP and enable the receive engine.
 */
        for (priIdx = 0; priIdx < pAdapter->RxNumPrio; priIdx++)
		{
                HsmLoadRxDp(pAdapter, priIdx);
        		HsmRxStart(pAdapter, priIdx);
		}
/*
 *      Wait till Transmit and Receive engines are enabled. 
 */
	    NsmSleep(pAdapter->pNsmContext, 10);    

		if ( !(pAdapter->interruptStatus & ADAPTER_SLEEPING) )
       	pAdapter->AdapterStatus |= ADAPTER_OPEN;
			
		if (!HoldDpc)
                NsmReleaseLock(pAdapter->pNsmContext, pAdapter->AdapterLock);
		else
        		NsmReleaseDPCLock(pAdapter->pNsmContext, pAdapter->AdapterLock);
        
#ifdef NSCDEBUG
    NsmDbgMsg("HsmOpen: Adapter opened. \n");
#endif
#ifdef PM_WOL

		/* MKC Check if we have to read the curr power state from somewhere */
		pAdapter->CurrPowerStatus = POWER_STATE_D0;

#endif
        return (SUCCESS);

}       /*      end of Hsmopen()        */


/******************************************************************************
*f*
*   Name:               
*                       HsmClose
*
*   Description:        
*                       Close the adapter. 
*
*   Parameters:     
*                       pAdapter        - Pointer to the adapter context.
*
*   Return Value:   
*               SUCCESS - On successful close operation.
*               FAILURE - If the Adapter status is not ADAPTER_OPEN / 
*                       Adapter is in reset.
*
*f*
******************************************************************************/
UCHAR
HsmClose(AdapterContext *pAdapter)
{
        UINT    Cr_val;
        UINT    Ier_val;

#ifdef NSCDEBUG
    NsmDbgMsg("HsmClose: closing the Adapter . \n");
#endif
        NsmAcquireLock(pAdapter->pNsmContext, pAdapter->AdapterLock);
/*
 *      If adapter is not opened then return FAILURE.
 */
        if (!(pAdapter->AdapterStatus & ADAPTER_OPEN))  { 
                NsmReleaseLock(pAdapter->pNsmContext, pAdapter->AdapterLock);
                return FAILURE;
        }       

#ifdef NSCDEBUG
    NsmDbgMsg("HsmClose: waiting for the receive and transmit engine to be disabled. \n");
#endif

/*
 *	Disable interrupts from the adapter(setting 0 to IE bit in IER) & disable 
 *	the	receive engine and transmit engine (setting RXD and TXD bits in CR )
 */
        NsmRegRead32(pAdapter->pNsmContext, (pAdapter->RegAddr + CR), &Cr_val);
		/*Madhu : No need of SWI
        Cr_val |= (RXD | TXD | SWI);*/
        Cr_val |= (RXD | TXD );
        NsmRegWrite32(pAdapter->pNsmContext, (pAdapter->RegAddr + CR), Cr_val);

        pAdapter->SWIFlag = 0;

/*
 *      Clear the bitmask ADAPTER_OPEN from AdapterStatus field.
 */
        HsmDisableInterrupts(pAdapter);
		/*Madhu Clear the multicast hash table*/
		clear_mca_tbl(pAdapter);
        HsmClearStatistics(pAdapter);
		pAdapter->AdapterStatus &= ~(ADAPTER_OPEN);
        NsmReleaseLock(pAdapter->pNsmContext, pAdapter->AdapterLock);
        
#ifdef NSCDEBUG
    NsmDbgMsg("HsmClose: Adapter closed. \n");
#endif

        return SUCCESS;

}       /* End of HsmClose() */


/* Setting the Interrupt Mask */
VOID HsmMaskIntr( AdapterContext *pAdapter, UINT Mask)
{
	NsmRegWrite32(pAdapter->pNsmContext,(pAdapter->RegAddr+ IMR), Mask);
}


/******************************************************************************
*f*
*   Name:               
*                       HsmReset
*
*   Description:        
*                       Reset the adapter. 
*
*   Parameters:     
*                       pAdapter        - Pointer to the adapter context.
*
*   Return Value:   
*                       SUCCESS - Reset successful.
*                       FAILURE - Adapter is not opened already.
*
*f*
******************************************************************************/
UCHAR
HsmReset(AdapterContext *pAdapter, UINT aSynch)
{
        UINT    Cr_val;
        UINT    Cfg_val;
        UINT    Bmcr_val, Bmsr_val;
        UINT    Imr_val;
        UINT    Physts_val;
        UINT    i = 0;
		UCHAR   Stat;

/*Ramit : adding Pcr_val for Pause Frames*/
		UINT	Pcr_val = 0;
#ifdef NSCDEBUG
    NsmDbgMsg("HsmReset: Resetting the adapter . \n");
#endif

        /* Ramit : Do not interrupt the Reset */
		HsmDisableInterrupts(pAdapter);  
		
        NsmAcquireLock(pAdapter->pNsmContext, pAdapter->AdapterLock);