cmdsend.c

来自「marvell8385 GSPI开发驱动」· C语言 代码 · 共 1,764 行 · 第 1/5 页

            // count the channels need to scan 
      TotalChan = 0;
      for ( i=0; i < MAX_REGION_BAND_NUM; i++ ) 
      { 
          region_channel = &(Adapter->region_channel[i]);
          if (region_channel->Valid == TRUE)
          TotalChan += region_channel->NrCFP;
      } 
      DBGPRINT(DBG_CMDRESP,(">>> SCAN command TotalChan = %d\n", TotalChan));
                     //NKDbgPrintfW(L"[Marvell]HostCmd_CMD_802_11_SCAN: + SCAN command TotalChan = %d", TotalChan);   
           
            // no channel need to be scaned 
      if (TotalChan == 0)
            { 
              Adapter->bIsScanInProgress = FALSE;  
        return NDIS_STATUS_SUCCESS;
            }
      
      for ( i=0; i < MAX_REGION_BAND_NUM; i++ )
      {
        region_channel = &(Adapter->region_channel[i]);

          if (region_channel->Valid == FALSE)
            continue;
                  
          j=0;
          cmd_index=0;  
    
          while (j<region_channel->NrCFP)
          { 
          

          bc.BandSelection = region_channel->Band;
            bc.Channel = region_channel->CFP[j].Channel;
          
#ifdef MRV_CHIP_8385H
          PrepareAndSendCommand(  
              Adapter,
                HostCmd_CMD_802_11_BAND_CONFIG,
                  HostCmd_ACT_SET,
                  HostCmd_OPTION_USE_INT,
                  (NDIS_OID)0,
                  HostCmd_PENDING_ON_NONE,
                  0,
                  FALSE,
                  NULL,
                  NULL,
                  NULL,
                  &bc); 
#endif          
          pTempScanCmd[cmd_index] = GetFreeCmdCtrlNode(Adapter);
          if ( pTempScanCmd[cmd_index] == NULL )
          {
                  NdisAcquireSpinLock(&Adapter->FreeQSpinLock);
                    CleanUpCmdCtrlNode(pTempCmd);
                  InsertQNodeAtTail(&Adapter->CmdFreeQ, (PQ_NODE)pTempCmd);
                    NdisReleaseSpinLock(&Adapter->FreeQSpinLock);

            DBGPRINT(DBG_CMDRESP,(">>> Get Free CmdNode Fail \n"));
            
                    return NDIS_STATUS_FAILURE;
                }

                // setup the command
                pTempScanCmd[cmd_index]->ExpectedRetCode = GetExpectedRetCode(HostCmd_CMD_802_11_SCAN);
                pScanCMD = (PHostCmd_DS_802_11_SCAN)pTempScanCmd[cmd_index]->BufVirtualAddr;

          // setup scan command and parameter
                pScanCMD->SeqNum = (Adapter->SeqNum++);
                pScanCMD->Command = HostCmd_CMD_802_11_SCAN;
                pScanCMD->Result = INTOption;
                pScanCMD->Size = sizeof(HostCmd_DS_802_11_SCAN);
         
                pScanCMD->BSSType = HostCmd_BSS_TYPE_ANY;
          
                pScanCMD->IsAutoAssociation = 0;
                if (Adapter->bIsAssociationBlockedByScan)
                  pTempScanCmd[cmd_index]->Pad[1] |= MRVDRV_ES_ASSOCIATIONBLOCKED;
              
              if (Adapter->SetActiveScanSSID)
                {
                  NdisMoveMemory (pScanCMD->SSID,
                    Adapter->ActiveScanSSID.Ssid,
                    Adapter->ActiveScanSSID.SsidLength);
                    pTempScanCmd[cmd_index]->Pad[0] |= MRVDRV_ES_SPECIFICSCAN;
          }
          else if (Adapter->SetActiveScanBSSID) 
                {
            NdisMoveMemory (pScanCMD->BSSID,
                    Adapter->ActiveScanBSSID,
                    MRVDRV_ETH_ADDR_LEN);
                    pTempScanCmd[cmd_index]->Pad[0] |= MRVDRV_ES_SPECIFICSCAN;
          }
          else 
                {   
                    pTempScanCmd[cmd_index]->Pad[0] |= MRVDRV_ES_NOTSPECIFICSCAN;
            NdisZeroMemory(pScanCMD->SSID, MRVDRV_MAX_SSID_LENGTH);   
            NdisZeroMemory(pScanCMD->BSSID, MRVDRV_ETH_ADDR_LEN);     
                } 

          pScanCMD->ScanType = HostCmd_SCAN_TYPE_ACTIVE;
        
                pScanCMD->MinCHTime = HostCmd_SCAN_MIN_CH_TIME; 
            pScanCMD->MaxCHTime = HostCmd_SCAN_MAX_CH_TIME; 

                NdisZeroMemory(pScanCMD->CHList, MRVDRV_MAX_CHANNEL_NUMBER);
           
                for (k=0; k<PSCAN_NUM_CH_PER_SCAN; k++)
                {     
                  // fill channel info
                    pScanCMD->CHList[k] =(UCHAR)region_channel->CFP[j].Channel;
            
            j++;  
            TotalChan--; 
            
                    if (j >= region_channel->NrCFP)
                      break;
                }           
        
                // this is the last command, copy the attributes
                SetCmdCtrlNode (Adapter,
                              pTempScanCmd[cmd_index], 
                            0, 
                            HostCmd_PENDING_ON_NONE, 
                            HostCmd_OPTION_USE_INT, 
                            0, 
                            FALSE, 
                            NULL,
                            NULL,
                            NULL, 
                            NULL);

          pTempScanCmd[cmd_index]->Pad[2] |= (0x03 & region_channel->Band);

          if (cmd_index == 0)
          {  
            pTempScanCmd[cmd_index]->Pad[2] |= MRVDRV_SCAN_CMD_START;  // scan start
          }
          if (TotalChan == 0)
            pTempScanCmd[cmd_index]->Pad[2] |= MRVDRV_SCAN_CMD_END;  // scan end 

          switch (region_channel->Band)
          {
            case MRVDRV_802_11_BAND_B:
              pTempScanCmd[cmd_index]->Pad[2] |= MRVDRV_802_11_BAND_B;
              
              break;
              case MRVDRV_802_11_BAND_BG:
              pTempScanCmd[cmd_index]->Pad[2] |= MRVDRV_802_11_BAND_BG;
              
            break;
            case MRVDRV_802_11_BAND_A:
              pTempScanCmd[cmd_index]->Pad[2] |= MRVDRV_802_11_BAND_A;
              
            break;
            default:
              pTempScanCmd[cmd_index]->Pad[2] |= MRVDRV_802_11_BAND_BG;
              
            break;
          }
          DBGPRINT(DBG_CMDRESP,("Set Band to %d\n", (pTempScanCmd[cmd_index]->Pad[2] & 0x3)));
  
          pTempScanCmd[cmd_index]->PadExt[0] = (UCHAR)(bc.Channel);
            DBGPRINT(DBG_CMDRESP,("Set Channel to %d\n", pTempScanCmd[cmd_index]->PadExt[0]));  

          // send command    
                DBGPRINT(DBG_CMDRESP,(">>> send scan command %d\n", cmd_index));
                ///DownloadCommandToStation(Adapter, pTempScanCmd[cmd_index]); 
           
          //dralee_1108++
          EnterCriticalSection(&Adapter->CmdQueueExeSection);

          InsertCmdToQueue (Adapter, pTempScanCmd[cmd_index]); 

          //dralee_1108++ 
          LeaveCriticalSection(&Adapter->CmdQueueExeSection); 

          GetCmdFromQueueToExecute(Adapter);
          
                cmd_index ++;
        }
      } 

      Adapter->SeqNum--; 
      NdisAcquireSpinLock(&Adapter->FreeQSpinLock);
      CleanUpCmdCtrlNode(pTempCmd);
      InsertQNodeAtTail(&Adapter->CmdFreeQ, (PQ_NODE)pTempCmd);
      NdisReleaseSpinLock(&Adapter->FreeQSpinLock);              

      DBGPRINT(DBG_CMDRESP,("HWAC - Progressive SCAN commnad is ready\n"));

        return NDIS_STATUS_SUCCESS;   
    } 

    break;
