/drivers/net/wireless/tiwlan1251/common/src/hal/hl_ctrl/whalCtrl.c

Large files files are truncated, but you can click here to view the full file

/****************************************************************************
**+-----------------------------------------------------------------------+**
**|                                                                       |**
**| Copyright(c) 1998 - 2008 Texas Instruments. All rights reserved.      |**
**| All rights reserved.                                                  |**
**|                                                                       |**
**| Redistribution and use in source and binary forms, with or without    |**
**| modification, are permitted provided that the following conditions    |**
**| are met:                                                              |**
**|                                                                       |**
**|  * Redistributions of source code must retain the above copyright     |**
**|    notice, this list of conditions and the following disclaimer.      |**
**|  * Redistributions in binary form must reproduce the above copyright  |**
**|    notice, this list of conditions and the following disclaimer in    |**
**|    the documentation and/or other materials provided with the         |**
**|    distribution.                                                      |**
**|  * Neither the name Texas Instruments nor the names of its            |**
**|    contributors may be used to endorse or promote products derived    |**
**|    from this software without specific prior written permission.      |**
**|                                                                       |**
**| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS   |**
**| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT     |**
**| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |**
**| A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT  |**
**| OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |**
**| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT      |**
**| LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |**
**| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |**
**| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT   |**
**| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |**
**| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  |**
**|                                                                       |**
**+-----------------------------------------------------------------------+**
****************************************************************************/

#include "whalCommon.h"
#include "whalCtrl_api.h"
#include "whalCtrl.h"
#include "txHwQueue_api.h"
#include "txXfer_api.h"
#include "txResult_api.h"
#include "whalSecurity.h"
#include "eventMbox_api.h" 
#include "whalBus_Api.h"
#include "TNETW_Driver_api.h"
#include "commonTypes.h"
#include "TNETW_Driver.h"
#include "DebugTraceXfer_api.h"
#include "FwEvent_api.h"

/* 
    Rx filter field is mostly hard-coded.
   This filter value basically pass only valid beacons / probe responses. For exact bit description,
   consult either the DPG or the FPG (or both, and Yoel...)
*/
#define CFG_RX_PRSP_EN_ 4
#define CFG_RX_MGMT_EN_ 0x10
#define CFG_RX_BCN_EN_  0x200
#define RX_FILTER_CFG_ (CFG_RX_PRSP_EN_ | CFG_RX_MGMT_EN_ | CFG_RX_BCN_EN_)

#define SIZE_OF_HEADER 4

void whalCtrl_PrintAll (TI_HANDLE hWhalCtrl);


#ifdef ROAMING_TRIGGER_DBG
static void whalCtrl_dbg_RSSI_LEVEL(TI_HANDLE hWhalCtrl,char* str , UINT32 strLen);
TI_STATUS whalCtrl_dbg_SYNCHRONIZATION(TI_HANDLE hWhalCtrl);
TI_STATUS whalCtrl_dbg_BSS_LOSE(TI_HANDLE hWhalCtrl);
TI_STATUS whalCtrl_dbg_MAX_TX_RETRY(TI_HANDLE hWhalCtrl);
TI_STATUS whalCtrl_dbgRegisterRoamingEventCB(TI_HANDLE hWhalCtrl);
int whalCtrl_dbgRoamingCommands (TI_HANDLE hWhalCtrl);
#endif

static int whalCtrl_ReadTemplateFrameMib(TI_HANDLE hWhalCtrl, TI_HANDLE CB_Handle, void* CB_Func, void* CB_Buf);
static int whalCtrl_WriteTemplateFrameMib(TI_HANDLE hWhalCtrl, PLT_MIB_t* pMib);
static int whalCtrl_PltMibSetBeaconFilterIETable(TI_HANDLE hWhalCtrl, PLT_MIB_t* pMib);
static int whalCtrl_PltMibGetBeaconFilterIETable(TI_HANDLE hWhalCtrl, TI_HANDLE CB_Handle, void* CB_Func, void* CB_Buf);
static int whalCtrl_PLT_ReadMIB_TxRatePolicy(TI_HANDLE hWhalCtrl, TI_HANDLE CB_Handle, void* CB_Func, void* CB_Buf);
static int whalCtrl_PLT_WriteMIB_TxRatePolicy(TI_HANDLE hWhalCtrl, PLT_MIB_t* pMib);

/*
 * ----------------------------------------------------------------------------
 * Function : whalCtrl_Create
 *
 * Input    :
 * Output   :
 * Process  :
 * Note(s)  :  Done
 * -----------------------------------------------------------------------------
 */
TI_HANDLE whalCtrl_Create (TI_HANDLE hOs)
{
    WHAL_CTRL       *pWhalCtrl;
    WlanParams_T    *pWlanParams;
    DmaParams_T     *pDmaParams;

    /* 
    allocate the HAL Ctrl 
    */
    pWhalCtrl = (WHAL_CTRL *)os_memoryAlloc (hOs, sizeof(WHAL_CTRL));
    if (pWhalCtrl == NULL)
    {
        WLAN_OS_REPORT(("whalCtrl_Create: Error memory Allocation\n"));
        return NULL;
    }
    os_memoryZero (hOs, (void *)pWhalCtrl, sizeof(WHAL_CTRL));

    pWhalCtrl->hOs = hOs;
    pWhalCtrl->EncDecEnableFlag = FALSE;
    
    
    /* 
    Create the Params object
    */
    pWhalCtrl->pWhalParams = whal_params_Create (hOs,TRUE);
    if (pWhalCtrl->pWhalParams == NULL)
    {
        WLAN_OS_REPORT(("whalCtrl_Create: Error whal_params_Create\n"));
        whalCtrl_Destroy(pWhalCtrl);
        return NULL;
    }

    /* Initialize the Params object database fields*/
    pWlanParams = whal_ParamsGetWlanParams(pWhalCtrl->pWhalParams);
    pWlanParams->hwAccessMethod = HW_ACCESS_BUS_SLAVE_INDIRECT;
    pWlanParams->maxSitesFragCollect = HAL_CTRL_SITE_FRAG_COLLECT_DEF;
    pWlanParams->RtsThreshold       = HAL_CTRL_RTS_THRESHOLD_DEF; 
    pWlanParams->bJoin              = FALSE;

    /*soft gemini defaults*/
    pWlanParams->SoftGeminiEnable   = SG_DISABLE;
     

    /*becon filter defaults*/
    pWlanParams->beaconFilterParams.desiredState    = FALSE;
    pWlanParams->beaconFilterParams.numOfElements   = DEF_NUM_STORED_FILTERS;
    pWlanParams->beaconFilterIETable.numberOfIEs    = DEF_BEACON_FILTER_IE_TABLE_NUM;
    pWlanParams->beaconFilterIETable.IETableSize        = BEACON_FILTER_IE_TABLE_DEF_SIZE;

    
    /* set the dma params */
    pDmaParams = whal_ParamsGetDmaParams(pWhalCtrl->pWhalParams);
    whal_ParamsSetDmaParams(pWhalCtrl->pWhalParams);
    
    

    /* 
    Configure the hardware control object 
    */
    pWhalCtrl->pHwCtrl = whal_hwCtrl_Create(hOs, pWhalCtrl->pWhalParams);   
    if (pWhalCtrl->pHwCtrl == NULL)
    {
        WLAN_OS_REPORT(("whalCtrl_Create: Error whal_hwCtrl_Create\n"));
        whalCtrl_Destroy(pWhalCtrl);
        return NULL;
    }
    
    /* set the Roaming  params */
    /* Configure  the Low RSSI, the Low SNR and the Missed beacon Defaults */
    whal_ParamsSetRoamingParams(pWhalCtrl->pWhalParams);

    
    /* 
    Create the Security Object
    */
    pWhalCtrl->pWhalSecurity = whalSecur_Create (hOs, pWhalCtrl, pDmaParams->NumStations);

    if (pWhalCtrl->pWhalSecurity == NULL)
    {
        WLAN_OS_REPORT(("whalCtrl_Create: Error whalSecur_Create\n"));
        whalCtrl_Destroy(pWhalCtrl);
        return NULL;
    }
    

    WLAN_INIT_REPORT(("whalCtrl_Create end %x\n",(TI_HANDLE)pWhalCtrl));

    return (pWhalCtrl);
}

