miscproc.c

marvell8385 GSPI开发驱动

		case RECONNECT_LINK_LOST:

			Adapter->bIsReconnectEnable = TRUE;
			Adapter->usReconnectCounter = 1;
			Adapter->ulReconnectPeriod = 3600000;  // 36000 sec (1 hr)
			NdisGetSystemUpTime(&Adapter->ulStartTimeStamp);
			Adapter->ReconnectType = RECONNECT_PERIOD_TYPE;
			Adapter->bIsAcceptSystemConnect = TRUE;
			
			break;
			
		case RECONNECT_DEAUTHENTICATE:

			Adapter->bIsReconnectEnable = TRUE;
			Adapter->usReconnectCounter = 0;
			Adapter->ulReconnectPeriod = 100000;  // 100 sec 
			NdisGetSystemUpTime(&Adapter->ulStartTimeStamp);
			Adapter->ReconnectType = RECONNECT_PERIOD_TYPE;
			Adapter->bIsAcceptSystemConnect = FALSE;
			break;
			
       	case RECONNECT_ROAMING:

			Adapter->bIsReconnectEnable = TRUE;
			Adapter->usReconnectCounter = 0;
			Adapter->ulReconnectPeriod = 0;
			Adapter->ulStartTimeStamp = 0;
			Adapter->ReconnectType = RECONNECT_RSSI_TYPE;
			Adapter->bIsAcceptSystemConnect = FALSE;
			break;
			
       	case RECONNECT_D3_TO_D0:
			
			Adapter->bIsReconnectEnable = TRUE;
			Adapter->usReconnectCounter = 1;
			Adapter->ulReconnectPeriod = 0;
			Adapter->ulStartTimeStamp = 0;
			Adapter->ReconnectType = RECONNECT_COUNTER_TYPE;
		        /*
			Adapter->bIsReconnectEnable = TRUE;
			Adapter->usReconnectCounter = 0;
			Adapter->ulReconnectPeriod = 100000;  // 100 sec 
			NdisGetSystemUpTime(&Adapter->ulStartTimeStamp);
			Adapter->ReconnectType = RECONNECT_PERIOD_TYPE;
                     */
			break;
			
       	case RECONNECT_DEEP_SLEEP_AWAKE:
			
			Adapter->bIsReconnectEnable = TRUE;
			Adapter->usReconnectCounter = 1;
			Adapter->ulReconnectPeriod = 0;
			Adapter->ulStartTimeStamp = 0;
			Adapter->ReconnectType = RECONNECT_COUNTER_TYPE;
			Adapter->bIsAcceptSystemConnect = FALSE;
			break;

		case RECONNECT_HIDE_SSID:
			
			Adapter->bIsReconnectEnable = TRUE;
			Adapter->usReconnectCounter = 10;
			Adapter->ulReconnectPeriod = 0;
			Adapter->ulStartTimeStamp = 0;
			Adapter->ReconnectType = RECONNECT_COUNTER_TYPE;
			Adapter->bIsAcceptSystemConnect = FALSE;
			break;
			
      	}

       switch (Adapter->ReconnectType)
       {
		case RECONNECT_COUNTER_TYPE:

			ReConnectHandler( Adapter);
			
			break;

		case RECONNECT_PERIOD_TYPE:
			
			DBGPRINT(DBG_ALLEN, ("RECONNECT_PERIOD_TYPE Set timer \n"));

			// Start Reconnect timer
       		NdisMSetPeriodicTimer( &Adapter->MrvReConnectTimer,  RE_CONNECT_PERIOD_TIME);
	       	Adapter->ReConnectTimerIsSet = TRUE;

			Adapter->bIsReConnectNow = FALSE;

			break;

		default :
			break;
       }	
	return; 
}

VOID
InfraBssReconnectStop(
		PMRVDRV_ADAPTER Adapter)
{
	BOOLEAN  timerStatus;
	// int i;
	
	DBGPRINT(DBG_ALLEN, ("InfraBssReconnectStop()  \n"));
	
	Adapter->bIsReconnectEnable = FALSE;
       Adapter->bIsReConnectNow = FALSE;
	
	if (Adapter->ReConnectTimerIsSet == TRUE)
	{
       	NdisMCancelTimer(&Adapter->MrvReConnectTimer, &timerStatus);
		Adapter->ReConnectTimerIsSet = FALSE;
    	}

	return;
}	

