cmdproc.c

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

    EnterCriticalSection(&Adapter->CmdQueueExeSection);

    IsDownloadCmdToFW = 0;
    if (!IsQEmpty(&Adapter->CmdPendQ))
    {	

        NdisAcquireSpinLock(&Adapter->PriorityQSpinLock);	
        pTempNode = (CmdCtrlNode *)PopFirstQNode(&Adapter->CmdPendQ);
	NdisReleaseSpinLock(&Adapter->PriorityQSpinLock);

        if (pTempNode != NULL)
  	{ 
  	    Command = ((PHostCmd_DS_GEN)(pTempNode->BufVirtualAddr))->Command;
            if ((Command ==  HostCmd_CMD_802_11_PS_MODE))
                PsSubCommand = ((PHostCmd_DS_802_11_PS_MODE)pTempNode->BufVirtualAddr)->SubCommand;
            else
                PsSubCommand = 0;
	
  	    switch(Adapter->psState)
  	    {
                case PS_STATE_FULL_POWER:

                    IsDownloadCmdToFW = 1;
                    break;    

		case PS_STATE_WAKEUP:	
	
                    IsDownloadCmdToFW = 1;
	
                    			if ((Command == HostCmd_CMD_802_11_HOST_SLEEP_AWAKE_CONFIRM))
                        break;
									
                    if (PsSubCommand != HostCmd_SubCmd_Exit_PS)
	   	    {	
                        pPsExitCmd = GetFreeCmdCtrlNode(Adapter);
					MakePsCmd (Adapter, pPsExitCmd, HostCmd_SubCmd_Exit_PS);
                        InsertQNodeFromHead(&(Adapter->CmdPendQ),(PQ_NODE)pTempNode);
                        pTempNode = pPsExitCmd;
                    }   
                    break;

                case PS_STATE_SLEEP:

					//RETAILMSG(1, (TEXT("> 0")));

		    NdisAcquireSpinLock(&Adapter->PriorityQSpinLock);	
                    InsertQNodeFromHead(&(Adapter->CmdPendQ),(PQ_NODE)pTempNode);
      		    NdisReleaseSpinLock(&Adapter->PriorityQSpinLock);
	 	    break;

                case PS_STATE_SLEEP_PENDING:
                    
                    			if ((Command == HostCmd_CMD_802_11_HOST_SLEEP_AWAKE_CONFIRM))
                    {
                        IsDownloadCmdToFW = 1;
				break;
       	            }
	 
                    if (PsSubCommand == HostCmd_SubCmd_Sleep_Confirmed)
                    {
                        IsDownloadCmdToFW = 1;
	            }
                    else
    		    {
						//RETAILMSG(1, (TEXT("> 1")));
						
			NdisAcquireSpinLock(&Adapter->PriorityQSpinLock);		
                        InsertQNodeFromHead(&(Adapter->CmdPendQ),(PQ_NODE)pTempNode);
			NdisReleaseSpinLock(&Adapter->PriorityQSpinLock);	
    		    }
                    break;
            }    
        } // (pTempNode != NULL) end    
    }
    else // Queue is empty
    {
    		
        if ((Adapter->MediaConnectStatus == NdisMediaStateConnected) &&
            (Adapter->PSMode != Ndis802_11PowerModeCAM) &&
            	    (Adapter->psState == PS_STATE_FULL_POWER) &&
  	           EncryptionStateCheck(Adapter)  ) // pluschen
	{
            pPsEnterCmd = GetFreeCmdCtrlNode(Adapter);
            MakePsCmd (Adapter, pPsEnterCmd, HostCmd_SubCmd_Enter_PS);
            pTempNode = pPsEnterCmd;
            IsDownloadCmdToFW = 1;
	}
		else
		{
			//RETAILMSG(1, (TEXT("> 2")));
		}
    }	

    if (IsDownloadCmdToFW)
    {
        Command = ((PHostCmd_DS_GEN)(pTempNode->BufVirtualAddr))->Command;

	//RETAILMSG(1, (TEXT("GetCmdFromQueueToExecute send command 0x%x > 1"), Command));



        if ((Command == HostCmd_CMD_802_11_PS_MODE))
            PsSubCommand = ((PHostCmd_DS_802_11_PS_MODE)pTempNode->BufVirtualAddr)->SubCommand;
			
    	status = DownloadCommand(Adapter, pTempNode);
	if ( status != NDIS_STATUS_SUCCESS)    
	{
	    NdisAcquireSpinLock(&Adapter->PriorityQSpinLock);		
            InsertQNodeFromHead(&(Adapter->CmdPendQ),(PQ_NODE)pTempNode);
	    NdisReleaseSpinLock(&Adapter->PriorityQSpinLock);		
	}

    }	
					 			 
    LeaveCriticalSection(&Adapter->CmdQueueExeSection); 

    return;
}