/*
 * ----------------------------------------------------------------------------
 * Function : whalCtrl_GetSetHwAddr
 *
 * Input    :
 * Output   :
 * Process  :  Configure the hardware control object
 * Note(s)  :  Done
 * -----------------------------------------------------------------------------
 */
int whalCtrl_GetSetHwAddr (WHAL_CTRL* pWhalCtrl, TI_HANDLE hMemMgr,UINT32 *pFWImage)
{
    int Status;
    UINT32 AcxRegAddr;
    UINT32 AcxMemAddr;

    /*
     * Initiate and get the wlan hardware register and memory addresses
     */
    AcxRegAddr = (UINT32)os_hwGetRegistersAddr(pWhalCtrl->hOs);
    AcxMemAddr = (UINT32)os_hwGetMemoryAddr(pWhalCtrl->hOs);

    /* Get the handle of the Interrupt handler object */
    pWhalCtrl->hWhalBus = whal_hwCtrl_GetBusHandle(pWhalCtrl->pHwCtrl);

    /*
     * Configure wlan hardware control object
     */
    Status = whal_hwCtrl_Config( pWhalCtrl->pHwCtrl,(TI_HANDLE)pWhalCtrl, 
                                 whal_ParamsGetWlanParams(pWhalCtrl->pWhalParams)->hwAccessMethod, 
                                 AcxRegAddr, 
                                 AcxMemAddr, 
                                 pWhalCtrl->hReport, 
                                 hMemMgr, 
                                 pFWImage,

                                 pWhalCtrl->hEventMbox);
    if (Status == TNETWIF_ERROR)
    {
        WLAN_REPORT_ERROR(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,  (" whalCtrl_GetSetHwAddr: whal_hwCtrl_Config failure \n"));
    }
    
    return Status;
}


typedef int (*fcallback_t) (TI_HANDLE);


/*
 * ----------------------------------------------------------------------------
 * Function : whalCtrl_ConfigHwCb2
 *
 * Input    :
 * Output   :
 * Process  :  last configuration call to the low level hal
 * Note(s)  :  Done
 * -----------------------------------------------------------------------------
 */
static int whalCtrl_ConfigHwCb2 (TI_HANDLE hWhalCtrl, TI_STATUS status)
{
    WHAL_CTRL    *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;

    if (status != OK)
    {
        return NOK;
    }

    /* Call the upper layer callback */
    return (*((fcallback_t)pWhalCtrl->fCb)) (pWhalCtrl->hCb);
}


/*
 * ----------------------------------------------------------------------------
 * Function : whalCtrl_ConfigHwCb1
 *
 * Input    :
 * Output   :
 * Process  :  last configuration call to the low level hal
 * Note(s)  :  Done
 * -----------------------------------------------------------------------------
 */
static int whalCtrl_ConfigHwCb1 (TI_HANDLE hWhalCtrl, TI_STATUS status)
{
    WHAL_CTRL    *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
    DmaParams_T  *pDmaParams = whal_ParamsGetDmaParams (pWhalCtrl->pWhalParams);

    /* 
     * Store the addresses of the double buffer (Rx/Tx) 
     * and the path status and control (Tx/Rx) in the corresponding modules
     */
	FwEvent_SetHwInfo (pWhalCtrl->hFwEvent, &(pWhalCtrl->pHwCtrl->DataPathParams));

    txXfer_setHwInfo (pWhalCtrl->hTxXfer, &(pWhalCtrl->pHwCtrl->DataPathParams));    

    txResult_setHwInfo (pWhalCtrl->hTxResult, &(pWhalCtrl->pHwCtrl->DataPathParams));

    rxXfer_SetDoubleBufferAddr (pWhalCtrl->hRxXfer, &(pWhalCtrl->pHwCtrl->DataPathParams)); 

    /* Provide number of HW Tx-blocks and descriptors to Tx-HW-Queue module */
    txHwQueue_setHwInfo (pWhalCtrl->hTxHwQueue, pDmaParams);

  #ifdef TI_DBG
    /* Set the debug trace addresses */
    debugTrace_ConfigHw (pWhalCtrl->hDebugTrace,
                         (UINT32)pWhalCtrl->pHwCtrl->MemMap.debugBuffer1Start,
                         (UINT32)pWhalCtrl->pHwCtrl->MemMap.debugBuffer2Start);
  #endif /* TI_DBG */

    /* 
     * Register all health/sanityCheck/Recovery callbacks 
     * --------------------------------------------------
     *      DeviceError - CORE callback for full recovery
     *      HealthReport - Event Mbox callback for extracting device error
     *      MacStatus - Event Mbox callback for checkHwStatus FCS_ERR, RX_FREE_MEM regs
     *      AciIndication - Event Mbox callback for accumulate SCR_PAD8 image
     *      Mailbox error - Mailbox queue callback for case of timeout/error  
     *      Power control error - PowerMngr callback in case of power ctrl timeout 
     *      Failure event - CORE Callback in case of MailboxError or PowerCtrl error 
     */
  #ifdef USE_RECOVERY
    whalCtrl_RegisterErrorsCallbacks (hWhalCtrl);
  #endif

  #ifdef ROAMING_TRIGGER_DBG
    whalCtrl_dbgRegisterRoamingEventCB (hWhalCtrl);
    whalCtrl_dbgRoamingCommands (hWhalCtrl);
  #endif

    return whal_hwInfoElemMiscTableGet (pWhalCtrl->pHwCtrl->pHwMboxConfig, 
                                        &pWhalCtrl->misc,
                                        (void *)whalCtrl_ConfigHwCb2,
                                        hWhalCtrl);
}


/*
 * ----------------------------------------------------------------------------
 * Function : whalCtrl_ConfigHw
 *
 * Input    :
 * Output   :
 * Process  :  last configuration call to the low level hal
 * Note(s)  :  Done
 * -----------------------------------------------------------------------------
 */