VOID
DoReConnect(
		PMRVDRV_ADAPTER Adapter)
{
	NDIS_STATUS Status;

	DBGPRINT(DBG_ALLEN, ("DoReConnect()  \n"));

	if ((Adapter->ReEncryptionStatus != Ndis802_11WEPEnabled) &&
	    (Adapter->ReEncryptionStatus != Ndis802_11WEPDisabled) &&
	    (Adapter->ReEncryptionStatus != Ndis802_11WEPKeyAbsent) &&	
           (Adapter->ReEncryptionStatus != Ndis802_11WEPNotSupported))
       {
		DBGPRINT(DBG_ALLEN, ("Not reconnect security type  \n"));
		Adapter->bIsReConnectNow = FALSE;
		return;   
       }

       if ( Adapter->bIsReConnectNow == TRUE)
       {
       	DBGPRINT(DBG_ALLEN, ("Adapter->bIsReConnectNow = TRUE  \n"));	
		return;
       }
	else
		Adapter->bIsReConnectNow = TRUE;

	// set infrastructure mode
	DBGPRINT(DBG_ALLEN, ("InfrastructureMode = 0x%x  \n", Adapter->ReInfrastructureMode));
	PrepareAndSendCommand(
	  			 Adapter,
				 HostCmd_CMD_802_11_SNMP_MIB,
				 (USHORT)Adapter->ReInfrastructureMode,
				 HostCmd_OPTION_USE_INT,
				 (NDIS_OID)OID_802_11_INFRASTRUCTURE_MODE,
                     	 HostCmd_PENDING_ON_NONE,
				 0,
				 FALSE,
				 NULL,
				 NULL,
				 NULL,
				 NULL);
       
	// set authentication mode 
	DBGPRINT(DBG_ALLEN, ("AuthenticationMode = 0x%x  \n", Adapter->ReAuthenticationMode));
	Adapter->AuthenticationMode = Adapter->ReAuthenticationMode;

	// set encryption mode 
	DBGPRINT(DBG_ALLEN, ("EncryptionStatus = 0x%x  \n", Adapter->ReEncryptionStatus));
	Status = MrvDrvSetEncryptionStatus( 
				 Adapter, 
				 Adapter->ReEncryptionStatus,
    			        (NDIS_OID) 0,                     
				 &(Adapter->ReEncryptionStatus),   
				 NULL,		
				 NULL);         
				
       // Add Key : now just support wep , no WPA
	if ((Adapter->ReEncryptionStatus == Ndis802_11Encryption1Enabled) ||
	    (Adapter->ReEncryptionStatus == Ndis802_11Encryption1KeyAbsent))
	{
            	PrepareAndSendCommand(
			      	 Adapter,
				 HostCmd_CMD_802_11_SET_WEP,
			    	 0,
			        HostCmd_OPTION_USE_INT,
			        OID_802_11_ADD_WEP,
			        HostCmd_PENDING_ON_NONE,
			        0,
			        FALSE,
			        NULL,
			        NULL,
			        NULL,
			        &(Adapter->ReWEPKey));
				
		Adapter->EncryptionStatus = Ndis802_11Encryption1Enabled;
	}
	
	// set ssid
	NdisMoveMemory(  &(Adapter->ActiveScanSSID), 
				      	&(Adapter->ReSSID), 
					sizeof(NDIS_802_11_SSID)); 
	
	HexDump(DBG_ALLEN, "ActiveScanSSID:", Adapter->ActiveScanSSID.Ssid, Adapter->ActiveScanSSID.SsidLength);

	if (( ! Adapter->bIsScanInProgress ) && ( ! Adapter->bIsAssociateInProgress ))
	{  
		DBGPRINT(DBG_ALLEN, ("Send HostCmd_CMD_802_11_SCAN  then Association\n"));	
		
		Adapter->bIsAssociationBlockedByScan = TRUE;
  		Adapter->SetActiveScanSSID = TRUE;

		Status = PrepareAndSendCommand(
					       Adapter,				
		       	 		HostCmd_CMD_802_11_SCAN,
		        			0,
		        			HostCmd_OPTION_USE_INT,
		        			(NDIS_OID)0,
              				HostCmd_PENDING_ON_NONE,
		      				0, 
		        			FALSE, 
		        			NULL, 
						NULL, 
						NULL, 
						&(Adapter->ActiveScanSSID));

	}
       else
	{
		Adapter->bIsReConnectNow = FALSE;
       }   
}

