cmdproc.c

marvell8385 GSPI开发驱动

 *        NDIS_OID PendingOID
 *        USHORT PendingInfo
 *        USHORT INTOption
 *        USHORT BatchQNum
 *        BOOLEAN IsLastBatchCmd
 *        PULONG BytesWritten
 *        PULONG BytesRead
 *        PULONG BytesNeeded
 *        PVOID InformationBuffer
 *    
 *  Return Value:        
 * 
 *  Notes: 
 *
 *****************************************************************************/
VOID SetCmdCtrlNode(
  IN  PMRVDRV_ADAPTER Adapter,
  IN  CmdCtrlNode *pTempNode,
  IN  NDIS_OID PendingOID,
  IN  USHORT PendingInfo,
  IN  USHORT INTOption,
  IN  USHORT BatchQNum,
  IN  BOOLEAN IsLastBatchCmd,
  IN  PULONG BytesWritten,
  IN  PULONG BytesRead,
  IN  PULONG BytesNeeded,
  IN  PVOID InformationBuffer
)
{
  if( !pTempNode )
    return;
  
  pTempNode->PendingOID    = PendingOID;
  pTempNode->PendingInfo     = PendingInfo;
  pTempNode->INTOption     = INTOption;
  pTempNode->BatchQNum     = BatchQNum;
  pTempNode->IsLastBatchCmd  = IsLastBatchCmd;
  pTempNode->BytesWritten    = BytesWritten;
  pTempNode->BytesRead     = BytesRead;
  pTempNode->BytesNeeded     = BytesNeeded;
  pTempNode->InformationBuffer = InformationBuffer;
  
  return;
}
/******************************************************************************
 *
 *  Name: GetExpectedRetCode()
 *
 *  Description: 
 *
 *  Arguments:  
 *    
 *  Return Value:        
 * 
 *  Notes: 
 *
 *****************************************************************************/
USHORT 
GetExpectedRetCode(USHORT Cmd)
{
  USHORT RetCode;


  if (Cmd==HostCmd_CMD_802_11_ASSOCIATE_EXT)
    RetCode = HostCmd_RET_802_11_ASSOCIATE;
  else
    RetCode = (Cmd | 0x8000); 
   
  return RetCode;
}

/******************************************************************************
 *
 *  Name: CleanUpCmdCtrlNode()
 *
 *  Description: to clean up CmdCtrlNode
 *
 *  Arguments:  CmdCtrlNode *pTempNode
 *    
 *  Return Value:        
 * 
 *  Notes: 
 *
 *****************************************************************************/
VOID CleanUpCmdCtrlNode(
  IN  CmdCtrlNode *pTempNode
)
{
  if( !pTempNode )
    return;

  pTempNode->Status      = HostCmd_STATE_IDLE;
  pTempNode->PendingOID    = (NDIS_OID)0;
  pTempNode->ExpectedRetCode   = HostCmd_CMD_NONE;
  pTempNode->PendingInfo     = HostCmd_PENDING_ON_NONE;
  pTempNode->INTOption     = HostCmd_OPTION_USE_INT; // Default
  pTempNode->BatchQNum     = 0;
  pTempNode->IsLastBatchCmd  = FALSE;
  pTempNode->BytesWritten    = NULL;
  pTempNode->BytesRead     = NULL;
  pTempNode->BytesNeeded     = NULL;
  pTempNode->InformationBuffer = NULL;
    pTempNode->Pad[0]            = 0;
    pTempNode->Pad[1]            = 0;
    pTempNode->Pad[2]            = 0;
  pTempNode->PadExt[0]     = 0;
  pTempNode->PadExt[0]     = 0;
  pTempNode->PadExt[0]     = 0;
  pTempNode->PadExt[0]     = 0;

  if( pTempNode->BufVirtualAddr != NULL )
      NdisZeroMemory(pTempNode->BufVirtualAddr, MRVDRV_SIZE_OF_CMD_BUFFER);
  
  return;
}

// plus ++