int whalCtrl_ConfigHw 
(
    TI_HANDLE              hWhalCtrl, 
    TnetwDrv_InitParams_t *pInitParams, 
    void                  *fCb,
    TI_HANDLE              hCb
)
{
    WHAL_CTRL       *pWhalCtrl      = (WHAL_CTRL *)hWhalCtrl;
    TxParam_t       *pTxParams      = whal_ParamsGetTxParams (pWhalCtrl->pWhalParams);
    WlanParams_T    *pWlanParams    = whal_ParamsGetWlanParams (pWhalCtrl->pWhalParams);
    UINT8           acID;
    int k = 0;

    pWhalCtrl->fCb = fCb;
    pWhalCtrl->hCb = hCb;
       
    if (NULL != pInitParams)
    {
    /* whalCtrl_init_t */
    pWlanParams->PacketDetectionThreshold   = pInitParams->whalCtrl_init.packetDetectionThreshold;
    pWlanParams->qosNullDataTemplateSize    = pInitParams->whalCtrl_init.qosNullDataTemplateSize;
    pWlanParams->PsPollTemplateSize         = pInitParams->whalCtrl_init.PsPollTemplateSize;
    pWlanParams->probeResponseTemplateSize  = pInitParams->whalCtrl_init.probeResponseTemplateSize;
    pWlanParams->probeRequestTemplateSize   = pInitParams->whalCtrl_init.probeRequestTemplateSize;
    pWlanParams->beaconTemplateSize         = pInitParams->whalCtrl_init.beaconTemplateSize;
    pWlanParams->nullTemplateSize           = pInitParams->whalCtrl_init.nullTemplateSize;
    /* Beacon broadcast options */
    pWlanParams->BcnBrcOptions.BeaconRxTimeout      = pInitParams->whalCtrl_init.BeaconRxTimeout;
    pWlanParams->BcnBrcOptions.BroadcastRxTimeout   = pInitParams->whalCtrl_init.BroadcastRxTimeout;
    pWlanParams->BcnBrcOptions.RxBroadcastInPs      = pInitParams->whalCtrl_init.RxBroadcastInPs;

    pWlanParams->ConsecutivePsPollDeliveryFailureThreshold = 
        pInitParams->whalCtrl_init.ConsecutivePsPollDeliveryFailureThreshold;

    pTxParams->txCompleteTimeout            = pInitParams->whalCtrl_init.txCompleteTimeout;
    pTxParams->txCompleteThreshold          = pInitParams->whalCtrl_init.txCompleteThreshold;
    
    /* halCtrlConfigParams_t */
    pWlanParams->RxEnergyDetection          = pInitParams->halCtrlConfigParams.halCtrlRxEnergyDetection;
    pWlanParams->TxEnergyDetection          = pInitParams->halCtrlConfigParams.halCtrlTxEnergyDetection;
    pWlanParams->ACIMode                    = pInitParams->halCtrlConfigParams.halCtrlACIMode;     
    pWlanParams->inputCCA                   = pInitParams->halCtrlConfigParams.halCtrlInputCCA;    
    pWlanParams->qualifiedCCA               = pInitParams->halCtrlConfigParams.halCtrlQualifiedCCA;
    pWlanParams->stompForRx                 = pInitParams->halCtrlConfigParams.halCtrlStompForRx;  
    pWlanParams->stompForTx                 = pInitParams->halCtrlConfigParams.halCtrlStompForTx;  
    pWlanParams->txCCA                      = pInitParams->halCtrlConfigParams.halCtrlTxCCA;       
    pWlanParams->RxDisableBroadcast         = pInitParams->halCtrlConfigParams.halCtrlRxDisableBroadcast;
    pWlanParams->calibrationChannel2_4      = pInitParams->halCtrlConfigParams.halCtrlCalibrationChannel2_4;
    pWlanParams->calibrationChannel5_0      = pInitParams->halCtrlConfigParams.halCtrlCalibrationChannel5_0;

    /* Not used but need by Palau */
    pWlanParams->RtsThreshold               = pInitParams->halCtrlConfigParams.halCtrlRtsThreshold;
    pWlanParams->CtsToSelf                  = CTS_TO_SELF_DISABLE; 
    
    pWlanParams->WiFiWmmPS 					= pInitParams->halCtrlConfigParams.WiFiWmmPS;

    pWlanParams->MaxTxMsduLifetime          = pInitParams->halCtrlConfigParams.halCtrlMaxTxMsduLifetime;  
    pWlanParams->MaxRxMsduLifetime          = pInitParams->halCtrlConfigParams.halCtrlMaxRxMsduLifetime;  

    pWlanParams->rxTimeOut.psPoll           = pInitParams->halCtrlConfigParams.rxTimeOut.psPoll;  
    pWlanParams->rxTimeOut.UPSD             = pInitParams->halCtrlConfigParams.rxTimeOut.UPSD;  

    /* No used */
    pWlanParams->FragmentThreshold          = pInitParams->halCtrlConfigParams.halCtrlFragThreshold;
    pWlanParams->ListenInterval             = (UINT8)pInitParams->halCtrlConfigParams.halCtrlListenInterval;
    pWlanParams->RateFallback               = pInitParams->halCtrlConfigParams.halCtrlRateFallbackRetry;        
    pWlanParams->MacClock                   = pInitParams->halCtrlConfigParams.halCtrlMacClock;     
    pWlanParams->ArmClock                   = pInitParams->halCtrlConfigParams.halCtrlArmClock;     
    pWlanParams->Enable4x                   = pInitParams->halCtrlConfigParams.halCtrlEnable4x;
    pWlanParams->TxCompleteThreshold        = pInitParams->halCtrlConfigParams.halCtrlTxCompleteThreshold;
    
    /* Configure ARP IP */
    
    pWlanParams->isArpIpFilteringEnabled =  pInitParams->arpIpFilterParams.isFilterEnabled ;
    os_memoryCopy(pWhalCtrl->hOs,(void *)pWlanParams->arp_IP_addr.addr,(void *)pInitParams->arpIpFilterParams.arpIpInitParams.addr , IP_V4_ADDR_LEN) ;
    
    /* Configure address group */
    pWlanParams->numGroupAddrs = pInitParams->macAddrFilterParams.numOfMacAddresses;
    pWlanParams->isMacAddrFilteringnabled = pInitParams->macAddrFilterParams.isFilterEnabled;
    
    for (k = 0; k < pWlanParams->numGroupAddrs; k++)
    {
            os_memoryCopy (pWhalCtrl->hOs,(void*)pWlanParams->Group_addr[k].addr, (void*)pInitParams->macAddrFilterParams.macAddrTable[k].addr, MAC_ADDR_LEN);
    }

    /* Configure beacon timing (early wakeup parmeter) */
    pWlanParams->earlyWakeUp = pInitParams->macPreambleParams.earlyWakeUp;

    /* QoS configure queue */
    for (acID = 0; acID < MAX_NUM_OF_AC; acID++)
    {
        /*
         * Setting ac queues params for AccessCategoryCfg (TNET configuration)
         */
        pWlanParams->acQueuesParams[acID].acId                        = acID;
        pWlanParams->acQueuesParams[acID].qId                         = acID;
        pWlanParams->acQueuesParams[acID].percentOfBlockHighThreshold = pInitParams->whalCtrl_init.TxBlocksHighPercentPerAc[acID];
        pWlanParams->acQueuesParams[acID].percentOfBlockLowThreshold  = pInitParams->whalCtrl_init.TxBlocksLowPercentPerAc[acID];
    }
    }

    /*
     * Configure the WLAN hardware after config all the hardware objects
     */
    if (whal_hwCtrl_ConfigHw (pWhalCtrl->pHwCtrl, (void *)whalCtrl_ConfigHwCb1, hWhalCtrl, FALSE) != OK)
        return NOK;

    return OK;
}