/// called by 
VOID
ReConnectHandler(
		PMRVDRV_ADAPTER Adapter)
{

	if (Adapter->bIsReconnectEnable == FALSE )
	{
		return;
	}

	if (Adapter->bIsAssociateInProgress ||Adapter->bIsScanInProgress ||Adapter->bIsSystemConnectNow)
	{     
		DBGPRINT(DBG_ALLEN, ("Adapter->bIsSystemConnectNow = TRUE\n"));
		return;   
	}

	DBGPRINT(DBG_ALLEN, ("ReConnectHandler()  ,ReconnectType = 0x%x\n", Adapter->ReconnectType));
	
	switch (Adapter->ReconnectType)
	{
		case RECONNECT_COUNTER_TYPE:

			DBGPRINT(DBG_ALLEN, ("usReconnectCounter = 0x%x  \n", Adapter->usReconnectCounter));

			if (Adapter->usReconnectCounter >= 1)
			{
				Adapter->usReconnectCounter --;

				DoReConnect (Adapter);
			}
			else
			{
				InfraBssReconnectStop(Adapter);	
			}
			break;
			
		case RECONNECT_PERIOD_TYPE:

			{	
				ULONG   ulCurrentSystemUpTime, ulDiff;

        			NdisGetSystemUpTime(&ulCurrentSystemUpTime);
				ulDiff = ulCurrentSystemUpTime - Adapter->ulStartTimeStamp ;

				DBGPRINT(DBG_ALLEN, ("ulStartTimeStamp = 0x%x  \n", Adapter->ulStartTimeStamp));
				DBGPRINT(DBG_ALLEN, ("ulCurrentSystemUpTime = 0x%x  \n", ulCurrentSystemUpTime));
				DBGPRINT(DBG_ALLEN, ("ulDiff = 0x%x  \n", ulDiff));

				if (ulDiff  < Adapter->ulReconnectPeriod) 
				{
					DoReConnect (Adapter);
				}
				else
				{	
					InfraBssReconnectStop(Adapter);	
				}
			}
			break;
		
		case RECONNECT_RSSI_TYPE:
			break;
	}
}



#endif //REASSOCIATE


#ifdef AUTO_REASSOCIATION
void TTMrvPrintFile(const char *fmt, ...)
{
    va_list     argP;
    FILE        *MrvDbgfp;
    DWORD       dwThreadID;
    DWORD       dwTick;


       MrvDbgfp = fopen("\\My Documents\\MrvlSD-25DBG.log","a+");

    //MessageBox(NULL, TEXT("printdbgmsg"), TEXT("CF25"), MB_OK);
    if ( MrvDbgfp == NULL )
    {
        //MessageBox(NULL, TEXT("open file failed"), TEXT("CF25"), MB_OK);
        return;
    }

    // dwThreadID = GetCurrentThreadId();
    // dwTick = GetTickCount();

    // fprintf(MrvDbgfp, "%8x:%d:", dwThreadID, dwTick);

    va_start(argP, fmt);
    vfprintf(MrvDbgfp, fmt, argP);
    fflush(MrvDbgfp);

    va_end(argP);

    fclose(MrvDbgfp);
}
#endif //AUTO_REASSOCIATION

#ifdef AUTO_REASSOCIATION
VOID MrvDrvSendCmdTimerHandler(
	IN PVOID SystemSpecific1,
	IN PVOID FunctionContext,
	IN PVOID SystemSpecific2,
	IN PVOID SystemSpecific3
	)
{
	PMRVDRV_ADAPTER	pAdapter = (PMRVDRV_ADAPTER) FunctionContext;
	NDIS_STATUS			Status;
	
	DBGPRINT( DBG_MACEVENT, ("+ MrvDrvSendCmdTimerHandler\n") );

	if (!pAdapter->ReAssociationInProgress)
	{
		goto endof_MrvDrvSendCmdTimerHandler;
	}

	DBGPRINT( DBG_MACEVENT, ("    Send out scan command for reassociation\n") );
	DBGPRINT( DBG_MACEVENT, ("    tick=%d\n", GetTickCount()) );
	
//#ifndef DEBUG_PARA_ROAMING
#ifdef DEBUG_PARA_ROAMING
#ifdef PARA_WPA_1X
if(IsRoamingWantWZCWorkProperly()){
	Status = PrepareAndSendCommand(
						pAdapter,
						HostCmd_CMD_802_11_SCAN,
						0,
						HostCmd_OPTION_USE_INT,
						(NDIS_OID)0,
						HostCmd_PENDING_ON_REASSOCIATION,
						0,
						FALSE,
						NULL,
						NULL,
						NULL,
						NULL);

	if ( !NDIS_SUCCESS(Status) )
	{
		DBGPRINT( DBG_MACEVENT, ("    Send failed [%x]\n", Status) );
	}
}
#endif
#else
	Status = PrepareAndSendCommand(
						pAdapter,
						HostCmd_CMD_802_11_SCAN,
						0,
						HostCmd_OPTION_USE_INT,
						(NDIS_OID)0,
						HostCmd_PENDING_ON_REASSOCIATION,
						0,
						FALSE,
						NULL,
						NULL,
						NULL,
						NULL);

	if ( !NDIS_SUCCESS(Status) )
	{
		DBGPRINT( DBG_MACEVENT, ("    Send failed [%x]\n", Status) );
	}
#endif

endof_MrvDrvSendCmdTimerHandler:
	
	DBGPRINT( DBG_MACEVENT, ("- MrvDrvSendCmdTimerHandler\n") );

	pAdapter->bIsSendCmdImterSet = FALSE;
	
}

