initproc.c

Windows CE 6.0 BSP for VOIP sample phone. Intel PXA270 platform.

        Adapter->bIsPendingReset = FALSE;
        Adapter->bIsAssociationBlockedByScan = FALSE;
        Adapter->bIsScanWhileConnect = FALSE;
        Adapter->bIsConnectToAny = FALSE;
		
        Adapter->bIsScanInProgress = FALSE;
        Adapter->bIsAssociateInProgress = FALSE;
 
	Adapter->bIsReconnectEnable = FALSE;
 
        Adapter->CurCmd = NULL;
	Adapter->bIsAddress = FALSE;

	Adapter->bIsSystemConnectNow = FALSE;

	Adapter->bIsFreeNow = FALSE;
	
	Adapter->bIsDoingTx = FALSE;
	Adapter->bIsDoingRx = FALSE;
	Adapter->bIsDoingCmd = FALSE;

    	Adapter->ScanProbes = 2;

    	Adapter->LocalListenInterval = 0;  //0 - remain firmware listen interval unchanged

    	Adapter->SubscribeEvents = LINK_LOSS; 
    	Adapter->EventRecord.EventMap = LINK_LOSS;
    	Adapter->EventRecord.BeaconMissed = LINK_LOST_BEACONCNT;
    	
	Adapter->bIsBeaconLoseEvent = FALSE;
       Adapter->bIsDeauthenticaticationEvent = FALSE;
       Adapter->bIsD3ToD0reconnect = FALSE;

 	Adapter->AvoidScanTime = 10000;	//10sec 
 
#ifdef HOST_WAKEUP
	Adapter->bHostWakeCfgSet =0;
#endif
		
#ifdef BG_SCAN
    	Adapter->bBgScanEnabled = 0; 
   	Adapter->bActiveRoamingwithBGSCAN=FALSE;
	Adapter->bPSEnableBGScan=FALSE;
	NdisZeroMemory(Adapter->BgScanCfg, LENGTH_BGSCAN_CFG);
	Adapter->nBgScanCfg=0;
	Adapter->ulScanInterval=20000; //20sec
	Adapter->bBgDeepSleep=0;
#endif 

#ifdef ACTIVE_ROAMING
       Adapter->bIsActiveRoaming = FALSE;
	Adapter->bActiveRoamingScanOneChannel=TRUE;
	Adapter->bLinkLostScanOneChannel=TRUE;
       Adapter->EventRecord.RSSILowValue  = DEFAULT_RSSI_LOW_VALUE; 
	Adapter->ACTIVE_ROAMING_Count=0;
	Adapter->ActiveRoamingwithBGSCAN_FLAG=FALSE;   
	Adapter->ulRSSIThresholdTimer=5000;  
	Adapter->RSSI_Range=10;   	
#endif

       Adapter->bcn_avg_factor  = DEFAULT_BCN_AVG_FACTOR;
	Adapter->data_avg_factor = DEFAULT_DATA_AVG_FACTOR;

        Adapter->ListBufferLen = 0 ;
       Adapter->bIsScanOID = FALSE; 

       Adapter->bIsOidUsed = FALSE;
	   
	Adapter->bIsEnterD3 = FALSE;

	Adapter->bTXRESOURCES=FALSE;

	Adapter->bIsInDPC = FALSE;
	
// For Adhoc indication fix ++  
	Adapter->bIsMoreThanOneStaInAdHocBSS = FALSE;
// For Adhoc indication fix --	
	return;
}

/******************************************************************************
 *
 *  Name: AllocateAdapterBuffer()
 *
 *  Description: Device object buffer initialization function
 *
 *  Arguments:  
 *      PMRVDRV_ADAPTER Adapter
 *    
 *  Return Value: NDIS_STATUS_SUCCESS or NDIS_STATUS_FAILURE
 * 
 *  Notes:       
 *
 *****************************************************************************/
NDIS_STATUS AllocateAdapterBuffer(
    	IN PMRVDRV_ADAPTER Adapter
	)
{
       NDIS_STATUS Status;
	
	ULONG Offset;
	Offset = 0;

	DBGPRINT(DBG_ALLEN, (">>>> AllocateAdapterBuffer\n"));
	
	///Adapter->InitializationStatus |= MRVDRV_INIT_STATUS_MAP_REGISTER_ALLOCATED;

	// Build up TxQ
 	if(AllocateSingleTx(Adapter) != NDIS_STATUS_SUCCESS)
	{
		DBGPRINT(DBG_ALLEN, ("return NDIS_STATUS_RESOURCES\n"));
		return NDIS_STATUS_RESOURCES; 
	}

	// Build up RxQ
	Status = AllocateRxQ(Adapter);
	if( Status != NDIS_STATUS_SUCCESS )
	{
		FreeSingleTx(Adapter);
		DBGPRINT(DBG_ALLEN, ("return NDIS_STATUS_RESOURCES\n"));
		return NDIS_STATUS_RESOURCES;
	}

	// Build up command buffers
	Status = AllocateCmdBuffer(Adapter);
	if( Status != NDIS_STATUS_SUCCESS )
	{
		FreeSingleTx(Adapter);
		FreeRxQ(Adapter);
		DBGPRINT(DBG_ALLEN, ("return NDIS_STATUS_RESOURCES\n"));
		return NDIS_STATUS_RESOURCES;
	}

	DBGPRINT(DBG_ALLEN, ("<<<< AllocateAdapterBuffer successful \n"));


	return NDIS_STATUS_SUCCESS;
}