/*
 * ----------------------------------------------------------------------------
 * Function : whalCtrl_Config
 *
 * Input    :
 * Output   :
 * Process  :
 * Note(s)  :  Done
 * -----------------------------------------------------------------------------
 */
TI_STATUS whalCtrl_Config (TI_HANDLE hWhalCtrl,TI_HANDLE hTNETW_Driver, whalCtrl_config_t* pWhalCtrlCfg,UINT32 *pFWImage)
{
    int                 Stt             = OK;

    whalSecur_config_t  securCfg;
    WHAL_CTRL           *pWhalCtrl      = (WHAL_CTRL *)hWhalCtrl;
    WlanParams_T        *pWlanParams    = whal_ParamsGetWlanParams(pWhalCtrl->pWhalParams);
      
    /* Save config parameters */
    pWhalCtrl->hReport = pWhalCtrlCfg->hReport;
    pWhalCtrl->hFwEvent = pWhalCtrlCfg->hFwEvent;
    pWhalCtrl->hRxXfer = pWhalCtrlCfg->hRxXfer;
    pWhalCtrl->hTxXfer = pWhalCtrlCfg->hTxXfer;
    pWhalCtrl->hTxHwQueue = pWhalCtrlCfg->hTxHwQueue;
    pWhalCtrl->hTxResult = pWhalCtrlCfg->hTxResult;
    pWhalCtrl->hTNETW_Driver = hTNETW_Driver;
    pWhalCtrl->hEventMbox = pWhalCtrlCfg->hEventMbox;
    pWhalCtrl->hCmdQueue = pWhalCtrlCfg->hCmdQueue;
#ifdef TI_DBG
    pWhalCtrl->hDebugTrace = pWhalCtrlCfg->hDebugTrace;
#endif /* TI_DBG */
    /* 
    Config the Params object 
    */
    whal_params_Config (pWhalCtrl->pWhalParams, pWhalCtrl->hReport);

    /* 
    Configure the security object
    */
    securCfg.hMemMgr = pWhalCtrlCfg->hMemMgr;
    securCfg.hReport = pWhalCtrl->hReport;
    if (whalSecur_Config (pWhalCtrl->pWhalSecurity, &securCfg) != OK)
    {
        WLAN_REPORT_ERROR (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, ("Error on whalSecur_Config\n"));
    }
    
    /* 
    Initialize the Params object database fields
    */

    pWlanParams->FragmentationOnHal = 0;

#if !defined(GWSI_DRIVER) && !defined(GWSI_LIB)
    /* NO pInitTableCopy in GWSI yet */
    pWlanParams->RecoveryEnable     = 
        ((TnetwDrv_InitParams_t*)(((TnetwDrv_t *)hTNETW_Driver)->pInitTableCopy))->halCtrlConfigParams.halCtrlRecoveryEnable;
#endif /* GWSI_DRIVER */
    
    /* 
    Call local function to configure the hardware control object 
    */
    /* This will at the end call the download function */
    Stt = whalCtrl_GetSetHwAddr(pWhalCtrl, pWhalCtrlCfg->hMemMgr,pFWImage);
    /*  This could return TNETWIF__ERROR,TNETWIF_COMPLETE or TNETWIF_PENDING */
    return (TI_STATUS)Stt;
}


/*
 * ----------------------------------------------------------------------------
 * Function : whalCtrl_GetTnetwifHandle
 *
 * Input    :
 * Output   :
 * Process  :  
 * Note(s)  :  
 * -----------------------------------------------------------------------------
 */
TI_HANDLE whalCtrl_GetTnetwifHandle (TI_HANDLE hWhalCtrl)
{
    WHAL_CTRL  *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;

    return whal_hwCtrl_GetTnentwifHandle (pWhalCtrl->pHwCtrl);
}


/*
 * ----------------------------------------------------------------------------
 * Function : whalCtrl_GetTnetwifHandle
 *
 * Input    :
 * Output   :
 * Process  :  
 * Note(s)  :  
 * -----------------------------------------------------------------------------
 */
TI_HANDLE whalCtrl_GetWhalParams (TI_HANDLE hWhalCtrl)
{
    WHAL_CTRL  *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;

    return (TI_HANDLE)pWhalCtrl->pWhalParams;
}


/****************************************************************************
 *                      whalCtrl_FinalizeDownload()
 ****************************************************************************
 * DESCRIPTION: Finalize all the remaining initialization after the download has finished 
 * 
 * INPUTS:  
 * 
 * OUTPUT:  None
 * 
 * RETURNS: OK or NOK
 ****************************************************************************/
TI_STATUS whalCtrl_FinalizeDownload (TI_HANDLE hWhalCtrl)
{
    WHAL_CTRL  *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;

    /* Call the upper layer to finalize all download action and then send the InitComplete Callback */
#if !defined(GWSI_DRIVER) && !defined(GWSI_LIB)
    return TnetwDrv_InitHw_FinalizeDownload(pWhalCtrl->hTNETW_Driver);
#else
    /* GWSI SA deosn't suport recovery, so the normal finalize function is called directly */
    return TnetwDrv_FinalizeDownload (pWhalCtrl->hTNETW_Driver);
#endif
}


/****************************************************************************
 *                      whalCtrl_FinalizeOnFailure()
 ****************************************************************************
 * DESCRIPTION: Finalize all the remaining initialization after the download has failed 
 * 
 * INPUTS:  
 * 
 * OUTPUT:  None
 * 
 * RETURNS: OK or NOK
 ****************************************************************************/
TI_STATUS whalCtrl_FinalizeOnFailure (TI_HANDLE hWhalCtrl)
{
    WHAL_CTRL  *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;

    /* Call the upper layer to finalize all download */
    return TnetwDrv_FinalizeOnFailure (pWhalCtrl->hTNETW_Driver);
}


/*
 * ----------------------------------------------------------------------------
 * Function : whalCtrl_Register_CB
 *
 * Input    : 
 * Output   :
 * Process  :
 * Note(s)  : 
 * -----------------------------------------------------------------------------
 */
void whalCtrl_Register_CB(TI_HANDLE hWhalCtrl,tiUINT32 CallBackID,void *CBFunc,TI_HANDLE CBObj)
{
    WHAL_CTRL* pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;

    WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, ("whalCtrl_Register_CB (Value = 0x%x)\n", CallBackID));

    switch(CallBackID)
    {
    case HAL_INTERNAL_EVENT_FAILURE:
        pWhalCtrl->FailureEvent_CB        = (failureEventCB_t)CBFunc;
        pWhalCtrl->FailureEvent_CB_handle = CBObj;
        /* Register all health/sanityCheck/Recovery callbacks 
                DeviceError - CORE callback for full recovery
                HealthReport - Event Mbox callback for extracting device error
                MacStatus - Event Mbox callback for checkHwStatus FCS_ERR, RX_FREE_MEM regs
                Mailbox error - Mailbox queue callback for case of timeout/error */
      #ifdef USE_RECOVERY
        whalCtrl_RegisterErrorsCallbacks(hWhalCtrl);
      #else
        CmdQueue_RegisterForErrorCB(pWhalCtrl->hCmdQueue, CBFunc, CBObj);
      #endif 
        break;
    case HAL_INT_COMMAND_COMPLETE:
        whalCtrl_RegisterCmdCompleteGenericCB(hWhalCtrl,CBFunc,CBObj);      
        break;
    default:
        /* register to the Event MBOX the corresponding Callback */
        whalCtrl_EventMbox_RegisterForEvent(hWhalCtrl, (int)(CallBackID), CBFunc, CBObj);
        whalCtrl_EventMbox_Enable(hWhalCtrl, (int)(CallBackID));
    }
    
    return;
}


