| /* |
| * SoftGemini.c |
| * |
| * Copyright(c) 1998 - 2009 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. |
| */ |
| |
| /** \file softGemini.c |
| * \brief BlueTooth-Wlan coexistence module interface |
| * |
| * \see softGemini.h |
| */ |
| |
| /**************************************************************************************************** |
| * * |
| * MODULE: softGemini.c * |
| * PURPOSE: BlueTooth-Wlan coexistence module interface. * |
| * This module handles all data base (and Fw setting accordingly) * |
| * for Bluetooth-Wlan coexistence implementation. * |
| * * |
| ****************************************************************************************************/ |
| |
| #define __FILE_ID__ FILE_ID_5 |
| #include "report.h" |
| #include "osApi.h" |
| #include "SoftGemini.h" |
| #include "DataCtrl_Api.h" |
| #include "scrApi.h" |
| #include "PowerMgr_API.h" |
| #include "ScanCncn.h" |
| #include "currBss.h" |
| #include "CmdDispatcher.h" |
| #include "TWDriver.h" |
| #include "DrvMainModules.h" |
| #include "bssTypes.h" |
| #include "sme.h" |
| |
| |
| #define SENSE_MODE_ENABLE 0x01 |
| #define SENSE_MODE_DISABLE 0x00 |
| #define PROTECTIVE_MODE_ON 0x01 |
| #define PROTECTIVE_MODE_OFF 0x00 |
| |
| /********************************************************************************/ |
| /* Internal functions prototypes. */ |
| /********************************************************************************/ |
| |
| static TI_STATUS SoftGemini_setEnableParam(TI_HANDLE hSoftGemini, ESoftGeminiEnableModes SoftGeminiEnable, TI_BOOL recovery); |
| static TI_STATUS SoftGemini_setParamsToFW(TI_HANDLE hSoftGemini, TSoftGeminiParams *SoftGeminiParam); |
| static TI_STATUS SoftGemini_EnableDriver(TI_HANDLE hSoftGemini); |
| static TI_STATUS SoftGemini_DisableDriver(TI_HANDLE hSoftGemini); |
| static TI_STATUS SoftGemini_SetPS(SoftGemini_t *pSoftGemini); |
| static TI_STATUS SoftGemini_unSetPS(SoftGemini_t *pSoftGemini); |
| static void SoftGemini_RemoveProtectiveModeParameters(TI_HANDLE hSoftGemini); |
| static void SoftGemini_setConfigParam(TI_HANDLE hSoftGemini, TI_UINT32 *param); |
| static void SoftGemini_EnableProtectiveMode(TI_HANDLE hSoftGemini); |
| static void SoftGemini_DisableProtectiveMode(TI_HANDLE hSoftGemini); |
| #ifdef REPORT_LOG |
| static char* SoftGemini_ConvertModeToString(ESoftGeminiEnableModes SoftGeminiEnable); |
| #endif |
| |
| /********************************************************************************/ |
| /* Interface functions Implementation. */ |
| /********************************************************************************/ |
| /************************************************************************ |
| * SoftGemini_SetPSmode * |
| ************************************************************************ |
| DESCRIPTION: SoftGemini module, called by the conn_Infra on connection |
| performs the following: |
| - Enables SG if needed |
| - Enables the SG power mode |
| INPUT: hSoftGemini - Handle to SoftGemini |
| |
| OUTPUT: |
| |
| RETURN: |
| |
| ************************************************************************/ |
| void SoftGemini_SetPSmode(TI_HANDLE hSoftGemini) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| |
| if (pSoftGemini) |
| { |
| if (pSoftGemini->bDriverEnabled) |
| { |
| /* Check if coexAutoPsMode is enabled to enter/exit P.S */ |
| if ( pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_AUTO_PS_MODE]) |
| { |
| SoftGemini_SetPS(pSoftGemini); |
| } |
| } |
| if (pSoftGemini->bProtectiveMode) |
| { |
| SoftGemini_EnableProtectiveMode(hSoftGemini); |
| } |
| } |
| else |
| { |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_ERROR, " SoftGemini_SetPSmode() - Error hSoftGemini= NULL \n"); |
| } |
| } |
| |
| /************************************************************************ |
| * SoftGemini_unSetPSmode * |
| ************************************************************************ |
| DESCRIPTION: SoftGemini module, called by the conn_Infra after disconnecting |
| performs the following: |
| - Disables the SG |
| - Disables the SG power mode |
| INPUT: hSoftGemini - Handle to SoftGemini |
| |
| OUTPUT: |
| |
| RETURN: |
| |
| ************************************************************************/ |
| void SoftGemini_unSetPSmode(TI_HANDLE hSoftGemini) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| |
| if (pSoftGemini) |
| { |
| if (pSoftGemini->bDriverEnabled) |
| { |
| /* Check if coexAutoPsMode is enabled to enter/exit P.S */ |
| if ( pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_AUTO_PS_MODE]) |
| { |
| SoftGemini_unSetPS(pSoftGemini); |
| } |
| } |
| if (pSoftGemini->bProtectiveMode) |
| { |
| SoftGemini_RemoveProtectiveModeParameters(hSoftGemini); |
| } |
| } |
| else |
| { |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_ERROR, " SoftGemini_unSetPSmode() - Error hSoftGemini= NULL \n"); |
| } |
| } |
| |
| /************************************************************************ |
| * SoftGemini_create * |
| ************************************************************************ |
| DESCRIPTION: SoftGemini module creation function, called by the config mgr in creation phase |
| performs the following: |
| - Allocate the SoftGemini handle |
| |
| INPUT: hOs - Handle to OS |
| |
| |
| OUTPUT: |
| |
| RETURN: Handle to the SoftGemini module on success, NULL otherwise |
| |
| ************************************************************************/ |
| TI_HANDLE SoftGemini_create(TI_HANDLE hOs) |
| { |
| SoftGemini_t *pSoftGemini = NULL; |
| |
| /* allocating the SoftGemini object */ |
| pSoftGemini = os_memoryAlloc(hOs,sizeof(SoftGemini_t)); |
| |
| if (pSoftGemini == NULL) |
| return NULL; |
| |
| pSoftGemini->hOs = hOs; |
| |
| return pSoftGemini; |
| } |
| |
| /************************************************************************ |
| * SoftGemini_config * |
| ************************************************************************ |
| DESCRIPTION: SoftGemini module init function, called by the rvMain in init phase |
| performs the following: |
| - Init local variables |
| - Init the handles to be used by the module |
| |
| INPUT: pStadHandles - The driver modules handles |
| |
| OUTPUT: |
| |
| RETURN: void |
| ************************************************************************/ |
| void SoftGemini_init (TStadHandlesList *pStadHandles) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)(pStadHandles->hSoftGemini); |
| |
| pSoftGemini->hCtrlData = pStadHandles->hCtrlData; |
| pSoftGemini->hTWD = pStadHandles->hTWD; |
| pSoftGemini->hReport = pStadHandles->hReport; |
| pSoftGemini->hSCR = pStadHandles->hSCR; |
| pSoftGemini->hPowerMgr = pStadHandles->hPowerMgr; |
| pSoftGemini->hCmdDispatch = pStadHandles->hCmdDispatch; |
| pSoftGemini->hScanCncn = pStadHandles->hScanCncn; |
| pSoftGemini->hCurrBss = pStadHandles->hCurrBss; |
| pSoftGemini->hSme = pStadHandles->hSme; |
| } |
| |
| |
| TI_STATUS SoftGemini_SetDefaults (TI_HANDLE hSoftGemini, SoftGeminiInitParams_t *pSoftGeminiInitParams) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| TI_UINT8 i =0; |
| TI_STATUS status; |
| /*************************************/ |
| /* Getting SoftGemini init Params */ |
| /***********************************/ |
| |
| pSoftGemini->SoftGeminiEnable = pSoftGeminiInitParams->SoftGeminiEnable; |
| |
| for (i =0; i< SOFT_GEMINI_PARAMS_MAX ; i++) |
| { |
| pSoftGemini->SoftGeminiParam.coexParams[i] = pSoftGeminiInitParams->coexParams[i]; |
| } |
| |
| pSoftGemini->SoftGeminiParam.paramIdx = 0xFF; /* signals to FW to config all the paramters */ |
| |
| |
| /* Send the configuration to the FW */ |
| status = SoftGemini_setParamsToFW(hSoftGemini, &pSoftGemini->SoftGeminiParam); |
| |
| /*******************************/ |
| /* register Indication interrupts */ |
| /*****************************/ |
| |
| TWD_RegisterEvent (pSoftGemini->hTWD, |
| TWD_OWN_EVENT_SOFT_GEMINI_SENSE, |
| (void *)SoftGemini_SenseIndicationCB, |
| hSoftGemini); |
| TWD_RegisterEvent (pSoftGemini->hTWD, |
| TWD_OWN_EVENT_SOFT_GEMINI_PREDIC, |
| (void *)SoftGemini_ProtectiveIndicationCB, |
| hSoftGemini); |
| |
| TWD_EnableEvent (pSoftGemini->hTWD, TWD_OWN_EVENT_SOFT_GEMINI_SENSE); |
| TWD_EnableEvent (pSoftGemini->hTWD, TWD_OWN_EVENT_SOFT_GEMINI_PREDIC); |
| |
| /* On system initialization SG is disabled but later calls to SoftGemini_setEnableParam() */ |
| pSoftGemini->bProtectiveMode = TI_FALSE; |
| pSoftGemini->SoftGeminiEnable = SG_DISABLE; |
| pSoftGemini->bDriverEnabled = TI_FALSE; |
| pSoftGemini->bPsPollFailureActive = TI_FALSE; |
| |
| if ((TI_OK == status) && (pSoftGeminiInitParams->SoftGeminiEnable != SG_DISABLE)) |
| { /* called only if different than SG_DISABLE */ |
| status = SoftGemini_setEnableParam(hSoftGemini, pSoftGeminiInitParams->SoftGeminiEnable, TI_FALSE); |
| } |
| |
| if (status == TI_OK) |
| { |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INIT, " SoftGemini_config() - configured successfully\n"); |
| } |
| else |
| { |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_ERROR, " SoftGemini_config() - Error configuring module \n"); |
| } |
| |
| return status; |
| } |
| |
| /************************************************************************ |
| * SoftGemini_destroy * |
| ************************************************************************ |
| DESCRIPTION: SoftGemini module destroy function, called by the config mgr in the destroy phase |
| performs the following: |
| - Free all memory aloocated by the module |
| |
| INPUT: hSoftGemini - SoftGemini handle. |
| |
| |
| OUTPUT: |
| |
| RETURN: TI_OK on success, TI_NOK otherwise |
| |
| ************************************************************************/ |
| TI_STATUS SoftGemini_destroy(TI_HANDLE hSoftGemini) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| |
| if (pSoftGemini != NULL) |
| { |
| os_memoryFree( pSoftGemini->hOs, (TI_HANDLE)pSoftGemini , sizeof(SoftGemini_t)); |
| } |
| |
| return TI_OK; |
| } |
| |
| |
| /*********************************************************************** |
| * SoftGemini_setParam |
| *********************************************************************** |
| DESCRIPTION: SoftGemini set param function, called by the following: |
| - config mgr in order to set a parameter receiving from the OS abstraction layer. |
| - From inside the driver |
| |
| INPUT: hSoftGemini - SoftGemini handle. |
| pParam - Pointer to the parameter |
| |
| OUTPUT: |
| |
| RETURN: TI_OK on success, TI_NOK otherwise |
| |
| ************************************************************************/ |
| TI_STATUS SoftGemini_setParam(TI_HANDLE hSoftGemini, |
| paramInfo_t *pParam) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| TI_STATUS return_value = TI_OK; |
| |
| TRACE1(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, " SoftGemini_setParam() (0x%x)\n", pParam->paramType); |
| |
| switch(pParam->paramType) |
| { |
| |
| case SOFT_GEMINI_SET_ENABLE: |
| |
| return_value = SoftGemini_setEnableParam(hSoftGemini,pParam->content.SoftGeminiEnable, TI_FALSE); |
| break; |
| |
| case SOFT_GEMINI_SET_CONFIG: |
| |
| /* copy new params to SoftGemini module */ |
| SoftGemini_setConfigParam(hSoftGemini,pParam->content.SoftGeminiParamArray); |
| |
| /* set new params to FW */ |
| return_value = SoftGemini_setParamsToFW(hSoftGemini, &(pSoftGemini->SoftGeminiParam)); |
| |
| if (pSoftGemini->bProtectiveMode == TI_TRUE) |
| { |
| /* set new configurations of scan to scancncn */ |
| scanCncn_SGconfigureScanParams(pSoftGemini->hScanCncn,TI_TRUE, |
| (TI_UINT8)pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_AUTO_SCAN_PROBE_REQ], |
| pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_HV3_MAX_OVERRIDE], |
| pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_ACTIVE_SCAN_DURATION_FACTOR_HV3]); |
| } |
| break; |
| |
| default: |
| TRACE1(pSoftGemini->hReport, REPORT_SEVERITY_ERROR, " SoftGemini_setParam(), Params is not supported, %d\n\n", pParam->paramType); |
| return PARAM_NOT_SUPPORTED; |
| } |
| |
| return return_value; |
| } |
| |
| /*********************************************************************** |
| * SoftGemini_getParam |
| *********************************************************************** |
| DESCRIPTION: SoftGemini get param function, called by the following: |
| - config mgr in order to get a parameter from the OS abstraction layer. |
| - From inside the dirver |
| |
| INPUT: hSoftGemini - SoftGemini handle. |
| |
| |
| OUTPUT: pParam - Pointer to the parameter |
| |
| RETURN: TI_OK on success, TI_NOK otherwise |
| |
| ************************************************************************/ |
| TI_STATUS SoftGemini_getParam(TI_HANDLE hSoftGemini, |
| paramInfo_t *pParam) |
| { |
| switch (pParam->paramType) |
| { |
| case SOFT_GEMINI_GET_CONFIG: |
| SoftGemini_printParams(hSoftGemini); |
| break; |
| } |
| |
| return TI_OK; |
| } |
| |
| |
| |
| /*************************************************************************** |
| * SoftGemini_setEnableParam * |
| **************************************************************************** |
| * DESCRIPTION: The function sets the appropriate Enable value, |
| * configures SCR , POWER MGR , DATA CTRL , FW. |
| * |
| * INPUTS: pSoftGemini - the object |
| ***************************************************************************/ |
| static TI_STATUS SoftGemini_setEnableParam(TI_HANDLE hSoftGemini, ESoftGeminiEnableModes SoftGeminiEnable, TI_BOOL recovery) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| TTwdParamInfo param; |
| TI_STATUS return_value = TI_OK; |
| |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, " setSoftGeminiEnableParam() - Old value = , New value = \n"); |
| |
| |
| /* |
| * PsPoll work around is active. Just save the value and configure it later |
| */ |
| if ( pSoftGemini->bPsPollFailureActive ) |
| { |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, " setSoftGeminiEnableParam() - while PsPollFailure is active\n"); |
| |
| pSoftGemini->PsPollFailureLastEnableValue = SoftGeminiEnable; |
| return TI_OK; |
| } |
| |
| /**********************************/ |
| /* Sanity check on enable values */ |
| /********************************/ |
| |
| /* Old Value New Value */ |
| /* | | */ |
| /* \|/ \|/ */ |
| |
| if ((pSoftGemini->SoftGeminiEnable == SoftGeminiEnable) && !recovery) |
| { |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_ERROR, " - setting same value \n"); |
| return TI_NOK; |
| } |
| |
| /*******************************/ |
| /* Make the necessary actions */ |
| /*****************************/ |
| |
| switch (SoftGeminiEnable) |
| { |
| case SG_PROTECTIVE: |
| case SG_OPPORTUNISTIC: |
| |
| /* set FW with SG_ENABLE */ |
| param.paramType = TWD_SG_ENABLE_PARAM_ID; |
| param.content.SoftGeminiEnable = SoftGeminiEnable; |
| return_value = TWD_SetParam (pSoftGemini->hTWD, ¶m); |
| |
| break; |
| |
| case SG_DISABLE: |
| |
| /* set FW with SG_DISABLE */ |
| param.paramType = TWD_SG_ENABLE_PARAM_ID; |
| param.content.SoftGeminiEnable = SG_DISABLE; |
| return_value = TWD_SetParam (pSoftGemini->hTWD, ¶m); |
| |
| if (pSoftGemini->bDriverEnabled) |
| { |
| SoftGemini_DisableDriver(hSoftGemini); |
| } |
| |
| break; |
| |
| default: |
| TRACE1(pSoftGemini->hReport, REPORT_SEVERITY_ERROR, " defualt :%d\n",SoftGeminiEnable); |
| return TI_NOK; |
| } |
| |
| /* Pass to the new enable state */ |
| pSoftGemini->SoftGeminiEnable = SoftGeminiEnable; |
| |
| if (TI_OK != return_value) |
| { |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_ERROR, " can't configure enable param to FW :\n"); |
| } |
| |
| return return_value; |
| } |
| |
| /*************************************************************************** |
| * SoftGemini_setConfigParam * |
| **************************************************************************** |
| * DESCRIPTION: The function sets params |
| * |
| * INPUTS: pSoftGemini - the object |
| * param - params to be configured |
| ***************************************************************************/ |
| static void SoftGemini_setConfigParam(TI_HANDLE hSoftGemini, TI_UINT32 *param) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| |
| /* param[0] - SG parameter index, param[1] - SG parameter value */ |
| pSoftGemini->SoftGeminiParam.coexParams[(TI_UINT8)param[0]] = (TI_UINT32)param[1]; |
| pSoftGemini->SoftGeminiParam.paramIdx = (TI_UINT8)param[0]; |
| } |
| |
| /*************************************************************************** |
| * SoftGemini_printParams * |
| **************************************************************************** |
| * DESCRIPTION: Print SG Parameters. |
| * |
| * INPUTS: pSoftGemini - the object |
| ***************************************************************************/ |
| void SoftGemini_printParams(TI_HANDLE hSoftGemini) |
| { |
| #ifdef REPORT_LOG |
| |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| TSoftGeminiParams *SoftGeminiParam = &pSoftGemini->SoftGeminiParam; |
| |
| WLAN_OS_REPORT(("[0]: coexBtPerThreshold = %d\n", SoftGeminiParam->coexParams[SOFT_GEMINI_BT_PER_THRESHOLD])); |
| WLAN_OS_REPORT(("[1]: coexHv3MaxOverride = %d \n", SoftGeminiParam->coexParams[SOFT_GEMINI_HV3_MAX_OVERRIDE])); |
| WLAN_OS_REPORT(("[2]: coexBtNfsSampleInterval = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_BT_NFS_SAMPLE_INTERVAL])); |
| WLAN_OS_REPORT(("[3]: coexBtLoadRatio = %d (%)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_BT_LOAD_RATIO])); |
| WLAN_OS_REPORT(("[4]: coexAutoPsMode = %s \n", (SoftGeminiParam->coexParams[SOFT_GEMINI_AUTO_PS_MODE]?"Enabled":"Disabled"))); |
| WLAN_OS_REPORT(("[5]: coexAutoScanEnlargedNumOfProbeReqPercent = %d (%)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_AUTO_SCAN_PROBE_REQ])); |
| WLAN_OS_REPORT(("[6]: coexHv3AutoScanEnlargedScanWinodowPercent = %d (%)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_ACTIVE_SCAN_DURATION_FACTOR_HV3])); |
| WLAN_OS_REPORT(("[7]: coexAntennaConfiguration = %s (0 = Single, 1 = Dual) \n", (SoftGeminiParam->coexParams[SOFT_GEMINI_ANTENNA_CONFIGURATION]?"Dual":"Single"))); |
| WLAN_OS_REPORT(("[8]: coexMaxConsecutiveBeaconMissPrecent = %d (%)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_BEACON_MISS_PERCENT])); |
| WLAN_OS_REPORT(("[9]: coexAPRateAdapationThr = %d\n", SoftGeminiParam->coexParams[SOFT_GEMINI_RATE_ADAPT_THRESH])); |
| WLAN_OS_REPORT(("[10]: coexAPRateAdapationSnr = %d\n", SoftGeminiParam->coexParams[SOFT_GEMINI_RATE_ADAPT_SNR])); |
| WLAN_OS_REPORT(("[11]: coexWlanPsBtAclMasterMinBR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_MASTER_MIN_BR])); |
| WLAN_OS_REPORT(("[12]: coexWlanPsBtAclMasterMaxBR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_MASTER_MAX_BR])); |
| WLAN_OS_REPORT(("[13]: coexWlanPsMaxBtAclMasterBR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_MAX_BT_ACL_MASTER_BR])); |
| WLAN_OS_REPORT(("[14]: coexWlanPsBtAclSlaveMinBR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_SLAVE_MIN_BR])); |
| WLAN_OS_REPORT(("[15]: coexWlanPsBtAclSlaveMaxBR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_SLAVE_MAX_BR])); |
| WLAN_OS_REPORT(("[16]: coexWlanPsMaxBtAclSlaveBR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_MAX_BT_ACL_SLAVE_BR])); |
| WLAN_OS_REPORT(("[17]: coexWlanPsBtAclMasterMinEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_MASTER_MIN_EDR])); |
| WLAN_OS_REPORT(("[18]: coexWlanPsBtAclMasterMaxEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_MASTER_MAX_EDR])); |
| WLAN_OS_REPORT(("[19]: coexWlanPsMaxBtAclMasterEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_MAX_BT_ACL_MASTER_EDR])); |
| WLAN_OS_REPORT(("[20]: coexWlanPsBtAclSlaveMinEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_SLAVE_MIN_EDR])); |
| WLAN_OS_REPORT(("[21]: coexWlanPsBtAclSlaveMaxEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_SLAVE_MAX_EDR])); |
| WLAN_OS_REPORT(("[22]: coexWlanPsMaxBtAclSlaveEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_MAX_BT_ACL_SLAVE_EDR])); |
| WLAN_OS_REPORT(("[23]: coexRxt = %d (usec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_RXT])); |
| WLAN_OS_REPORT(("[24]: coexTxt = %d (usec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_TXT])); |
| WLAN_OS_REPORT(("[25]: coexAdaptiveRxtTxt = %s \n", (SoftGeminiParam->coexParams[SOFT_GEMINI_ADAPTIVE_RXT_TXT]?"Enabled":"Disabled"))); |
| WLAN_OS_REPORT(("[26]: coexPsPollTimeout = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_PS_POLL_TIMEOUT])); |
| WLAN_OS_REPORT(("[27]: coexUpsdTimeout = %d (msec) \n", SoftGeminiParam->coexParams[SOFT_GEMINI_UPSD_TIMEOUT])); |
| WLAN_OS_REPORT(("[28]: coexWlanActiveBtAclMasterMinEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR])); |
| WLAN_OS_REPORT(("[29]: coexWlanActiveBtAclMasterMaxEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR])); |
| WLAN_OS_REPORT(("[30]: coexWlanActiveMaxBtAclMasterEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR])); |
| WLAN_OS_REPORT(("[31]: coexWlanActiveBtAclSlaveMinEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR])); |
| WLAN_OS_REPORT(("[32]: coexWlanActiveBtAclSlaveMaxEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR])); |
| WLAN_OS_REPORT(("[33]: coexWlanActiveMaxBtAclSlaveEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR])); |
| WLAN_OS_REPORT(("[34]: coexWlanActiveBtAclMinBR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_ACTIVE_BT_ACL_MIN_BR])); |
| WLAN_OS_REPORT(("[35]: coexWlanActiveBtAclMinBr = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_ACTIVE_BT_ACL_MAX_BR])); |
| WLAN_OS_REPORT(("[36]: coexWlanActiveMaxBtAclBr = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_ACTIVE_MAX_BT_ACL_BR])); |
| WLAN_OS_REPORT(("[37]: coexHv3AutoEnlargePassiveScanWindowPercent = %d (%)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_PASSIVE_SCAN_DURATION_FACTOR_HV3])); |
| WLAN_OS_REPORT(("[38]: coexA2DPAutoEnlargePassiveScanWindowPercent = %d (%) \n", SoftGeminiParam->coexParams[SOFT_GEMINI_PASSIVE_SCAN_DURATION_FACTOR_A2DP])); |
| WLAN_OS_REPORT(("[39]: coexPassiveScanA2dpBtTime = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_PASSIVE_SCAN_A2DP_BT_TIME])); |
| WLAN_OS_REPORT(("[40]: coexPassiveScanA2dpWlanTime = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_PASSIVE_SCAN_A2DP_WLAN_TIME])); |
| WLAN_OS_REPORT(("[41]: CoexHv3MaxServed = %d \n", SoftGeminiParam->coexParams[SOFT_GEMINI_HV3_MAX_SERVED])); |
| WLAN_OS_REPORT(("[42]: coexDhcpTime = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_DHCP_TIME])); |
| WLAN_OS_REPORT(("[43]: coexA2dpAutoScanEnlargedScanWinodowPercent = %d (%)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_ACTIVE_SCAN_DURATION_FACTOR_A2DP])); |
| WLAN_OS_REPORT(("[44]: coexTempParam1 = %d \n", SoftGeminiParam->coexParams[SOFT_GEMINI_TEMP_PARAM_1])); |
| WLAN_OS_REPORT(("[45]: coexTempParam2 = %d \n", SoftGeminiParam->coexParams[SOFT_GEMINI_TEMP_PARAM_2])); |
| WLAN_OS_REPORT(("[46]: coexTempParam3 = %d \n", SoftGeminiParam->coexParams[SOFT_GEMINI_TEMP_PARAM_3])); |
| WLAN_OS_REPORT(("[47]: coexTempParam4 = %d \n", SoftGeminiParam->coexParams[SOFT_GEMINI_TEMP_PARAM_4])); |
| WLAN_OS_REPORT(("[48]: coexTempParam5 = %d \n", SoftGeminiParam->coexParams[SOFT_GEMINI_TEMP_PARAM_5])); |
| WLAN_OS_REPORT(("Enable mode : %s\n", SoftGemini_ConvertModeToString(pSoftGemini->SoftGeminiEnable))); |
| WLAN_OS_REPORT(("Driver Enabled : %s\n",(pSoftGemini->bDriverEnabled ? "YES" : "NO"))); |
| WLAN_OS_REPORT(("Protective mode : %s\n", (pSoftGemini->bProtectiveMode ? "ON" : "OFF"))); |
| WLAN_OS_REPORT(("PsPoll failure active : %s\n", (pSoftGemini->bPsPollFailureActive ? "YES" : "NO"))); |
| |
| #endif |
| } |
| |
| /*************************************************************************** |
| * SoftGemini_setParamsToFW * |
| **************************************************************************** |
| * DESCRIPTION: The function sets the FW with the appropriate parameters set. |
| * |
| * INPUTS: pSoftGemini - the object |
| * |
| * |
| * OUTPUT: |
| * |
| * RETURNS: |
| ***************************************************************************/ |
| static TI_STATUS SoftGemini_setParamsToFW(TI_HANDLE hSoftGemini, TSoftGeminiParams *softGeminiParams) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| TTwdParamInfo param; |
| |
| os_memoryCopy(pSoftGemini->hOs,¶m.content.SoftGeminiParam, softGeminiParams, sizeof(TSoftGeminiParams)); |
| param.paramType = TWD_SG_CONFIG_PARAM_ID; |
| return TWD_SetParam (pSoftGemini->hTWD, ¶m); |
| } |
| |
| |
| /*************************************************************************** |
| * SoftGemini_EnableDriver * |
| **************************************************************************** |
| * DESCRIPTION: Activated when SG is enabled (after CLI or FW command) |
| * |
| * INPUTS: pSoftGemini - the object |
| * |
| ***************************************************************************/ |
| static TI_STATUS SoftGemini_EnableDriver(TI_HANDLE hSoftGemini) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| TI_STATUS return_value = TI_OK; |
| |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, "\n"); |
| |
| pSoftGemini->bDriverEnabled = TI_TRUE; |
| |
| /* Check if coexAutoPsMode - Co-ex is enabled to enter/exit P.S */ |
| if ( pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_AUTO_PS_MODE]) |
| { |
| SoftGemini_SetPS(pSoftGemini); |
| } |
| |
| scr_setMode(pSoftGemini->hSCR, SCR_MID_SG); |
| |
| return return_value; |
| } |
| |
| /*************************************************************************** |
| * SoftGemini_DisableDriver * |
| **************************************************************************** |
| * DESCRIPTION: Activated when SG is disabled (after CLI or FW command) |
| * |
| * INPUTS: pSoftGemini - the object |
| * |
| ***************************************************************************/ |
| static TI_STATUS SoftGemini_DisableDriver(TI_HANDLE hSoftGemini) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| TI_STATUS return_value = TI_OK; |
| |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, "\n"); |
| |
| pSoftGemini->bDriverEnabled = TI_FALSE; |
| |
| scr_setMode(pSoftGemini->hSCR, SCR_MID_NORMAL); |
| |
| |
| /* Check if coexAutoPsMode - Co-ex is enabled to enter/exit P.S */ |
| if ( pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_AUTO_PS_MODE]) |
| { |
| SoftGemini_unSetPS(pSoftGemini); |
| } |
| |
| /* Undo the changes that were made when Protective mode was on */ |
| if (pSoftGemini->bProtectiveMode) |
| { |
| SoftGemini_DisableProtectiveMode(hSoftGemini); |
| } |
| |
| return return_value; |
| } |
| |
| /*************************************************************************** |
| * SoftGemini_SetPS * |
| **************************************************************************** |
| * DESCRIPTION: Set Always PS to PowerMgr |
| * |
| * INPUTS: pSoftGemini - the object |
| * |
| ***************************************************************************/ |
| static TI_STATUS SoftGemini_SetPS(SoftGemini_t *pSoftGemini) |
| { |
| paramInfo_t param; |
| bssEntry_t *pBssInfo=NULL; |
| |
| if (pSoftGemini->hCurrBss) |
| { |
| pBssInfo = currBSS_getBssInfo(pSoftGemini->hCurrBss); |
| } |
| else |
| { |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_ERROR, "SoftGemini_SetPS: hCurrBss = NULL!!!\n"); |
| } |
| |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, "\n"); |
| |
| if (pBssInfo) |
| { |
| if ((pBssInfo->band == RADIO_BAND_2_4_GHZ)) |
| { |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, " SG-setPS: band == RADIO_BAND_2_4_GHZ"); |
| |
| /* Set Params to Power Mgr for SG priority */ |
| param.paramType = POWER_MGR_POWER_MODE; |
| param.content.powerMngPowerMode.PowerMode = POWER_MODE_PS_ONLY; |
| param.content.powerMngPowerMode.PowerMngPriority = POWER_MANAGER_SG_PRIORITY; |
| powerMgr_setParam(pSoftGemini->hPowerMgr,¶m); |
| |
| /* enable SG priority for Power Mgr */ |
| param.paramType = POWER_MGR_ENABLE_PRIORITY; |
| param.content.powerMngPriority = POWER_MANAGER_SG_PRIORITY; |
| return powerMgr_setParam(pSoftGemini->hPowerMgr,¶m); |
| } |
| else |
| { |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, " SG-setPS: band == RADIO_BAND_5_GHZ"); |
| } |
| } |
| return TI_OK; |
| } |
| |
| /*************************************************************************** |
| * SoftGemini_unSetPS * |
| **************************************************************************** |
| * DESCRIPTION: unSet Always PS to PowerMgr |
| * |
| * INPUTS: pSoftGemini - the object |
| * |
| ***************************************************************************/ |
| static TI_STATUS SoftGemini_unSetPS(SoftGemini_t *pSoftGemini) |
| { |
| paramInfo_t param; |
| |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, ", SG-unSetPS \n"); |
| |
| /* disable SG priority for Power Mgr*/ |
| param.paramType = POWER_MGR_DISABLE_PRIORITY; |
| param.content.powerMngPriority = POWER_MANAGER_SG_PRIORITY; |
| return powerMgr_setParam(pSoftGemini->hPowerMgr,¶m); |
| |
| } |
| |
| /*************************************************************************** |
| * SoftGemini_EnableProtectiveMode * |
| **************************************************************************** |
| * DESCRIPTION: Activated when FW inform us that protective mode is ON |
| * |
| * |
| * INPUTS: pSoftGemini - the object |
| * |
| ***************************************************************************/ |
| void SoftGemini_EnableProtectiveMode(TI_HANDLE hSoftGemini) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| paramInfo_t param; |
| |
| pSoftGemini->bProtectiveMode = TI_TRUE; |
| |
| /* set new configurations of SG roaming parameters */ |
| |
| /* This code should be removed on SG stage 2 integration |
| currBSS_SGconfigureBSSLoss(pSoftGemini->hCurrBss,pSoftGemini->BSSLossCompensationPercent,TI_TRUE); */ |
| |
| /* set new configurations of scan to scancncn */ |
| scanCncn_SGconfigureScanParams(pSoftGemini->hScanCncn,TI_TRUE, |
| (TI_UINT8)pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_AUTO_SCAN_PROBE_REQ], |
| pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_HV3_MAX_OVERRIDE], |
| pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_ACTIVE_SCAN_DURATION_FACTOR_HV3]); |
| |
| /* Call the power manager to enter short doze */ |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, " SoftGemini_EnableProtectiveMode set SD"); |
| |
| /* Set Params to Power Mgr for SG priority */ |
| param.paramType = POWER_MGR_POWER_MODE; |
| param.content.powerMngPowerMode.PowerMode = POWER_MODE_SHORT_DOZE; |
| param.content.powerMngPowerMode.PowerMngPriority = POWER_MANAGER_SG_PRIORITY; |
| powerMgr_setParam(pSoftGemini->hPowerMgr,¶m); |
| } |
| |
| /*************************************************************************** |
| * SoftGemini_DisableProtectiveMode * |
| **************************************************************************** |
| * DESCRIPTION: Activated when FW inform us that protective mode is OFF or SG is disabled |
| * |
| * INPUTS: pSoftGemini - the object |
| * |
| ***************************************************************************/ |
| void SoftGemini_DisableProtectiveMode(TI_HANDLE hSoftGemini) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, "\n"); |
| |
| pSoftGemini->bProtectiveMode = TI_FALSE; |
| |
| SoftGemini_RemoveProtectiveModeParameters(hSoftGemini); |
| } |
| |
| /*************************************************************************** |
| * SoftGemini_DisableProtectiveMode * |
| **************************************************************************** |
| * DESCRIPTION: Called from SoftGemini_DisableProtectiveMode() when FW inform |
| * us that protective mode is OFF or SG is disabled, or from |
| * SoftGemini_unSetPSmode() when driver disconnects from AP. |
| * |
| * INPUTS: pSoftGemini - the object |
| * |
| ***************************************************************************/ |
| |
| void SoftGemini_RemoveProtectiveModeParameters(TI_HANDLE hSoftGemini) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| paramInfo_t param; |
| |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, "\n"); |
| |
| /* don't use the SG roaming parameters */ |
| currBSS_SGconfigureBSSLoss(pSoftGemini->hCurrBss,0,TI_FALSE); |
| |
| /* don't use the SG scan parameters */ |
| scanCncn_SGconfigureScanParams(pSoftGemini->hScanCncn,TI_FALSE,0,0,0); |
| |
| /* Call the power manager to exit short doze */ |
| /* Set Params to Power Mgr for SG priority */ |
| param.paramType = POWER_MGR_POWER_MODE; |
| param.content.powerMngPowerMode.PowerMode = POWER_MODE_PS_ONLY; |
| param.content.powerMngPowerMode.PowerMngPriority = POWER_MANAGER_SG_PRIORITY; |
| powerMgr_setParam(pSoftGemini->hPowerMgr,¶m); |
| } |
| |
| /*************************************************************************** |
| * SoftGemini_SenseIndicationCB * |
| **************************************************************************** |
| * DESCRIPTION: This is the the function which is called for sense mode indication from FW |
| * (i.e. we are in SENSE mode and FW detects BT activity ) |
| * SENSE_MODE_ENABLE - Indicates that FW detected BT activity |
| * SENSE_MODE_DISABLE - Indicates that FW doesn't detect BT activity for a period of time |
| * |
| * INPUTS: pSoftGemini - the object |
| * NOTE This function is located in the API for debug purposes |
| ***************************************************************************/ |
| |
| void SoftGemini_SenseIndicationCB( TI_HANDLE hSoftGemini, char* str, TI_UINT32 strLen ) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| |
| if (pSoftGemini->SoftGeminiEnable == SG_DISABLE) { |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_WARNING, ": SG is disabled, existing"); |
| return; |
| } |
| |
| if ( (SENSE_MODE_ENABLE == *str) && (!pSoftGemini->bDriverEnabled) ) |
| { |
| SoftGemini_EnableDriver(hSoftGemini); |
| } |
| else if ( (SENSE_MODE_DISABLE == *str) && (pSoftGemini->bDriverEnabled) ) |
| { |
| SoftGemini_DisableDriver(hSoftGemini); |
| } |
| } |
| |
| /*************************************************************************** |
| * SoftGemini_ProtectiveIndicationCB * |
| **************************************************************************** |
| * DESCRIPTION: This is the the function which is called when FW starts Protective mode (i.e BT voice) |
| * |
| * PROTECTIVE_MODE_ON - FW is activated on protective mode (BT voice is running) |
| * PROTECTIVE_MODE_OFF - FW is not activated on protective mode |
| * |
| * INPUTS: pSoftGemini - the object |
| * NOTE This function is located in the API for debug purposes |
| ***************************************************************************/ |
| |
| void SoftGemini_ProtectiveIndicationCB( TI_HANDLE hSoftGemini, char* str, TI_UINT32 strLen ) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| |
| TRACE1(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, " with 0x%x\n",*str); |
| |
| if (SG_DISABLE != pSoftGemini->SoftGeminiEnable) |
| { |
| if ((!pSoftGemini->bProtectiveMode) && (PROTECTIVE_MODE_ON == *str)) |
| { |
| SoftGemini_EnableProtectiveMode(hSoftGemini); |
| } |
| else if ((pSoftGemini->bProtectiveMode) && (PROTECTIVE_MODE_OFF == *str)) |
| { |
| SoftGemini_DisableProtectiveMode(hSoftGemini); |
| } |
| else |
| { |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, " : Protective mode called when Protective mode is \n"); |
| } |
| } |
| else |
| { |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_WARNING, " : Protective mode called when SG mode is ? \n"); |
| } |
| } |
| |
| /*************************************************************************** |
| * SoftGemini_ConvertModeToString * |
| ****************************************************************************/ |
| #ifdef REPORT_LOG |
| |
| char* SoftGemini_ConvertModeToString(ESoftGeminiEnableModes SoftGeminiEnable) |
| { |
| switch(SoftGeminiEnable) |
| { |
| case SG_PROTECTIVE: return "SG_PROTECTIVE"; |
| case SG_DISABLE: return "SG_DISABLE"; |
| case SG_OPPORTUNISTIC: return "SG_OPPORTUNISTIC"; |
| default: |
| return "ERROR"; |
| } |
| } |
| |
| #endif |
| |
| /*************************************************************************** |
| * SoftGemini_getSGMode * |
| ****************************************************************************/ |
| ESoftGeminiEnableModes SoftGemini_getSGMode(TI_HANDLE hSoftGemini) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| return pSoftGemini->SoftGeminiEnable; |
| } |
| |
| /*************************************************************************** |
| * SoftGemini_handleRecovery * |
| **************************************************************************** |
| * DESCRIPTION: The function reconfigures WHAL with the SG parameters. |
| * |
| * INPUTS: pSoftGemini - the object |
| ***************************************************************************/ |
| TI_STATUS SoftGemini_handleRecovery(TI_HANDLE hSoftGemini) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| ESoftGeminiEnableModes realSoftGeminiEnableMode; |
| |
| realSoftGeminiEnableMode = pSoftGemini->SoftGeminiEnable; |
| /* Disable the SG */ |
| SoftGemini_setEnableParam(hSoftGemini, SG_DISABLE, TI_TRUE); |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, "Disable SG \n"); |
| |
| pSoftGemini->SoftGeminiEnable = realSoftGeminiEnableMode; |
| /* Set enable param */ |
| |
| SoftGemini_setEnableParam(hSoftGemini, pSoftGemini->SoftGeminiEnable, TI_TRUE); |
| TRACE1(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, "Set SG to-%d\n", pSoftGemini->SoftGeminiEnable); |
| |
| /* Config the params to FW */ |
| |
| SoftGemini_setParamsToFW(hSoftGemini, &pSoftGemini->SoftGeminiParam); |
| /*SoftGemini_printParams(hSoftGemini);*/ |
| return TI_OK; |
| } |
| /*************************************************************************** |
| * SoftGemini_startPsPollFailure * |
| **************************************************************************** |
| * DESCRIPTION: After Ps-Poll failure we disable the SG |
| * |
| * INPUTS: pSoftGemini - the object |
| ***************************************************************************/ |
| void SoftGemini_startPsPollFailure(TI_HANDLE hSoftGemini) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, "\n"); |
| |
| if ( (!pSoftGemini->bPsPollFailureActive) && (pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_AUTO_PS_MODE] == TI_TRUE) ) |
| { |
| pSoftGemini->PsPollFailureLastEnableValue = pSoftGemini->SoftGeminiEnable; |
| |
| /* Disable SG if needed */ |
| if ( pSoftGemini->SoftGeminiEnable != SG_DISABLE ) |
| { |
| SoftGemini_setEnableParam(hSoftGemini, SG_DISABLE, TI_FALSE); |
| } |
| |
| pSoftGemini->bPsPollFailureActive = TI_TRUE; |
| } |
| else /* Calling SoftGemini_startPsPollFailure twice ? */ |
| { |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_WARNING, "Calling SoftGemini_startPsPollFailure while bPsPollFailureActive is TRUE\n"); |
| } |
| } |
| |
| /*************************************************************************** |
| * SoftGemini_endPsPollFailure * |
| **************************************************************************** |
| * DESCRIPTION: Return to normal behavior after the PsPoll failure |
| * |
| * INPUTS: pSoftGemini - the object |
| ***************************************************************************/ |
| void SoftGemini_endPsPollFailure(TI_HANDLE hSoftGemini) |
| { |
| SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; |
| |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, "\n"); |
| |
| if ( pSoftGemini->bPsPollFailureActive ) |
| { |
| pSoftGemini->bPsPollFailureActive = TI_FALSE; |
| |
| /* return to previous value */ |
| if ( pSoftGemini->PsPollFailureLastEnableValue != SG_DISABLE ) |
| { |
| SoftGemini_setEnableParam(hSoftGemini, pSoftGemini->PsPollFailureLastEnableValue, TI_FALSE); |
| } |
| } |
| else /* Calling SoftGemini_endPsPollFailure twice ? */ |
| { |
| TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_WARNING, "Calling SoftGemini_endPsPollFailure while bPsPollFailureActive is FALSE\n"); |
| } |
| } |
| |
| |