/******************************************************************************
 *
 *  Name: ReadRegistryInfo()
 *
 *  Description: Device registry read function
 *
 *  Arguments: 
 *      PMRVDRV_ADAPTER Adapter
 *      NDIS_HANDLE RegHdl
 *
 *    
 *  Return Value: 
 *      NDIS_STATUS_SUCCESS
 *      NDIS_STATUS_FAILURE
 * 
 *  Notes:        
 *
 *****************************************************************************/

NDIS_STATUS ReadRegistryInfo(
    	IN PMRVDRV_ADAPTER Adapter,
    	IN NDIS_HANDLE RegHdl
	)
{
        NDIS_STATUS Status;
        REGINFOTAB *RegInfoTab;
        UINT i;
        ULONG j;
     
        UINT Value;
        PUCHAR pPtr;
        PUCHAR pTmp;
     
        NDIS_CONFIGURATION_PARAMETER NdisConfigParam,*ReturnedValue;
        ANSI_STRING  DestinationANSIString;
        char UnicodeBuffer[512];	// to save the UNICODE string. 
        char AnsiBuffer[128];   	// to save the ANSI string. 
        PUCHAR NetworkAddress;

        // Read registry network address, if there is a good one, put it itno Adapter->CurrentAddr array
        NdisReadNetworkAddress(&Status, &NetworkAddress, &i, RegHdl);
        if( Status == NDIS_STATUS_SUCCESS )
	 {
            	if( i == MRVDRV_ETH_ADDR_LEN )
	     	{
                	NdisMoveMemory(Adapter->CurrentAddr, NetworkAddress, MRVDRV_ETH_ADDR_LEN);
			DBGPRINT(DBG_LOAD,("*** Got registry soft addr: %2x %2x %2x %2x %2x %2x ***\n", 
			                                       Adapter->CurrentAddr[0],
			                                       Adapter->CurrentAddr[1],
			                                       Adapter->CurrentAddr[2],
			                                       Adapter->CurrentAddr[3],
			                                       Adapter->CurrentAddr[4],
			                                       Adapter->CurrentAddr[5]));            
            	}
        }

	 RegInfoTab = MrvDrvRegInfoTab;
	 ReturnedValue = &NdisConfigParam;
	
	 DestinationANSIString.Buffer=AnsiBuffer; 
	 DestinationANSIString.MaximumLength=0x21;
 	 ReturnedValue->ParameterData.StringData.Buffer=(PWSTR)UnicodeBuffer;

	 for (i=0; i<SIZE_OF_REG_TAB; i++, RegInfoTab++)
        {
            	pPtr = ((PUCHAR)Adapter) + RegInfoTab->Offset;
            	pTmp = pPtr;
            	if (RegInfoTab->Type == 0)
            	{
              	NdisReadConfiguration(
		   		    &Status,
            	                  &ReturnedValue,
            	                  RegHdl,
            	                  &RegInfoTab->ObjNSName,
            	                  NdisParameterInteger );
			
                	if (Status == NDIS_STATUS_SUCCESS)
                	{		        	
        			Value = ReturnedValue->ParameterData.IntegerData;
        			*((PULONG)pPtr) = (ULONG)Value;
        	  	}
            	}
            	else if(RegInfoTab->Type == 1)
            	{
                  	NdisReadConfiguration(
				    &Status,
            	                  &ReturnedValue,
            	                  RegHdl,
            	                  &RegInfoTab->ObjNSName,
            	                  NdisParameterString );

                 	if (Status == NDIS_STATUS_SUCCESS)
                  	{		
  				NdisUnicodeStringToAnsiString(
    				       	&DestinationANSIString, 
    				       	(PUNICODE_STRING)(&(ReturnedValue->ParameterData.StringData))
    			               	);   
    				
    			       for(j=0;DestinationANSIString.Buffer[j] != '\0';j++)
    			       {
    				    *(pTmp)=DestinationANSIString.Buffer[j];
    				    pTmp++;
    			       } 	 
    			       *((PULONG)(pPtr-4))=j;    			 
		    	}            		        	        		
             }  
	      else if (RegInfoTab->Type == 3) 
	      {
			NdisReadConfiguration(
				    &Status,
				    &ReturnedValue,
				    RegHdl,
				    &RegInfoTab->ObjNSName,
				    NdisParameterHexInteger);

			if (Status == NDIS_STATUS_SUCCESS) 
			{
				Value = ReturnedValue->ParameterData.IntegerData;
				*((PINT)pPtr) = Value;
			}
		}
        }

	 Adapter->WepKey1.KeyIndex=0x0;
	 Adapter->WepKey2.KeyIndex=0x1;
	 Adapter->WepKey3.KeyIndex=0x2;
	 Adapter->WepKey4.KeyIndex=0x3;	    
	 switch(Adapter->TxWepKey)
	 {
		case 0:
			Adapter->WepKey1.KeyIndex |= 0x80000000;
			NdisMoveMemory(&(Adapter->CurrentWEPKey),&(Adapter->WepKey1) , 12 + Adapter->WepKey1.KeyLength);
			break;
		case 1:
			Adapter->WepKey2.KeyIndex |= 0x80000000;
			NdisMoveMemory(&(Adapter->CurrentWEPKey),&(Adapter->WepKey2) , 12 + Adapter->WepKey2.KeyLength);
			break;	
		case 2:
			Adapter->WepKey3.KeyIndex |= 0x80000000;
			NdisMoveMemory(&(Adapter->CurrentWEPKey),&(Adapter->WepKey3) , 12 + Adapter->WepKey3.KeyLength);
			break;
		case 3:
			Adapter->WepKey4.KeyIndex |= 0x80000000;
			NdisMoveMemory(&(Adapter->CurrentWEPKey),&(Adapter->WepKey4) , 12 + Adapter->WepKey4.KeyLength);
			break;								
		default:
			break;	
	}		     

#ifdef ACTIVE_ROAMING
	Adapter->NegativeRSSI_Range=Adapter->RSSI_Range*(-1);
#endif	 

       return NDIS_STATUS_SUCCESS;
}