/*
 * ----------------------------------------------------------------------------
 * Function : whalCtrl_PreRecoveryProcess
 *
 * Input    : TI_HANDLE hWhalCtrl
 * Output   :
 * Process  : prepare for recovery - save all mbox callbacks
 * Note(s)  : 
 * -----------------------------------------------------------------------------
 */

void whalCtrl_PreRecoveryProcess(TI_HANDLE hWhalCtrl)
{
    WHAL_CTRL* pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
    
    CmdQueue_StartReconfig( pWhalCtrl->hCmdQueue );
}


/*
 * ----------------------------------------------------------------------------
 * Function : whalCtrl_SetMacAddress
 *
 * Input    :
 * Output   :
 * Process  :
 * Note(s)  :  Done
 * -----------------------------------------------------------------------------
 */
int whalCtrl_SetMacAddress(TI_HANDLE hWhalCtrl, macAddress_t *macAddr)
{
    WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;  

    return whal_hwCtrl_SetMacAddress(pWhalCtrl->pHwCtrl, macAddr);
}

/*
 * ----------------------------------------------------------------------------
 * Function : whalCtrl_SetParam
 *
 * Input    :
 * Output   :
 * Process  :
 * Note(s)  :  Done
 * -----------------------------------------------------------------------------
 */
TI_STATUS whalCtrl_SetParam (TI_HANDLE hWhalCtrl, whalParamInfo_t* pParamInfo)
{
    WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
    HwMboxConfig_T *pInfoElemConfig = whal_hwCtrl_GetMboxConfig(pWhalCtrl->pHwCtrl);
    WlanParams_T *pWlanParams = &pWhalCtrl->pWhalParams->WlanParams;
    TxParam_t    *pTxParams = whal_ParamsGetTxParams(pWhalCtrl->pWhalParams);


    WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
                             ("whalCtrl_SetParam : paramType=0x%X\n", pParamInfo->paramType));
    
    switch ((externalParam_e)pParamInfo->paramType)
    {
        case HAL_CTRL_RTS_THRESHOLD_PARAM:

            if  (pParamInfo->content.halCtrlRtsThreshold > HAL_CTRL_RTS_THRESHOLD_MAX)
            {
                WLAN_REPORT_ERROR(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,  (" whalCtrl########HAL_CTRL_RTS_THRESHOLD_PARAM: Value out of permitted range 0x%x\n",
                       pParamInfo->content.halCtrlRtsThreshold));
                return (PARAM_VALUE_NOT_VALID);
            }

            if (whal_hwInfoElemRtsThresholdSet (pInfoElemConfig,pParamInfo->content.halCtrlRtsThreshold) == OK)
            {
                WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,  (" whalCtrl########HAL_CTRL_RTS_THRESHOLD_PARAM 0x%x\n",
                                       pParamInfo->content.halCtrlRtsThreshold));
                pWlanParams->RtsThreshold = pParamInfo->content.halCtrlRtsThreshold;
            }


            break;

        case HAL_CTRL_CTS_TO_SELF_PARAM:

            if (whal_hwInfoElemCtsToSelfSet (pInfoElemConfig, pParamInfo->content.halCtrlCtsToSelf) == OK)
                pWlanParams->CtsToSelf = pParamInfo->content.halCtrlCtsToSelf;
        else
            return NOK;

            break;

        case HAL_CTRL_RX_TIME_OUT_PARAM:

            if (whal_hwInfoElemRxTimeOutSet (pInfoElemConfig, &pParamInfo->content.halCtrlRxTimeOut) == OK)
            {
                pWlanParams->rxTimeOut.psPoll = pParamInfo->content.halCtrlRxTimeOut.psPoll;
                pWlanParams->rxTimeOut.UPSD   = pParamInfo->content.halCtrlRxTimeOut.UPSD;  
            }
            break;


        case HAL_CTRL_FRAG_THRESHOLD_PARAM:
            if ((pParamInfo->content.halCtrlFragThreshold < HAL_CTRL_FRAG_THRESHOLD_MIN) ||
                (pParamInfo->content.halCtrlFragThreshold > HAL_CTRL_FRAG_THRESHOLD_MAX))
                return (PARAM_VALUE_NOT_VALID);

            pWlanParams->FragmentThreshold  = pParamInfo->content.halCtrlFragThreshold;
            pWlanParams->FragmentationOnHal = 0;
            break;
            
    case HAL_CTRL_DOT11_MAX_RX_MSDU_LIFE_TIME:
            if (whal_hwInfoElemRxMsduLifeTimeSet (pInfoElemConfig, pParamInfo->content.halCtrlMaxRxMsduLifetime) == OK)
               pWlanParams->MaxRxMsduLifetime = (UINT32)pParamInfo->content.halCtrlMaxRxMsduLifetime;
            break;
        
            case HAL_CTRL_ACX_STATISTICS_PARAM:
            if (whal_hwInfoElemAcxStatisiticsSet (pInfoElemConfig) != OK)
                return (NOK);
            break;
        
        case HAL_CTRL_LISTEN_INTERVAL_PARAM:
            if ((pParamInfo->content.halCtrlListenInterval < HAL_CTRL_LISTEN_INTERVAL_MIN) ||
                (pParamInfo->content.halCtrlListenInterval > HAL_CTRL_LISTEN_INTERVAL_MAX))
                return (PARAM_VALUE_NOT_VALID);

            pWlanParams->ListenInterval = (UINT8)pParamInfo->content.halCtrlListenInterval;
            break;
                            
        case HAL_CTRL_AID_PARAM:
            pWlanParams->Aid = pParamInfo->content.halCtrlAid;
            
            /* Configure the ACXAID info element*/
            if (whal_hwCtrl_AidSet (pWhalCtrl->pHwCtrl, pParamInfo->content.halCtrlAid) != OK)
               return (NOK);
            break;

        case HAL_CTRL_RSN_HW_ENC_DEC_ENABLE_PARAM:

            WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
                                    (" whalCtrl########HW_ENC_DEC_ENABLE %d\n", pParamInfo->content.rsnHwEncDecrEnable));
            
            /* Set the Encryption/Decryption on the HW*/
            if (whalSecur_HwEncDecrEnable (pWhalCtrl->pWhalSecurity, pParamInfo->content.rsnHwEncDecrEnable) != OK)
                return (NOK);
            break;

        case HAL_CTRL_RSN_KEY_ADD_PARAM:

            WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,  (" whalCtrl########KEY_ADD\n"));
            
            if (whalSecur_KeyAdd (pWhalCtrl->pWhalSecurity,
                                 (securityKeys_t *) pParamInfo->content.configureCmdCBParams.CB_buf,
                                 FALSE,
                                 pParamInfo->content.configureCmdCBParams.CB_Func, 
                                 pParamInfo->content.configureCmdCBParams.CB_handle) != OK)
                return (NOK);
            break;

        case HAL_CTRL_RSN_KEY_REMOVE_PARAM:
    
            WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,  (" whalCtrl########KEY_REMOVE\n"));
    
            if (whalSecur_KeyRemove (pWhalCtrl->pWhalSecurity, 
                                    (securityKeys_t *) pParamInfo->content.configureCmdCBParams.CB_buf,
                                    FALSE,
                                    pParamInfo->content.configureCmdCBParams.CB_Func, 
                                    pParamInfo->content.configureCmdCBParams.CB_handle) != OK)
                return (NOK);
            break;

        case HAL_CTRL_RSN_DEFAULT_KEY_ID_PARAM:
            if ((int) *pParamInfo->content.configureCmdCBParams.CB_buf > MAX_DEFAULT_KEY_ID)
                return (PARAM_VALUE_NOT_VALID);

            WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,  (" whalCtrl########DEFAULT_KEY_ID %d\n",
                                   (UINT8)pParamInfo->content.rsnDefaultKeyID));
            
            if (whalSecur_DefaultKeyIdSet(pWhalCtrl->pWhalSecurity,
                                 *pParamInfo->content.interogateCmdCBParams.CB_buf,
                                 pParamInfo->content.interogateCmdCBParams.CB_Func, 
                                 pParamInfo->content.interogateCmdCBParams.CB_handle) != OK)
                return (NOK);

            break;

        case HAL_CTRL_RSN_SECURITY_MODE_PARAM:
            WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
                                    (" whalCtrl########SECURITY_MODE_SET %d\n", pParamInfo->content.rsnEncryptionStatus));
            if (whalSecur_SecurModeSet (pWhalCtrl->pWhalSecurity, (cipherSuite_e)pParamInfo->content.rsnEncryptionStatus) != OK)
                return (NOK);
            break;