#else
    case HostCmd_CMD_802_11_SCAN:
    {   
       RETAILMSG(1,(TEXT("Enter HostCmd_CMD_802_11_SCAN : 1 : \n"))); 
      Adapter->SeqNum--; 
          NdisAcquireSpinLock(&Adapter->FreeQSpinLock);
          CleanUpCmdCtrlNode(pTempCmd);
          InsertQNodeAtTail(&Adapter->CmdFreeQ, (PQ_NODE)pTempCmd);
          NdisReleaseSpinLock(&Adapter->FreeQSpinLock);   

      pTempCmd = NULL;

#ifdef AUTO_REASSOCIATION
      SetupScanCommand (Adapter, PendingInfo );
#else
	SetupScanCommand (Adapter );
#endif
    } 
    
    break;

#endif
    case HostCmd_CMD_802_11_SET_WEP:
        pSetWEP = (PHostCmd_DS_802_11_SET_WEP)pCmdPtr;
      pNewWEP = (PNDIS_802_11_WEP)InformationBuffer;

       RETAILMSG(1,(TEXT("Enter HostCmd_DS_802_11_SET_WEP : \n")));
      
      Size = (USHORT)(sizeof(HostCmd_DS_802_11_SET_WEP));

      SetupWepKeys(
        PendingOID,
        pSetWEP, 
        pNewWEP,
        InformationBuffer,
        Adapter,
        CmdOption);
  
      break;

    case HostCmd_CMD_802_11_SNMP_MIB:

      switch (PendingOID)
      {
        case OID_802_11_INFRASTRUCTURE_MODE:
        {
          Size = (USHORT)(sizeof(HostCmd_DS_802_11_SNMP_MIB));
          pSNMPMIB = (PHostCmd_DS_802_11_SNMP_MIB)pCmdPtr;
          pSNMPMIB->QueryType = HostCmd_ACT_GEN_SET;
          pSNMPMIB->OID = (USHORT)DesiredBssType_i; // InfrastructureMode Index = 0
          pSNMPMIB->BufSize = sizeof(UCHAR);
        
          if( Adapter->InfrastructureMode == Ndis802_11Infrastructure )
            ucTemp = 1; // Infrastructure mode
          else
            ucTemp = 2; // Ad hoc mode
        
          NdisMoveMemory(pSNMPMIB->Value, &ucTemp, sizeof(UCHAR));        
          break;
        }   
      
        case OID_802_11_FRAGMENTATION_THRESHOLD:
        {
          NDIS_802_11_FRAGMENTATION_THRESHOLD ulTemp;
          USHORT usTemp;
        
          Size = (USHORT)(sizeof(HostCmd_DS_802_11_SNMP_MIB));
          pSNMPMIB = (PHostCmd_DS_802_11_SNMP_MIB)pCmdPtr;
          pSNMPMIB->OID = (USHORT)FragThresh_i; 
          
          if(PendingInfo==HostCmd_PENDING_ON_GET_OID){
            pSNMPMIB->QueryType = HostCmd_ACT_GEN_GET;
          }
          else if(PendingInfo==HostCmd_PENDING_ON_SET_OID){
            pSNMPMIB->QueryType = HostCmd_ACT_GEN_SET;
            pSNMPMIB->BufSize = sizeof(USHORT);
            ulTemp=*((NDIS_802_11_FRAGMENTATION_THRESHOLD *)InformationBuffer);
            *((PUSHORT)(pSNMPMIB->Value))=(USHORT)ulTemp;
            DBGPRINT(DBG_OID,("OID: Setting Fragmentation threshold to %d\n", ulTemp ));
          }
          else if(PendingInfo==HostCmd_PENDING_ON_NONE){
            pSNMPMIB->QueryType = HostCmd_ACT_GEN_SET;
            pSNMPMIB->BufSize = sizeof(USHORT);
            usTemp=(USHORT)Adapter->FragThsd;
            NdisMoveMemory(pSNMPMIB->Value, &usTemp, sizeof(USHORT));
          }                       
          break;          
        } 
      
        case OID_802_11_RTS_THRESHOLD:
        {
          USHORT usTemp;
          NDIS_802_11_RTS_THRESHOLD ulTemp;
        
          Size = (USHORT)(sizeof(HostCmd_DS_802_11_SNMP_MIB));
          pSNMPMIB = (PHostCmd_DS_802_11_SNMP_MIB)pCmdPtr;
          pSNMPMIB->OID = (USHORT)RtsThresh_i; 
      
          if(PendingInfo==HostCmd_PENDING_ON_GET_OID){
            pSNMPMIB->QueryType = HostCmd_ACT_GEN_GET;
          }
          else if(PendingInfo==HostCmd_PENDING_ON_SET_OID){
            pSNMPMIB->QueryType = HostCmd_ACT_GEN_SET;
            pSNMPMIB->BufSize = sizeof(USHORT);
            ulTemp=*((NDIS_802_11_RTS_THRESHOLD *)InformationBuffer);
            *((PUSHORT)(pSNMPMIB->Value))=(USHORT)ulTemp;
            DBGPRINT(DBG_OID,("OID: Setting RTS threshold to %d\n", ulTemp ));
          }
          else if(PendingInfo==HostCmd_PENDING_ON_NONE){
            pSNMPMIB->QueryType = HostCmd_ACT_GEN_SET;
            pSNMPMIB->BufSize = sizeof(USHORT);
            usTemp=(USHORT)Adapter->RTSThsd;
            NdisMoveMemory(pSNMPMIB->Value, &usTemp, sizeof(USHORT));
          }       
          break;    
        }         
#ifdef ENABLE_802_11D
        case OID_802_11D_ENABLE:
        {
          USHORT  usTemp;

          Size = (USHORT)(sizeof(HostCmd_DS_802_11_SNMP_MIB));
          pSNMPMIB = (PHostCmd_DS_802_11_SNMP_MIB)pCmdPtr;
          pSNMPMIB->OID = Dot11D_i;

          pSNMPMIB->QueryType = HostCmd_ACT_GEN_SET;
          pSNMPMIB->BufSize = sizeof(USHORT);
          usTemp = *(USHORT*) InformationBuffer;
          *((USHORT *) (pSNMPMIB->Value)) = usTemp;
  
          break;
        }
#endif
        
        default:
          break;
            }     
    break;    

    case HostCmd_CMD_802_11_AUTHENTICATE:
        {
            UCHAR ucAuth;

      Size = (USHORT)(sizeof(HostCmd_DS_802_11_AUTHENTICATE));
      pAuthenticate = (PHostCmd_DS_802_11_AUTHENTICATE) pCmdPtr;

      // if the authentication type need to be determined at initialization time
      if(PendingInfo == HostCmd_PENDING_ON_NONE)
            {
        ucAuth = (UCHAR)Adapter->AuthenticationMode;          
      } 
      else
            {
                ucAuth = (UCHAR) (*((PNDIS_802_11_AUTHENTICATION_MODE) InformationBuffer));
            }

            switch (ucAuth)
            {