cmdsend.c

此压缩包为杰得开发得z228的BSP的源代码,可以实现很多功能,尤其是视频解码有很好的效果.

        if ( pCmd->Action == HostCmd_ACT_SET )
        {
          pCmd->AC_BE = Adapter->QOSParams.AC_BE;
          pCmd->AC_BE_XTRA = Adapter->QOSParams.AC_BE_XTRA;
          pCmd->AC_BK = Adapter->QOSParams.AC_BK;
          pCmd->AC_BK_XTRA = Adapter->QOSParams.AC_BK_XTRA;
          pCmd->AC_VI = Adapter->QOSParams.AC_VI;
          pCmd->AC_VI_XTRA = Adapter->QOSParams.AC_VI_XTRA;
          pCmd->AC_VO = Adapter->QOSParams.AC_VO;
          pCmd->AC_VO_XTRA = Adapter->QOSParams.AC_VO_XTRA;
        }
      }

      break;

    case HostCmd_CMD_802_11_RSSI:
     {
	#ifdef NEW_RSSI
         Size = (USHORT)(sizeof(HostCmd_DS_802_11_RSSI));
	  prssi = (PHostCmd_DS_802_11_RSSI)pCmdPtr;
	  prssi->N=(SHORT)Adapter->bcn_avg_factor;

	  /* reset Beacon SNR/NF/RSSI values */
	 Adapter->SNR[TYPE_BEACON][TYPE_NOAVG] = 0;
	 Adapter->SNR[TYPE_BEACON][TYPE_AVG] = 0;
	 Adapter->NF[TYPE_BEACON][TYPE_NOAVG] = 0;
	 Adapter->NF[TYPE_BEACON][TYPE_AVG] = 0;
	 Adapter->RSSI[TYPE_BEACON][TYPE_NOAVG] = 0;
	 Adapter->RSSI[TYPE_BEACON][TYPE_AVG] = 0;
	#else
          Size = (USHORT)(sizeof(HostCmd_DS_802_11_RSSI));
	#endif
    } 
      break;

    case HostCmd_CMD_802_11_GET_LOG:
      Size = (USHORT)(sizeof(HostCmd_DS_802_11_GET_LOG));
      break;

    case HostCmd_CMD_GET_HW_SPEC:
      Size = (USHORT)(sizeof(HostCmd_DS_GET_HW_SPEC));
      pHWSpec = (PHostCmd_DS_GET_HW_SPEC)pCmdPtr;
      
      // Move Adapter->CurrentAddr to address field
      NdisMoveMemory(pHWSpec->PermanentAddr, Adapter->CurrentAddr, MRVDRV_ETH_ADDR_LEN);
    
      DBGPRINT(DBG_CMDRESP,("*** set f/w permanent addr : %2x %2x %2x %2x %2x %2x ***\n", 
        pHWSpec->PermanentAddr[0],
        pHWSpec->PermanentAddr[1],
        pHWSpec->PermanentAddr[2],
        pHWSpec->PermanentAddr[3],
        pHWSpec->PermanentAddr[4],
        pHWSpec->PermanentAddr[5]));        
    break;
  
    case HostCmd_CMD_802_11_RESET:
      Size = (USHORT)(sizeof(HostCmd_DS_802_11_RESET));
      pReset = (PHostCmd_DS_802_11_RESET)pCmdPtr;
      pReset->Action = CmdOption;
    break;
  
    case HostCmd_CMD_802_11_QUERY_STATUS:
      Size = (USHORT)(sizeof(HostCmd_DS_802_11_QUERY_STATUS));
      pStatus = (PHostCmd_DS_802_11_QUERY_STATUS)pCmdPtr;
    break;
  
    case HostCmd_CMD_802_11_QUERY_TRAFFIC:
      Size = (USHORT)(sizeof(HostCmd_DS_802_11_QUERY_TRAFFIC));
      pTraffic = (PHostCmd_DS_802_11_QUERY_TRAFFIC)pCmdPtr;
    break;
  
    case HostCmd_CMD_MAC_CONTROL:
      Size = (USHORT)(sizeof(HostCmd_DS_MAC_CONTROL));
      pControl = (PHostCmd_DS_MAC_CONTROL)pCmdPtr;
      pControl->Action = CmdOption;
    break;
  
    case HostCmd_CMD_MAC_MULTICAST_ADR:
      Size = (USHORT)(sizeof(HostCmd_DS_MAC_MULTICAST_ADR));
      pMCastAdr = (PHostCmd_DS_MAC_MULTICAST_ADR)pCmdPtr;
      pMCastAdr->Action = CmdOption;
      pMCastAdr->NumOfAdrs = (USHORT)Adapter->NumOfMulticastMACAddr;
      
      NdisMoveMemory(
        (PVOID)pMCastAdr->MACList, 
        (PVOID)Adapter->MulticastList,
        Adapter->NumOfMulticastMACAddr*ETH_LENGTH_OF_ADDRESS);
    break;
  
    case HostCmd_CMD_802_11_GET_STAT:
      Size = (USHORT)(sizeof(HostCmd_DS_802_11_GET_STAT));
      p11Stat = (PHostCmd_DS_802_11_GET_STAT)pCmdPtr;
    break;
  
    case HostCmd_CMD_802_3_GET_STAT:  
      Size = (USHORT)(sizeof(HostCmd_DS_802_3_GET_STAT));
      p3Stat = (PHostCmd_DS_802_3_GET_STAT)pCmdPtr;
    break;
  
    case HostCmd_CMD_802_11_PS_MODE:
         {
      Size = (USHORT)(sizeof(HostCmd_DS_802_11_PS_MODE));
      pPSMode = (PHostCmd_DS_802_11_PS_MODE)pCmdPtr;

      //pPSMode->Action = 0;
      pPSMode->SubCommand = (USHORT)InformationBuffer;
      //pPSMode->PowerMode = 0;
                 
#if 0 //dralee, 20051031, move to DownloadCommand()
//tt ++ ra fail
	if ( pPSMode->SubCommand == HostCmd_SubCmd_Enter_PS )
	{
		EnterCriticalSection(&Adapter->TxCriticalSection);
		BatchIndicateRetQPkts(Adapter);
		LeaveCriticalSection(&Adapter->TxCriticalSection);
	}
//tt -- 
#endif

        #ifdef MRVL_USE_MULTIPLE_DTIM
            pPSMode->PSNumDtims = Adapter->DTIMNum;
          #else
                  pPSMode->PSNumDtims = 0x1;
          #endif
    }
    break;
  
    case HostCmd_CMD_802_11_DATA_RATE:
      Size = (USHORT)(sizeof(HostCmd_DS_802_11_DATA_RATE));
      pDataRate = (PHostCmd_DS_802_11_DATA_RATE)pCmdPtr;
      
      SetupDataRate(CmdOption, pDataRate, Adapter,InformationBuffer);
    break;

    case HostCmd_CMD_802_11_BAND_CONFIG:
    {
      POID_MRVL_DS_802_11_BAND_CFG bc;

      bc = (POID_MRVL_DS_802_11_BAND_CFG)InformationBuffer;
      Size = (USHORT)(sizeof(HostCmd_DS_802_11_BAND_CONFIG));
      pBandConfig = (PHostCmd_DS_802_11_BAND_CONFIG)pCmdPtr;

      pBandConfig->Action = CmdOption;
      pBandConfig->Channel = bc->Channel;
      pBandConfig->BandSelection = bc->BandSelection; 
      pBandConfig->ChannelWidth = 0;
    }
        break;
  
#if 0  //dralee 081105, V4
    case HostCmd_CMD_802_11_SCAN:


    { 
      PREGION_CHANNEL region_channel;
      //PHostCmd_DS_802_11_BAND_CONFIG pBandC;
      PHostCmd_DS_802_11_SCAN pScanCMD;
      USHORT i,j,k,cmd_index;
      CmdCtrlNode *pTempScanCmd[20];
      //CmdCtrlNode *pTempBandCmd[20];
            USHORT TotalChan;
      HostCmd_DS_802_11_BAND_CONFIG bc;

            // scan in progress --> set the flag 
      Adapter->bIsScanInProgress = TRUE;
      
      // clean up the list
      if ((Adapter->bIsScanWhileConnect == FALSE) &&
        (Adapter->SetActiveScanSSID == FALSE))
      {
        Adapter->ulPSNumOfBSSIDs = 0;
      }
      
            // 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;
          
#if (defined(MRV_RF_8030) || defined(MRV_RF_8031))			///#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);