#ifdef EXC_MODULE_INCLUDED
        case HAL_CTRL_RSN_EXC_SW_ENC_ENABLE_PARAM:
            WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
                                    (" whalCtrl########EXC_SW_ENC_ENABLE %d\n", pParamInfo->content.rsnExcSwEncFlag));
#ifdef CKIP_ENABLED
            if (whalSecur_SwEncEnable (pWhalCtrl->pWhalSecurity, pParamInfo->content.rsnExcSwEncFlag) != OK)
                return (NOK);
#endif
            /* when SW encryption is ON, HW encryption should be turned OFF and vice versa */
            
            WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
                                    (" whalCtrl: Set HwEncDecrEnable to %d\n", !pParamInfo->content.rsnExcSwEncFlag));
                
            /* Set the Encryption/Decryption on the HW*/
            if (whalSecur_HwEncDecrEnable (pWhalCtrl->pWhalSecurity, (BOOL)(!(pParamInfo->content.rsnExcSwEncFlag))) != OK)
                return (NOK);
            break;

        case HAL_CTRL_RSN_EXC_MIC_FIELD_ENABLE_PARAM:
            WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
                                    (" whalCtrl########EXC_MIC_FIELD_ENABLE %d\n", pParamInfo->content.rsnExcMicFieldFlag));
#ifdef CKIP_ENABLED
            if (whalSecur_MicFieldEnable (pWhalCtrl->pWhalSecurity, pParamInfo->content.rsnExcMicFieldFlag) != OK)
                return (NOK);
#endif
            break;
#endif /* EXC_MODULE_INCLUDED*/

        case HAL_CTRL_TX_POWER_PARAM:
            
            WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
                                    (" whalCtrl########TX_POWER_LEVEL old = %d new = %d\n", 
									pTxParams->TxPowerDbm, pParamInfo->content.halCtrlTxPowerDbm));

			if ( pTxParams->TxPowerDbm == pParamInfo->content.halCtrlTxPowerDbm)
			{	/* Save up time if we set the same value */
				return TX_POWER_SET_SAME_VALUE;
			}

            pTxParams->TxPowerDbm = pParamInfo->content.halCtrlTxPowerDbm;
            
            /* configure the wlan hardware */
            if (whal_hwInfoElemTxPowerSet (pInfoElemConfig,
                                                &pTxParams->TxPowerDbm) != OK)
                return (NOK);
            break;


        case HAL_CTRL_SG_ENABLE_PARAM:
            return (TI_STATUS)whal_hwCtrl_SoftGeminiEnable(pWhalCtrl->pHwCtrl,(SoftGeminiEnableModes_e)pParamInfo->content.SoftGeminiEnable);

        case HAL_CTRL_SG_CONFIG_PARAM:
            return (TI_STATUS)whal_hwCtrl_SetSoftGeminiParams(pWhalCtrl->pHwCtrl,&(pParamInfo->content.SoftGeminiParam));

        case HAL_CTRL_ANTENNA_DIVERSITY_PARAMS:
            /* save parameters */
            whal_hwCtrl_SaveAntennaDiversityOptions (pWhalCtrl->pHwCtrl, &(pParamInfo->content.antennaDiversityOptions));
            /* Configure FW with new parameters */
            whal_hwCtrl_CurrentAntennaDiversitySendCmd (pWhalCtrl->pHwCtrl);
            break;

        case HAL_CTRL_TX_ANTENNA_PARAM:
            /* save antenna number */
            whal_hwCtrl_SetTxAntenna( pWhalCtrl->pHwCtrl, pParamInfo->content.antennaNum );
            /* Write parameters to FW */
            whal_hwCtrl_CurrentAntennaDiversitySendCmd( pWhalCtrl->pHwCtrl );
            break;

        case HAL_CTRL_RX_ANTENNA_PARAM:
            /* save antenna number */
            whal_hwCtrl_SetRxAntenna( pWhalCtrl->pHwCtrl, pParamInfo->content.antennaNum );
            /* Write parameters to FW */
            whal_hwCtrl_CurrentAntennaDiversitySendCmd( pWhalCtrl->pHwCtrl );
            break;

    /*
     *  TX Parameters 
     */ 

    case HAL_CTRL_TX_RATE_CLASS_PARAMS:
        return (TI_STATUS)whal_hwCtrl_TxRatePolicy(pWhalCtrl->pHwCtrl,pParamInfo->content.pTxRatePlicy);
/*      break; */

    case HAL_CTRL_QUEUES_PARAMS:
        os_memoryCopy (pWhalCtrl->hOs, &pWhalCtrl->pWhalParams->WlanParams.QtrafficParams,
                       pParamInfo->content.pQueueTrafficParams, sizeof(queueTrafficParams_t));

        return (TI_STATUS)whal_hwCtrl_TrafficConf(pWhalCtrl->pHwCtrl,pParamInfo->content.pQueueTrafficParams);