NDIS_STATUS
DownloadCommand(
	IN PMRVDRV_ADAPTER Adapter,
	IN CmdCtrlNode *pTempNode
	)
{
	USHORT          	*pusPtr;	// word pointer to current command.
	PHostCmd_DS_GEN pCmdPtr;
	ULONG           	ulTemp = 0;
    	BOOLEAN        	bQueueCMD = FALSE;
    	ULONG           	timeout;
    	USHORT 			Command = 0;
    	USHORT 			PsSubCommand = 0;	
       NDIS_STATUS 	status;

	NdisAcquireSpinLock(&Adapter->lCFInterfaceLock);	

	DBGPRINT(DBG_NEWCMD , ("DownloadCommand() \n"));

    	// Check device removal status
    	if ( Adapter->SurpriseRemoved == TRUE )
	{	
		NdisReleaseSpinLock(&Adapter->lCFInterfaceLock);	
		return NDIS_STATUS_FAILURE;
    	}
	Adapter->CurCmd = pTempNode;
	
	pCmdPtr = (PHostCmd_DS_GEN)pTempNode->BufVirtualAddr;

	Command = ((PHostCmd_DS_GEN)pCmdPtr)->Command;
	PsSubCommand = ((PHostCmd_DS_802_11_PS_MODE)pCmdPtr)->SubCommand;

       if (Adapter->psState == PS_STATE_SLEEP) 
 	{    
 		NdisReleaseSpinLock(&Adapter->lCFInterfaceLock);
 		return NDIS_STATUS_FAILURE;
       }

       if ((Adapter->psState == PS_STATE_SLEEP_PENDING) && 
 	    ((Command !=	HostCmd_CMD_802_11_PS_MODE) ||(PsSubCommand != HostCmd_SubCmd_Sleep_Confirmed)))
       {
		NdisReleaseSpinLock(&Adapter->lCFInterfaceLock);
		return NDIS_STATUS_FAILURE;
       }		
	
	/// HexDump(DBG_HWIF,"Command Buffer:",(PUCHAR)pCmdPtr, pCmdPtr->Size);

    	//// DisableInterrupt(Adapter);

   
    	// Download command via compact flash interface.
    	pusPtr = (PUSHORT)pCmdPtr;

	//AllenDBGPRINT(DBG_NEWCMD,("Send a command 0x%x ****\n", 
	//		((PHostCmd_DS_GEN)Adapter->CurCmd->BufVirtualAddr)->Command));

	//DEBUGMSG(1, (TEXT("Send a command 0x%x\r\n"),((PHostCmd_DS_GEN)Adapter->CurCmd->BufVirtualAddr)->Command));
	//RETAILMSG(1, (TEXT("Send a command 0x%x\r\n"),((PHostCmd_DS_GEN)Adapter->CurCmd->BufVirtualAddr)->Command));
	

	///HexDump(DBG_HWIF,"Command Buffer:",(PUCHAR)pCmdPtr, pCmdPtr->Size);

	//if (PsSubCommand == HostCmd_SubCmd_Sleep_Confirmed)
	//{	
	//RETAILMSG(1, (TEXT("Send a command 0x%x > 1"), ((PHostCmd_DS_GEN)Adapter->CurCmd->BufVirtualAddr)->Command));
	//	RETAILMSG(1, (TEXT("PsSubCommand 0x%x >>> "), PsSubCommand));
	//}
	
	if (cf_SendCmd( Adapter->hwIface, pusPtr, pCmdPtr->Size) == IX_STATUS_SUCCESS)
	{
		Adapter->bIsDoingCmd = TRUE;

       	Adapter->CommandTimerSet = TRUE;
		Adapter->isCommandTimerExpired = FALSE;
		
		/// set command timer
		if (Command == HostCmd_CMD_802_11_SCAN || 
      	    	    Command == HostCmd_CMD_802_11_ASSOCIATE_EXT ||
           	    Command == HostCmd_CMD_802_11_ASSOCIATE )
		{
     			timeout= MRVDRV_DEFAULT_LONG_COMMAND_TIME_OUT;
		}
		else
		{	
			timeout = MRVDRV_DEFAULT_COMMAND_TIME_OUT;
		}
		     
		if (Command == HostCmd_CMD_802_11_PS_MODE) 
    		{
       		if (PsSubCommand != HostCmd_SubCmd_Sleep_Confirmed)
        		{
          			NdisMSetTimer(&Adapter->MrvDrvCommandTimer, timeout); 
        		}
    		}    
		else
		{
    			NdisMSetTimer(&Adapter->MrvDrvCommandTimer, timeout);
		}	

  	

#ifdef DEEP_SLEEP
		// After deep sleep ,clean all command in command Q and indicate the upper layer 
		// the disconnected statue

        if (Adapter->CurCmd) 
        {    
            if (((PHostCmd_DS_GEN)Adapter->CurCmd->BufVirtualAddr)->Command == 
                          HostCmd_CMD_802_11_DEEP_SLEEP )
            {
                Adapter->IsDeepSleep = TRUE;
                ResetCmdBuffer(Adapter);	
                DBGPRINT(DBG_CMDRESP | DBG_ALLEN,("Deep Sleep : DEEP_SLEEP_CMD Sent Down\n"));
                
    //RETAILMSG(1, (TEXT("indicate NDIS_STATUS_MEDIA_DISCONNECT 1 \r\n")));	

                NdisMIndicateStatus(
                            Adapter->MrvDrvAdapterHdl,
                                NDIS_STATUS_MEDIA_DISCONNECT,
                            (PVOID)NULL,
                            0);
                    NdisMIndicateStatusComplete(Adapter->MrvDrvAdapterHdl);
                }
        }
#endif 

		if ((Command == HostCmd_CMD_802_11_PS_MODE) &&
		     ((PsSubCommand == HostCmd_SubCmd_Sleep_Confirmed) ||
		     (PsSubCommand == HostCmd_SubCmd_Enter_PS)))	
			
		{
	       	UpdatePowerSaveState( Adapter, Adapter->CurCmd, 0);

			if (PsSubCommand == HostCmd_SubCmd_Sleep_Confirmed)
			{
				Adapter->CurCmd = NULL;
				ReturnCmdNode(Adapter, pTempNode);
			}
		}	

              #ifdef HOST_WAKEUP

		if (Command == HostCmd_CMD_802_11_HOST_SLEEP_CFG)
        {
            if (Adapter->bHostWakeCfgSet == 1)
                Adapter->HostPowerState = HTWK_STATE_PRESLEEP;
            else
                Adapter->HostPowerState = HTWK_STATE_FULL_POWER;
        }
        #endif
       		status = NDIS_STATUS_SUCCESS;
	}
	else
	{
		Adapter->bIsDoingCmd = FALSE;
		Adapter->CurCmd = NULL;
		
		status = NDIS_STATUS_FAILURE;
	}
	
	NdisReleaseSpinLock(&Adapter->lCFInterfaceLock);
	
	return status;
}