VOID
InsertCmdToQueue(
  IN PMRVDRV_ADAPTER Adapter,
  IN CmdCtrlNode *pTempCmd
  )
{
    USHORT Command;
    USHORT PsSubCommand;
    USHORT AddToQueue = 0xFFFF;
  
    if (!pTempCmd)
    return;

    Command = ((PHostCmd_DS_GEN)(pTempCmd->BufVirtualAddr))->Command;
    if ((Command == HostCmd_CMD_802_11_PS_MODE))
        PsSubCommand = ((PHostCmd_DS_802_11_PS_MODE)pTempCmd->BufVirtualAddr)->SubCommand;
    else
        PsSubCommand = 0;
        
//    if(PsSubCommand != HostCmd_SubCmd_Sleep_Confirmed)
//        DraleeMsg((L"InsertCmdToQueue: Cmd %x PsSubCmd %x PSSTATE %x \n", Command, PsSubCommand, Adapter->psState));

    switch(Adapter->psState)
    {
    	case PS_STATE_FULL_POWER:
             if((PsSubCommand == HostCmd_SubCmd_Enter_PS) ||
                (PsSubCommand == 0))
                   AddToQueue = 0;    	     
    	break;
    	
    	case PS_STATE_WAKEUP:
              if(PsSubCommand == HostCmd_SubCmd_Exit_PS)
                  AddToQueue = 1;    	     
    	      else if (PsSubCommand == 0)
    	          AddToQueue = 0;

    	break;
    	
    	case PS_STATE_SLEEP:   //dralee_20051128
    	     if (PsSubCommand == HostCmd_SubCmd_Sleep_Confirmed|| PsSubCommand == HostCmd_SubCmd_Exit_PS)
    	         AddToQueue = 1;
    	     else if (PsSubCommand == 0)
    	          AddToQueue = 0;
    	break;
    }	
    
    if(Command == HostCmd_CMD_802_11_DEEP_SLEEP)
    {
         AddToQueue = 1;
    }
    if(Command == HostCmd_CMD_802_11_HOST_SLEEP_CFG)
    {
         AddToQueue = 1;
    }
        
    switch(AddToQueue)
    {
        case 0:	
          InsertQNodeAtTail(&(Adapter->CmdPendQ),(PQ_NODE)pTempCmd);
        break;
        case 1:
          InsertQNodeFromHead(&(Adapter->CmdPendQ),(PQ_NODE)pTempCmd);
        break;
        default:  
          ReturnCmdNode(Adapter, pTempCmd);
        break;
    }     

}

VOID
GetCmdFromQueueToExecute( 
  IN PMRVDRV_ADAPTER Adapter
  )
{
  CmdCtrlNode *pTempNode=NULL;
#ifndef CONFIG_WLAN_PMU
  CmdCtrlNode *pPsEnterCmd;
#endif
  CmdCtrlNode *pPsExitCmd;
  USHORT    PsSubCommand;
  USHORT    Command;
  USHORT    IsDownloadCmdToFW;
  NDIS_STATUS 	status;


  //USHORT      whichQ;

  DBGPRINT(DBG_NEWCMD, ("GetCmdFromQueueToExecute() \n"));
  
  //dralee_20051128
  if (Adapter->CurCmd || Adapter->SentPacket)  
  {
       DBGPRINT(DBG_NEWCMD, ("GetCmdFromQueueToExecute: return 1 =>Adapter->CurCmd\n")); 
       //RETAILMSG(1,(TEXT("GetCmdFromQueueToExecute: return 1 =>Adapter->CurCmd \r\n")));
       return;
  }  
   
  if ( Adapter->psState == PS_STATE_SLEEP && Adapter->bPSConfirm==TRUE )
  {
       DBGPRINT(DBG_NEWCMD, ("GetCmdFromQueueToExecute: return =>Adapter->psState == PS_STATE_SLEEP  PS_STATE_SLEEP_PENDING \n")); 
       //RETAILMSG(1, (TEXT("GetCmdFromQueueToExecute: return 1 =>Sleep confirmed \n\r"))); 
       return;
  } 
  
  //dralee 072705
  if( TryEnterCriticalSection(&Adapter->CmdQueueExeSection) == 0 )
      return; 

  //dralee 08092005
  EnterCriticalSection(&Adapter->TxCriticalSection);

  IsDownloadCmdToFW = 0;
  if (!IsQEmpty(&Adapter->CmdPendQ))
  { 
     pTempNode = (CmdCtrlNode *)PopFirstQNode(&Adapter->CmdPendQ);
     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 0                
                #if 0 //dralee_20051119
                if(PsSubCommand != HostCmd_SubCmd_Exit_PS)
                #else
                if(PsSubCommand != HostCmd_SubCmd_Exit_PS &&
                   Command != HostCmd_CMD_802_11_HOST_SLEEP_AWAKE_CONFIRM &&
                   Command != HostCmd_CMD_802_11_RSSI &&
                   Command != HostCmd_CMD_MAC_CONTROL &&
                   Command != HostCmd_CMD_802_11_HOST_SLEEP_CFG)
                #endif
                {
                   pPsExitCmd = GetFreeCmdCtrlNode(Adapter);
                   MakePsCmd (Adapter, pPsExitCmd, HostCmd_SubCmd_Exit_PS);
                   InsertQNodeFromHead(&(Adapter->CmdPendQ),(PQ_NODE)pTempNode);
                   pTempNode = pPsExitCmd;
                }	
#endif                
           break;
           case PS_STATE_SLEEP:
                if(PsSubCommand == HostCmd_SubCmd_Sleep_Confirmed)
                   IsDownloadCmdToFW = 1;
                else
                { 
                   InsertQNodeFromHead(&(Adapter->CmdPendQ),(PQ_NODE)pTempNode);
                }   
           break;
        }    
     } // (pTempNode != NULL) end    
  }
   else // Queue is empty
  {
#ifndef CONFIG_WLAN_PMU
        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;

  	}	  