/*      break; */

    case HAL_CTRL_AC_PARAMS:
        os_memoryCopy (pWhalCtrl->hOs, &pWhalCtrl->pWhalParams->WlanParams.acQosParams,
                       pParamInfo->content.configureCmdCBParams.CB_buf, sizeof(acQosParams_t));
        return (TI_STATUS)whal_hwCtrl_AcParamsConf(pWhalCtrl->pHwCtrl,&pParamInfo->content.configureCmdCBParams);
/*      break; */

        
    
#if 0

    /*Tx Ack/No Ack*/
    case HAL_CTRL_TX_ACK_POLICY:
            return (whal_ParamsSetAccessCategoryAckPolicy(pWhalCtrl->pWhalParams, 
                                                          pParamInfo->content.AcAckPolicy.AckPolicy,
                                                          pParamInfo->content.AcAckPolicy.AcId));
            break;

#endif

    case HAL_CTRL_MIN_POWER_LEVEL:
        whalCtrl_SetMinPowerLevel(pWhalCtrl,
                                    pParamInfo->content.minPowerPolicy);
            break;

    
    case HAL_CTRL_CLK_RUN_ENABLE:
        WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
                                (" whalCtrl_SetParam: CLK_RUN_ENABLE %d\n", pParamInfo->content.halCtrlClkRunEnable));

        /* Set the Encryption/Decryption on the HW*/
        if (whal_hwCtrl_ClkRunEnableSet (pWhalCtrl->pHwCtrl, pParamInfo->content.halCtrlClkRunEnable) != OK)
            return (NOK);
        break;

    case HAL_CTRL_EARLY_WAKEUP:
        WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
                                (" whalCtrl_SetParam: SET EARLY WAKEUP to %d\n", pParamInfo->content.earlyWakeup));
        pWlanParams->earlyWakeUp = pParamInfo->content.earlyWakeup;
        break;

        /* PLT params */    
    case HAL_CTRL_PLT_WRITE_MIB:
        WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,  ("%s - HAL_CTRL_PLT_WRITE_MIB(0x%x) \n", __FUNCTION__, pParamInfo->paramType));
        return (TI_STATUS)whalCtrl_WriteMib(hWhalCtrl, &pParamInfo->content.PltMib);
        
/*        break; */
        
    case HAL_CTRL_PLT_RX_PER_START:
        WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,  ("%s - HAL_CTRL_PLT_RX_PER_START(0x%x) \n", __FUNCTION__, pParamInfo->paramType));
        return (TI_STATUS)whalCtrl_RxPER(pWhalCtrl, PLT_RX_PER_START, 
            pParamInfo->content.interogateCmdCBParams.CB_handle, 
            pParamInfo->content.interogateCmdCBParams.CB_Func);            
/*        break; */
        
    case HAL_CTRL_PLT_RX_PER_STOP:
        WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,  ("%s - HAL_CTRL_PLT_RX_PER_STOP(0x%x) \n", __FUNCTION__, pParamInfo->paramType));
        return (TI_STATUS)whalCtrl_RxPER(pWhalCtrl, PLT_RX_PER_STOP, 
            pParamInfo->content.interogateCmdCBParams.CB_handle, 
            pParamInfo->content.interogateCmdCBParams.CB_Func);            
/*        break; */
        
    case HAL_CTRL_PLT_RX_PER_CLEAR:
        WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,  ("%s - HAL_CTRL_PLT_RX_PER_CLEAR(0x%x) \n", __FUNCTION__, pParamInfo->paramType));
        return (TI_STATUS)whalCtrl_RxPER(pWhalCtrl, PLT_RX_PER_CLEAR, 
            pParamInfo->content.interogateCmdCBParams.CB_handle, 
            pParamInfo->content.interogateCmdCBParams.CB_Func);            
/*        break; */
    case HAL_CTRL_PLT_TX_CW:
        WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,  ("%s - HAL_CTRL_PLT_TX_CW(0x%x) \n", __FUNCTION__, pParamInfo->paramType));
        return (TI_STATUS)whalCtrl_TxCW(pWhalCtrl, &pParamInfo->content.PltCW,
                                NULL, NULL, NULL);
        /*break;*/
        
    case HAL_CTRL_PLT_TX_CONTINUES:
        WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,  ("%s - HAL_CTRL_PLT_TX_CONTINUES(0x%x) \n", __FUNCTION__, pParamInfo->paramType));
        return (TI_STATUS)whalCtrl_TxContinues(pWhalCtrl, &pParamInfo->content.PltTxContinues,
                                    NULL, NULL, NULL);
        /*break;*/

    case HAL_CTRL_PLT_TX_STOP:
        WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,  ("%s - HAL_CTRL_PLT_TX_STOP(0x%x) \n", __FUNCTION__, pParamInfo->paramType));
        return (TI_STATUS)whal_hwCmdBit_perTxStop(pWhalCtrl->pHwCtrl->pHwMboxCmdBit, 
                                       NULL, NULL, NULL);
        /*break;*/
        
    case HAL_CTRL_PLT_WRITE_REGISTER:
        WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,  ("%s - HAL_CTRL_PLT_WRITE_REGISTER(0x%x) \n", __FUNCTION__, pParamInfo->paramType));
        return (TI_STATUS)whalCtrl_WriteRegister(pWhalCtrl, pParamInfo->content.interogateCmdCBParams.CB_handle, pParamInfo->content.interogateCmdCBParams.CB_Func, pParamInfo->content.interogateCmdCBParams.CB_buf);
/*        break;  */
        
    default:
        WLAN_REPORT_ERROR(pWhalCtrl->hReport,
                      HAL_CTRL_MODULE_LOG,
                      ("%s(%d) - whalCtrl_SetParam - ERROR - Param is not supported, %d\n\n",
                       __FILE__,__LINE__,pParamInfo->paramType));
        return (PARAM_NOT_SUPPORTED);
    }
    
    return (OK);
}


/*
 * ----------------------------------------------------------------------------
 * Function : whalCtrl_GetParam
 *
 * Input    :
 * Output   :
 * Process  :
 * Note(s)  :  Done
 * -----------------------------------------------------------------------------
 */