/******************************************************************************
 *
 *  Name: InitSyncObjects()
 *
 *  Description: Syncronization object initialization function
 *
 *  Arguments:  
 *      PMRVDRV_ADAPTER Adapter
 *    
 *  Return Value: 
 *      NDIS_STATUS_SUCCESS
 *      NDIS_STATUS_FAILURE
 * 
 *  Notes:        
 *
 *****************************************************************************/
NDIS_STATUS
InitSyncObjects(
	IN PMRVDRV_ADAPTER Adapter
	)
{
	DBGPRINT(DBG_LOAD, (">>>> InitSyncObjects  \n"));
	
        InitializeCriticalSection(&Adapter->TxCriticalSection);
	 InitializeCriticalSection(&Adapter->PsUpdateCriticalSection);     
        InitializeCriticalSection(&Adapter->CmdQueueExeSection);
        InitializeCriticalSection(&Adapter->IntCriticalSection);
   	 InitializeCriticalSection(&Adapter->DpcCriticalSection);
	
	Adapter->hOidQueryEvent = CreateEvent(NULL, FALSE, FALSE,NULL);
  	Adapter->hWaitForGetHwSpecEvent = CreateEvent(NULL, FALSE, FALSE,NULL);
	Adapter->hWaitForCommandFinish = CreateEvent(NULL, FALSE, FALSE,NULL);

	// Initialize Timer
	NdisMInitializeTimer(
			&Adapter->MrvDrvIndicateConnectStatusTimer,
			Adapter->MrvDrvAdapterHdl,
			(PNDIS_TIMER_FUNCTION)MrvDrvIndicateConnectStatusTimer,
			(PVOID)Adapter
			);
	Adapter->DisconnectTimerSet = FALSE;
	DBGPRINT(DBG_LOAD, (" MrvDrvIndicateConnectStatusTimer success \n"));
	
       // Initialize the timer for Command
	NdisMInitializeTimer(
			&Adapter->MrvDrvCommandTimer,
			Adapter->MrvDrvAdapterHdl,
			(PNDIS_TIMER_FUNCTION) MrvDrvCommandTimerFunction,
			(PVOID)Adapter
			);
	Adapter->CommandTimerSet = FALSE;
	DBGPRINT(DBG_LOAD, (" MrvDrvCommandTimer success \n"));
	             
	// Initialize the timer for TX
	NdisMInitializeTimer(
			&Adapter->MrvDrvTxPktTimer,
			Adapter->MrvDrvAdapterHdl,
			(PNDIS_TIMER_FUNCTION) MrvDrvTxPktTimerFunction,
			(PVOID)Adapter
			);
	Adapter->TxPktTimerIsSet = FALSE;
	DBGPRINT(DBG_LOAD, (" MrvDrvTxPktTimer success \n"));

       // Initialize the timer for avoid scan when 802.1x authentication be not completed 
       NdisMInitializeTimer(
			&Adapter->MrvDrvAvoidScanAfterConnectedTimer,
			Adapter->MrvDrvAdapterHdl,
			(PNDIS_TIMER_FUNCTION)MrvDrvAvoidScanAfterConnectedTimer,
			(PVOID)Adapter
			);
	Adapter->bAvoidScanAfterConnectedforMSecs = FALSE;	
  
	// Initialize the timer for Reconnect 
	NdisMInitializeTimer(
			&Adapter->MrvReConnectTimer,
			Adapter->MrvDrvAdapterHdl,
			(PNDIS_TIMER_FUNCTION) MrvDrvReConnectTimerFunction,
			(PVOID)Adapter
			);
	Adapter->ReConnectTimerIsSet = FALSE;
	DBGPRINT(DBG_LOAD, (" MrvReCon