VOID
UpdatePowerSaveState(
	IN PMRVDRV_ADAPTER Adapter,
	IN CmdCtrlNode *pTempNode,
	IN ULONG  PsEvent
	)
{
	USHORT Command;
	USHORT PsSubCommand;
	// CmdCtrlNode *pPsComfirm;

	//DBGPRINT(DBG_NEWPS,("++ UpdatePowerSaveState\n"));
	//DBGPRINT(DBG_NEWPS,("Current State : %d\n",Adapter->psState));

	EnterCriticalSection(&Adapter->PsUpdateCriticalSection);
	
	if (PsEvent)  // the input is a event
	{
        	//DBGPRINT(DBG_NEWPS,("Event Enter 0x%08x\n", PsEvent));
              //RETAILMSG(1, (TEXT("cs = 0x%x ev= 0x%x>>> "), Adapter->psState, PsEvent));	

		switch(Adapter->psState)
		{
			case PS_STATE_WAKEUP:	

				DBGPRINT(DBG_NEWPS | DBG_SP,("Current State : PS_STATE_WAKEUP\n"));
					
				if (PsEvent == MACREG_INT_CODE_PS_SLEEP)
				{	
					DBGPRINT(DBG_NEWPS | DBG_SP,("Receive Event : MACREG_INT_CODE_PS_SLEEP\n"));

					//if ((Adapter->CurCmd == NULL) && (Adapter->bIsDoingTx == FALSE) && 
					//   (Adapter->bIsDoingRx == FALSE)) 

					if ((Adapter->CurCmd == NULL) && (Adapter->TxPacketCount == 0) && 
					   (Adapter->bIsDoingRx == FALSE)) 
					{
					    	Adapter->psState = PS_STATE_SLEEP_PENDING;
					    	// insert a PS_COMFIRM command to pQ
					    	PSConfirmSleep(Adapter);
				        }
					else
					{
						//RETAILMSG(1, (TEXT(" >>>>> receive sleepevent but CurCmd!=0 >>>>>>\n")));	
					}
				}
				break;
						
    			case PS_STATE_SLEEP:
				
				DBGPRINT(DBG_NEWPS | DBG_SP,("Current State : PS_STATE_SLEEP\n"));
								
	 			if (PsEvent == MACREG_INT_CODE_PS_AWAKE)
	 			{
					DBGPRINT(DBG_NEWPS | DBG_SP,("Receive Event : MACREG_INT_CODE_PS_AWAKE\n"));	
					Adapter->psState = PS_STATE_WAKEUP;

					//NdisMSendResourcesAvailable(Adapter->MrvDrvAdapterHdl); 
	 			}
        
                                //dralee. protect for ps_confirm command lost 9/9/05
				if (PsEvent == MACREG_INT_CODE_PS_SLEEP)
				{	
					DBGPRINT(DBG_NEWPS | DBG_SP,("Receive Event : MACREG_INT_CODE_PS_SLEEP\n"));

					Adapter->psState = PS_STATE_SLEEP_PENDING;

					// insert a PS_COMFIRM command to pQ
					PSConfirmSleep(Adapter);
				}
				break;
/*
			case PS_STATE_FULL_POWER:

				if (PsEvent == MACREG_INT_CODE_PS_SLEEP)
				{	
					DBGPRINT(DBG_NEWPS | DBG_SP,("Receive Event : MACREG_INT_CODE_PS_SLEEP\n"));

					Adapter->psState = PS_STATE_SLEEP_PENDING;

					// insert a PS_COMFIRM command to pQ
					PSConfirmSleep(Adapter);
				}
				break;
*/								
			default:
				break;
       	}
	}
	else  // the input is a command
	{
		if (pTempNode==NULL)
			return;
		
		Command = ((PHostCmd_DS_GEN)(pTempNode->BufVirtualAddr))->Command;

		//DBGPRINT(DBG_NEWPS,("Command 0x%04x Enter\n", Command));
		
		if ((Command == HostCmd_CMD_802_11_PS_MODE) ||
		    (Command == HostCmd_RET_802_11_PS_MODE))
		{
			PsSubCommand = ((PHostCmd_DS_802_11_PS_MODE)pTempNode->BufVirtualAddr)->SubCommand;

//RETAILMSG(1, (TEXT("cs = 0x%x cmd= 0x%x>>> "), Adapter->psState, PsSubCommand));	
			
            		DBGPRINT(DBG_NEWPS,("PS Command : subcommand = %d\n",PsSubCommand));

			switch(Adapter->psState)
			{
  				case PS_STATE_FULL_POWER:

					DBGPRINT(DBG_NEWPS |DBG_SP,("Current State : PS_STATE_FULL_POWER\n"));
					
					if (PsSubCommand == HostCmd_SubCmd_Enter_PS)
					{
						DBGPRINT(DBG_NEWPS |DBG_SP,("Receive PS SubCommand : HostCmd_SubCmd_Enter_PS\n"));
						Adapter->psState = PS_STATE_WAKEUP;

						//NdisMSendResourcesAvailable(Adapter->MrvDrvAdapterHdl); 
					}
					break;
		
				case PS_STATE_WAKEUP:	

					DBGPRINT(DBG_NEWPS |DBG_SP,("Current State : PS_STATE_WAKEUP\n"));
					
					if (PsSubCommand == HostCmd_SubCmd_Exit_PS)
					{	
						DBGPRINT(DBG_NEWPS |DBG_SP,("Receive PS SubCommand : HostCmd_SubCmd_Exit_PS\n"));
						Adapter->psState = PS_STATE_FULL_POWER;	

						//NdisMSendResourcesAvailable(Adapter->MrvDrvAdapterHdl); 
					}
					/*
                    			if (PsSubCommand == HostCmd_SubCmd_Sleep_Confirmed)
                    			{
                        			DBGPRINT(DBG_NEWPS |DBG_SP,("Receive PS SubCommand : HostCmd_SubCmd_Sleep_Confirmed\n"));
                    				Adapter->psState = PS_STATE_SLEEP;
                    			}
                    			*/
					break;
				
    				case PS_STATE_SLEEP_PENDING:  

					DBGPRINT(DBG_NEWPS,("Current State : PS_STATE_SLEEP_PENDING\n"));

					/*
					if (PsSubCommand == HostCmd_SubCmd_Exit_PS)
					{	
						DBGPRINT(DBG_NEWPS |DBG_SP,("Receive PS SubCommand : HostCmd_SubCmd_Exit_PS\n"));
						Adapter->psState = PS_STATE_FULL_POWER;
						
						//NdisMSendResourcesAvailable(Adapter->MrvDrvAdapterHdl); 
					}
					*/
					if (PsSubCommand == HostCmd_SubCmd_Sleep_Confirmed)
					{
						DBGPRINT(DBG_NEWPS |DBG_SP,("Receive PS SubCommand : HostCmd_SubCmd_Sleep_Confirmed\n"));
						Adapter->psState = PS_STATE_SLEEP;
					}
					break;
			       
				case PS_STATE_SLEEP:

					DBGPRINT(DBG_NEWPS |DBG_SP,("Current State : PS_STATE_SLEEP\n"));

					if (PsSubCommand == HostCmd_SubCmd_Exit_PS)
					{	
						DBGPRINT(DBG_NEWPS |DBG_SP,("Receive PS SubCommand : HostCmd_SubCmd_Exit_PS\n"));
						Adapter->psState = PS_STATE_FULL_POWER;

						//NdisMSendResourcesAvailable(Adapter->MrvDrvAdapterHdl); 
					}
					break;

				default:
					break;
			}
		}
	}	

	//DBGPRINT(DBG_NEWPS,("-- UpdatePowerSaveState\n"));

	LeaveCriticalSection(&Adapter->PsUpdateCriticalSection);
	
	return;
}