TI_STATUS whalCtrl_GetParam (TI_HANDLE hWhalCtrl, whalParamInfo_t* pParamInfo)
{
    WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
    WlanParams_T *pWlanParams = &pWhalCtrl->pWhalParams->WlanParams;
    HwMboxConfig_T *pInfoElemConfig = whal_hwCtrl_GetMboxConfig(pWhalCtrl->pHwCtrl);
    TxParam_t      *pTxParams = whal_ParamsGetTxParams(pWhalCtrl->pWhalParams);

    switch ((externalParam_e)pParamInfo->paramType)
    {
        case HAL_CTRL_RTS_THRESHOLD_PARAM:
            pParamInfo->content.halCtrlRtsThreshold = pWlanParams->RtsThreshold;
            break;
        
        case HAL_CTRL_FRAG_THRESHOLD_PARAM:
            pParamInfo->content.halCtrlFragThreshold = pWlanParams->FragmentThreshold;
            break;

        case HAL_CTRL_COUNTERS_PARAM:
            /* Constant zero because the ACX last buffer next pointer is always pointed
               to itself, so it's like an endless buffer*/
            pParamInfo->content.halCtrlCounters.RecvNoBuffer = 0;
            pParamInfo->content.halCtrlCounters.FragmentsRecv = 0; /* not supported;*/
            pParamInfo->content.halCtrlCounters.FrameDuplicates = 0;/* not supported*/
            pParamInfo->content.halCtrlCounters.FcsErrors = pWhalCtrl->pWhalParams->GenCounters.FcsErrCnt;
            pParamInfo->content.halCtrlCounters.RecvError = pWhalCtrl->pWhalParams->GenCounters.FcsErrCnt;
            break;
        
        case HAL_CTRL_LISTEN_INTERVAL_PARAM:
            pParamInfo->content.halCtrlListenInterval = pWlanParams->ListenInterval;
            break;
                            
        case HAL_CTRL_RSN_DEFAULT_KEY_ID_PARAM:
            /* Not implemented */
            return NOK;
/*            break; */

        case HAL_CTRL_TX_POWER_PARAM:
            pParamInfo->content.halCtrlTxPowerDbm = pTxParams->TxPowerDbm;
            break;
        
        case HAL_CTRL_ACX_STATISTICS_PARAM:
            /* Not implemented */
         #if 0
            {
                acxStatisitcs_t     acxStatisitics;
                pParamInfo->content.acxStatisitics.FWpacketReceived = acxStatisitics.FWpacketReceived;
                /* Not supported */
                pParamInfo->content.acxStatisitics.HALpacketReceived = 0; 
            }
         #endif
            return NOK;

        case HAL_CTRL_MEDIUM_OCCUPANCY_PARAM:
            if (whal_hwInfoElemMediumOccupancyGet (pInfoElemConfig,
                                                   pParamInfo->content.interogateCmdCBParams) != OK)
                return (NOK);

            break;

        case HAL_CTRL_TSF_DTIM_MIB:
            if (whal_hwInfoElemTfsDtimGet(pInfoElemConfig,
                                          pParamInfo->content.interogateCmdCBParams) != OK)
                return (NOK);
            
            break;


    case HAL_CTRL_AID_PARAM:
        if (whal_hwCtrl_CurrentAssociationIdGet(pWhalCtrl->pHwCtrl,
                                     &(pParamInfo->content.halCtrlAid)) != OK)
            return (NOK);

        WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
                                (" AID 2 %d\n", pParamInfo->content.halCtrlAid));


        break;

    case HAL_CTRL_NOISE_HISTOGRAM_PARAM:
        if (whal_hwInfoElemNoiseHistogramResultsGet (pInfoElemConfig,
                                                     pParamInfo->content.interogateCmdCBParams) != OK)
        {
            return (NOK);
        }

        break;

    case HAL_CTRL_TX_ANTENNA_PARAM:
        /* get antenna number */
        whal_hwCtrl_GetTxAntenna( pWhalCtrl->pHwCtrl, &(pParamInfo->content.antennaNum) );
        break;

    case HAL_CTRL_RX_ANTENNA_PARAM:
        /* get antenna number */
        whal_hwCtrl_GetRxAntenna( pWhalCtrl->pHwCtrl, &(pParamInfo->content.antennaNum) );
        break;

    case HAL_CTRL_CURRENT_CHANNEL:
        /* get current channel number */
        pParamInfo->content.halCtrlCurrentChannel = whal_ParamsGetRadioChannel( pWhalCtrl->pWhalParams );

    case HAL_CTRL_MIN_POWER_LEVEL:
        whalCtrl_GetMinPowerLevel(pWhalCtrl, &pParamInfo->content.minPowerPolicy);
        break;

        /*SNR and RSSI belongs to the same MIB, and the relevant CB is passed here*/
    case HAL_CTRL_RSSI_LEVEL_PARAM:
    case HAL_CTRL_SNR_RATIO_PARAM:
        /* Retrive the Callback function and read buffer pointer that are in fact stored in the TIWLAN_ADAPTER and then send it to the Command Mailbox */
        whalCtrl_GetAsynRSSI (pWhalCtrl,pParamInfo->content.interogateCmdCBParams.CB_Func, pParamInfo->content.interogateCmdCBParams.CB_handle , pParamInfo->content.interogateCmdCBParams.CB_buf);
        break;

    case HAL_CTRL_BCN_BRC_OPTIONS:
        pParamInfo->content.BcnBrcOptions.BeaconRxTimeout    = pWlanParams->BcnBrcOptions.BeaconRxTimeout;
        pParamInfo->content.BcnBrcOptions.BroadcastRxTimeout = pWlanParams->BcnBrcOptions.BroadcastRxTimeout;
        pParamInfo->content.BcnBrcOptions.RxBroadcastInPs    = pWlanParams->BcnBrcOptions.RxBroadcastInPs;
        break;

    case HAL_CTRL_DOT11_MAX_RX_MSDU_LIFE_TIME:
        pParamInfo->content.halCtrlMaxRxMsduLifetime = pWlanParams->MaxRxMsduLifetime;
        break;
        
        
        /* PLT params */    
    case HAL_CTRL_PLT_RX_PER_GET_RESULTS:
        return (TI_STATUS)whalCtrl_RxPER(pWhalCtrl, PLT_RX_PER_GETRESULTS, 
            pParamInfo->content.interogateCmdCBParams.CB_handle, 
            pParamInfo->content.interogateCmdCBParams.CB_Func);            
/*        break; */
        
    case HAL_CTRL_PLT_READ_MIB:
        return (TI_STATUS)whalCtrl_ReadMib(pWhalCtrl, 
            pParamInfo->content.interogateCmdCBParams.CB_handle,
            pParamInfo->content.interogateCmdCBParams.CB_Func, 
            pParamInfo->content.interogateCmdCBParams.CB_buf);
        
/*        break; */
        
    case HAL_CTRL_PLT_READ_REGISTER:        
        whalCtrl_ReadRegister(pWhalCtrl, pParamInfo->content.interogateCmdCBParams.CB_handle,
            pParamInfo->content.interogateCmdCBParams.CB_Func, 
            pParamInfo->content.interogateCmdCBParams.CB_buf);
        break;

    case HAL_CTRL_PLT_RX_TX_CAL:
         WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,  ("%s - HAL_CTRL_PLT_RX_TX_CAL(0x%x) \n", __FUNCTION__, pParamInfo->paramType));         
         return (TI_STATUS)whal_hwCmdBit_TestCmd(pWhalCtrl->pHwCtrl->pHwMboxCmdBit,                                       
                                      pParamInfo->content.interogateCmdCBParams.CB_Func, 
                                      pParamInfo->content.interogateCmdCBParams.CB_handle,
                                      (TestCmd_t*)pParamInfo->content.interogateCmdCBParams.CB_buf);
         /*break*/

    case HAL_CTRL_PLT_RX_CAL_STATUS:
         whal_hwCmdBit_GetPltRxCalibrationStatus( pWhalCtrl->pHwCtrl->pHwMboxCmdBit, 
                                                  &(pParamInfo->content.PltRxCalibrationStatus) );
         return OK;
         /* break */

    case HAL_CTRL_CTS_TO_SELF_PARAM:
        pParamInfo->content.halCtrlCtsToSelf = pWlanParams->CtsToSelf;        
        break;

    case HAL_CTRL_TX_RATE_CLASS_PARAMS:
        pParamInfo->content.pTxRatePlicy …

Large files files are truncated, but you can click here to view the full file