NDIS_STATUS SubscribeMacEventForReAssoc( PMRVDRV_ADAPTER Adapter )
{
	NDIS_STATUS		Status;
	OID_MRVL_DS_SUBSCRIBE_EVENT	OidEvent;
	ULONG	BytesWritten, BytesNeeded;

	OidEvent.Events = 0x0008;
	Status = PrepareAndSendCommand(
						Adapter,
						HostCmd_CMD_802_11_SUBSCRIBE_EVENT,
						HostCmd_ACT_SET,
						HostCmd_OPTION_USE_INT,
						(NDIS_OID)0,
						HostCmd_PENDING_ON_NONE,
						0,
						FALSE,
						&BytesWritten,
						NULL,
						&BytesNeeded,
						&OidEvent);
	NKDbgPrintfW( L"### subscribe events %x\n", Status );
	return Status;	
}
#endif //AUTO_REASSOCIATION

//
void v5MrvPrintFileW(const unsigned short *fmt, ...)
{
    va_list     argP;
    FILE        *MrvDbgfp;
    //DWORD       dwThreadID;
    //DWORD       dwTick;


       MrvDbgfp = fopen("\\My Documents\\MrvlSDv5.log","a+");

    if ( MrvDbgfp == NULL )
    {
        return;
    }

    // dwThreadID = GetCurrentThreadId();
    // dwTick = GetTickCount();

    // fprintf(MrvDbgfp, "%8x:%d:", dwThreadID, dwTick);

    va_start(argP, fmt);
    vfwprintf(MrvDbgfp, fmt, argP);
    fflush(MrvDbgfp);

    va_end(argP);

    fclose(MrvDbgfp);
}


#ifdef RETQ_TIMER
VOID MrvRetQTimerFunction(
	IN PVOID SystemSpecific1,
	IN PVOID FunctionContext,
	IN PVOID SystemSpecific2,
	IN PVOID SystemSpecific3
	)
{
	  PMRVDRV_ADAPTER Adapter = (PMRVDRV_ADAPTER) FunctionContext;
                           
      //DraleeMsg((L"RETQ indicated by Timer\n")); 
      
      EnterCriticalSection(&Adapter->TxCriticalSection); 
      
      BatchIndicateRetQPkts(Adapter); 

      Adapter->RetQTimerIsSet=0;

      LeaveCriticalSection(&Adapter->TxCriticalSection);
}
#endif


VOID
SetUpLowRssiValue(
    PMRVDRV_ADAPTER Adapter  
    )
{
    ///OID_MRVL_DS_SUBSCRIBE_EVENT EventCtrl;
    //#ifdef MRVL_DBG_ACTIVE_ROAMING
    //       #ifdef MRVL_PRINT_DBG_MSG
       //                      MrvPrintFile("\n[Marvell]SetUpLowRssiValue =-%d dbm!!\n",usRssiValue);  
    //        #endif
    //#endif    
    //Adapter->EventRecord.EventMap   |= RSSI_LOW;    //ACTIVE_ROAMING    

        //Adapter->EventRecord.RSSILowValue  = usRssiValue; 
    
    //Adapter->EventRecord.RSSILowFreq   = 0;

       PrepareAndSendCommand(
                    Adapter,
                    HostCmd_CMD_802_11_SUBSCRIBE_EVENT,
                    HostCmd_ACT_SET,
                    HostCmd_OPTION_USE_INT,
                    (NDIS_OID)0,
                    HostCmd_PENDING_ON_NONE,
                    0,
                    FALSE,
                    NULL,
                    0,
                    0,
                    NULL);
        
    return;

}
//