#endif            
}	 
  
  if(IsDownloadCmdToFW)
  {
    // for debug	
//      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;
//      if(PsSubCommand != HostCmd_SubCmd_Sleep_Confirmed)   
//      DraleeMsg((L"GetCmdFromQueueToExecute: Cmd %x PsSubCmd %x PSSTATE %x \n", Command, PsSubCommand, Adapter->psState));
      status = DownloadCommand(Adapter, pTempNode);
      if ( status != NDIS_STATUS_SUCCESS)  
      {
          InsertQNodeFromHead(&(Adapter->CmdPendQ),(PQ_NODE)pTempNode);
      }
  }
  LeaveCriticalSection(&Adapter->TxCriticalSection);   
 
  LeaveCriticalSection(&Adapter->CmdQueueExeSection); 
  //sd_ReleaseCmdDownloadPath(Adapter);
} 

// plus --

NDIS_STATUS
DownloadCommand(
  IN PMRVDRV_ADAPTER Adapter,
  IN CmdCtrlNode *pTempNode
  )
{
  BOOLEAN timerStatus;
  //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; 
    #if defined(SDIO) || defined(IF_SPI)
    SD_API_STATUS           status;          // intermediate status
      SDIO_TX_PKT             cmdDownload;
    #endif

  DBGPRINT(DBG_NEWCMD, ("DownloadCommand() \n"));
  
    // Check device removal status
    if( Adapter->SurpriseRemoved == TRUE ){
        return NDIS_STATUS_ADAPTER_REMOVED;
    }

    DBGPRINT(DBG_NEWCMD,("**** Download command 2  0x%x ****\n", 
      ((PHostCmd_DS_GEN)pTempNode->BufVirtualAddr)->Command));

    Adapter->CurCmd = pTempNode;
  
    pCmdPtr = (PHostCmd_DS_GEN)pTempNode->BufVirtualAddr;
  
  // HexDump(DBG_HWIF,"Command Buffer:",(PUCHAR)pCmdPtr, pCmdPtr->Size);

    //// DisableInterrupt(Adapter);

/* tt v5 firmware
  Adapter->CommandTimerSet = TRUE;
  Adapter->isCommandTimerExpired = FALSE;
*/

  /// set command timer 
  Command = ((PHostCmd_DS_GEN)Adapter->CurCmd->BufVirtualAddr)->Command;
  
  DBGPRINT(DBG_NEWCMD,("Download command 3 0x%x ****\n", 
      ((PHostCmd_DS_GEN)Adapter->CurCmd->BufVirtualAddr)->Command));

#if defined(SDIO)||defined(IF_SPI)

    // prepare command download packet
    cmdDownload.Len = ADD_SDIO_PKT_HDR_LENGTH(pCmdPtr->Size);    
    cmdDownload.Type = SDIO_CMD_PKT;
    NdisMoveMemory(cmdDownload.Buf.CmdBuf, pCmdPtr, pCmdPtr->Size);

	if ( Command != 0x21 )
		V5DbgMsg( (L"   # dwn: 0x%x\n", Command) );
     
    // schiu 5/10/03
    // make sure the interrupt is enabled
    //EnableInterrupt(Adapter);

// tt ++ v5 firmware
	Adapter->CommandTimerSet = TRUE;
	Adapter->isCommandTimerExpired = FALSE;
       NdisMCancelTimer(&Adapter->MrvDrvCommandTimer, &timerStatus);
	NdisMSetTimer(&Adapter->MrvDrvCommandTimer, MRVDRV_DEFAULT_LONG_COMMAND_TIME_OUT);
// tt -- 

    //dralee 08092005 
    //move this critical section up to GetCmdFromQueueToExecute
    //EnterCriticalSection(&Adapter->TxCriticalSection);
    status = If_DownloadPkt(Adapter, &cmdDownload);
    //LeaveCriticalSection(&Adapter->TxCriticalSection);  







    if (!SD_API_SUCCESS(status))
    {
        if ( Adapter->CurCmd != NULL )
        {
            DBGPRINT(DBG_CMDRESP | DBG_ERROR, 
                ("CMD 0x%x download failed!\n", 
                ((PHostCmd_DS_GEN)Adapter->CurCmd->BufVirtualAddr)->Command));

            // there is a race condition for suspend/resume, so need
            // to check if suspend occured
            if ( Adapter->ShutDown == TRUE ) //Adapter->ShutDown = TRUE  when: SDCardEjected
            {
                // card eject event occured, the commands are cleaned up!
                DBGPRINT(DBG_UNLOAD, 
                    ("Detected shutdown in DownloadCommand procedure, exit!\n"));
                return NDIS_STATUS_FAILURE;
            }

            DBGPRINT(DBG_ALL, ("Call CleanupCmdCtrlNode\n")); 
            //Clean up the command control node
            CleanUpCmdCtrlNode(Adapter->CurCmd);

            DBGPRINT(DBG_ALL, ("Call InsertQ to CmdFreeQ\n"));
            //Put current command back to CmdFreeQ
            InsertQNodeAtTail(&Adapter->CmdFreeQ, (PQ_NODE)Adapter->CurCmd);

            DBGPRINT(DBG_ALL, ("Set CurCmd to NULL\n"));
            Adapter->CurCmd = NULL;
        }
        else
        {
            DBGPRINT(DBG_ERROR, ("Current command already removed, possibly due to"
                " card removal?\n"));