// pluschen
UINT8 EncryptionStateCheck(IN PMRVDRV_ADAPTER Adapter)
{
     UINT8 IsAllowPS;
     
     DBGPRINT(DBG_ALL,("ESCheck %x \n", Adapter->EncryptionStatus));
     	
     switch(Adapter->EncryptionStatus)
     {	
        case Ndis802_11Encryption1Enabled:    
        case Ndis802_11EncryptionDisabled:    
        case Ndis802_11Encryption2Enabled:
        case Ndis802_11Encryption3Enabled:
             IsAllowPS = 1;
        break;
        default:
             IsAllowPS = 0;
        break;
     }	
	
     return IsAllowPS; 	
}	


/*

VOID
BruteSendDeauthentication(
	IN PMRVDRV_ADAPTER Adapter,
	IN UCHAR *BSSID 
	)
{
       UCHAR buffer[128];
       USHORT Size; 
	PHostCmd_DS_802_11_DEAUTHENTICATE pDeAuthenticate;
   
	Size = (USHORT)(sizeof(HostCmd_DS_802_11_DEAUTHENTICATE));
	pDeAuthenticate = (PHostCmd_DS_802_11_DEAUTHENTICATE) buffer;

       // set AP MAC address
       NdisMoveMemory( pDeAuthenticate->MacAddr, BSSID, MRVDRV_ETH_ADDR_LEN);
	// Reason code 3 = Station is leaving
	pDeAuthenticate->ReasonCode = 3;

	pDeAuthenticate->Command = HostCmd_CMD_802_11_DEAUTHENTICATE;
	pDeAuthenticate->Result = 0;
	Adapter->SeqNum += 1;	
	pDeAuthenticate->SeqNum = Adapter->SeqNum;
	pDeAuthenticate->Size = Size;

	if (cf_SendCmd( Adapter->hwIface, (USHORT *)buffer, Size) == IX_STATUS_SUCCESS)
	{
		RETAILMSG(1, (TEXT("BruteSendDeauthentication OK \r\n ")));
	}
	else
	{
		RETAILMSG(1, (TEXT("BruteSendDeauthentication Fail \r\n ")));
	}
}
*/