1/* 2 * SoftGemini.c 3 * 4 * Copyright(c) 1998 - 2009 Texas Instruments. All rights reserved. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name Texas Instruments nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34/** \file softGemini.c 35 * \brief BlueTooth-Wlan coexistence module interface 36 * 37 * \see softGemini.h 38 */ 39 40/**************************************************************************************************** 41* * 42* MODULE: softGemini.c * 43* PURPOSE: BlueTooth-Wlan coexistence module interface. * 44* This module handles all data base (and Fw setting accordingly) * 45* for Bluetooth-Wlan coexistence implementation. * 46* * 47****************************************************************************************************/ 48 49#define __FILE_ID__ FILE_ID_5 50#include "report.h" 51#include "osApi.h" 52#include "SoftGemini.h" 53#include "DataCtrl_Api.h" 54#include "scrApi.h" 55#include "PowerMgr_API.h" 56#include "ScanCncn.h" 57#include "currBss.h" 58#include "CmdDispatcher.h" 59#include "TWDriver.h" 60#include "DrvMainModules.h" 61#include "bssTypes.h" 62#include "sme.h" 63 64 65#define SENSE_MODE_ENABLE 0x01 66#define SENSE_MODE_DISABLE 0x00 67#define PROTECTIVE_MODE_ON 0x01 68#define PROTECTIVE_MODE_OFF 0x00 69 70/********************************************************************************/ 71/* Internal functions prototypes. */ 72/********************************************************************************/ 73 74static TI_STATUS SoftGemini_setEnableParam(TI_HANDLE hSoftGemini, ESoftGeminiEnableModes SoftGeminiEnable, TI_BOOL recovery); 75static TI_STATUS SoftGemini_setParamsToFW(TI_HANDLE hSoftGemini, TSoftGeminiParams *SoftGeminiParam); 76static TI_STATUS SoftGemini_EnableDriver(TI_HANDLE hSoftGemini); 77static TI_STATUS SoftGemini_DisableDriver(TI_HANDLE hSoftGemini); 78static TI_STATUS SoftGemini_SetPS(SoftGemini_t *pSoftGemini); 79static TI_STATUS SoftGemini_unSetPS(SoftGemini_t *pSoftGemini); 80static void SoftGemini_RemoveProtectiveModeParameters(TI_HANDLE hSoftGemini); 81static void SoftGemini_setConfigParam(TI_HANDLE hSoftGemini, TI_UINT32 *param); 82static void SoftGemini_EnableProtectiveMode(TI_HANDLE hSoftGemini); 83static void SoftGemini_DisableProtectiveMode(TI_HANDLE hSoftGemini); 84#ifdef REPORT_LOG 85static char* SoftGemini_ConvertModeToString(ESoftGeminiEnableModes SoftGeminiEnable); 86#endif 87 88/********************************************************************************/ 89/* Interface functions Implementation. */ 90/********************************************************************************/ 91/************************************************************************ 92 * SoftGemini_SetPSmode * 93 ************************************************************************ 94DESCRIPTION: SoftGemini module, called by the conn_Infra on connection 95 performs the following: 96 - Enables SG if needed 97 - Enables the SG power mode 98INPUT: hSoftGemini - Handle to SoftGemini 99 100OUTPUT: 101 102RETURN: 103 104************************************************************************/ 105void SoftGemini_SetPSmode(TI_HANDLE hSoftGemini) 106{ 107 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 108 109 if (pSoftGemini) 110 { 111 if (pSoftGemini->bDriverEnabled) 112 { 113 /* Check if coexAutoPsMode is enabled to enter/exit P.S */ 114 if ( pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_AUTO_PS_MODE]) 115 { 116 SoftGemini_SetPS(pSoftGemini); 117 } 118 } 119 if (pSoftGemini->bProtectiveMode) 120 { 121 SoftGemini_EnableProtectiveMode(hSoftGemini); 122 } 123 } 124 else 125 { 126 TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_ERROR, " SoftGemini_SetPSmode() - Error hSoftGemini= NULL \n"); 127 } 128} 129 130/************************************************************************ 131 * SoftGemini_unSetPSmode * 132 ************************************************************************ 133DESCRIPTION: SoftGemini module, called by the conn_Infra after disconnecting 134 performs the following: 135 - Disables the SG 136 - Disables the SG power mode 137INPUT: hSoftGemini - Handle to SoftGemini 138 139OUTPUT: 140 141RETURN: 142 143************************************************************************/ 144void SoftGemini_unSetPSmode(TI_HANDLE hSoftGemini) 145{ 146 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 147 148 if (pSoftGemini) 149 { 150 if (pSoftGemini->bDriverEnabled) 151 { 152 /* Check if coexAutoPsMode is enabled to enter/exit P.S */ 153 if ( pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_AUTO_PS_MODE]) 154 { 155 SoftGemini_unSetPS(pSoftGemini); 156 } 157 } 158 if (pSoftGemini->bProtectiveMode) 159 { 160 SoftGemini_RemoveProtectiveModeParameters(hSoftGemini); 161 } 162 } 163 else 164 { 165 TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_ERROR, " SoftGemini_unSetPSmode() - Error hSoftGemini= NULL \n"); 166 } 167} 168 169/************************************************************************ 170 * SoftGemini_create * 171 ************************************************************************ 172DESCRIPTION: SoftGemini module creation function, called by the config mgr in creation phase 173 performs the following: 174 - Allocate the SoftGemini handle 175 176INPUT: hOs - Handle to OS 177 178 179OUTPUT: 180 181RETURN: Handle to the SoftGemini module on success, NULL otherwise 182 183************************************************************************/ 184TI_HANDLE SoftGemini_create(TI_HANDLE hOs) 185{ 186 SoftGemini_t *pSoftGemini = NULL; 187 188 /* allocating the SoftGemini object */ 189 pSoftGemini = os_memoryAlloc(hOs,sizeof(SoftGemini_t)); 190 191 if (pSoftGemini == NULL) 192 return NULL; 193 194 pSoftGemini->hOs = hOs; 195 196 return pSoftGemini; 197} 198 199/************************************************************************ 200 * SoftGemini_config * 201 ************************************************************************ 202DESCRIPTION: SoftGemini module init function, called by the rvMain in init phase 203 performs the following: 204 - Init local variables 205 - Init the handles to be used by the module 206 207INPUT: pStadHandles - The driver modules handles 208 209OUTPUT: 210 211RETURN: void 212************************************************************************/ 213void SoftGemini_init (TStadHandlesList *pStadHandles) 214{ 215 SoftGemini_t *pSoftGemini = (SoftGemini_t *)(pStadHandles->hSoftGemini); 216 217 pSoftGemini->hCtrlData = pStadHandles->hCtrlData; 218 pSoftGemini->hTWD = pStadHandles->hTWD; 219 pSoftGemini->hReport = pStadHandles->hReport; 220 pSoftGemini->hSCR = pStadHandles->hSCR; 221 pSoftGemini->hPowerMgr = pStadHandles->hPowerMgr; 222 pSoftGemini->hCmdDispatch = pStadHandles->hCmdDispatch; 223 pSoftGemini->hScanCncn = pStadHandles->hScanCncn; 224 pSoftGemini->hCurrBss = pStadHandles->hCurrBss; 225 pSoftGemini->hSme = pStadHandles->hSme; 226} 227 228 229TI_STATUS SoftGemini_SetDefaults (TI_HANDLE hSoftGemini, SoftGeminiInitParams_t *pSoftGeminiInitParams) 230{ 231 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 232 TI_UINT8 i =0; 233 TI_STATUS status; 234 /*************************************/ 235 /* Getting SoftGemini init Params */ 236 /***********************************/ 237 238 pSoftGemini->SoftGeminiEnable = pSoftGeminiInitParams->SoftGeminiEnable; 239 240 for (i =0; i< SOFT_GEMINI_PARAMS_MAX ; i++) 241 { 242 pSoftGemini->SoftGeminiParam.coexParams[i] = pSoftGeminiInitParams->coexParams[i]; 243 } 244 245 pSoftGemini->SoftGeminiParam.paramIdx = 0xFF; /* signals to FW to config all the paramters */ 246 247 248 /* Send the configuration to the FW */ 249 status = SoftGemini_setParamsToFW(hSoftGemini, &pSoftGemini->SoftGeminiParam); 250 251 /*******************************/ 252 /* register Indication interrupts */ 253 /*****************************/ 254 255 TWD_RegisterEvent (pSoftGemini->hTWD, 256 TWD_OWN_EVENT_SOFT_GEMINI_SENSE, 257 (void *)SoftGemini_SenseIndicationCB, 258 hSoftGemini); 259 TWD_RegisterEvent (pSoftGemini->hTWD, 260 TWD_OWN_EVENT_SOFT_GEMINI_PREDIC, 261 (void *)SoftGemini_ProtectiveIndicationCB, 262 hSoftGemini); 263 264 TWD_EnableEvent (pSoftGemini->hTWD, TWD_OWN_EVENT_SOFT_GEMINI_SENSE); 265 TWD_EnableEvent (pSoftGemini->hTWD, TWD_OWN_EVENT_SOFT_GEMINI_PREDIC); 266 267 /* On system initialization SG is disabled but later calls to SoftGemini_setEnableParam() */ 268 pSoftGemini->bProtectiveMode = TI_FALSE; 269 pSoftGemini->SoftGeminiEnable = SG_DISABLE; 270 pSoftGemini->bDriverEnabled = TI_FALSE; 271 pSoftGemini->bPsPollFailureActive = TI_FALSE; 272 273 if ((TI_OK == status) && (pSoftGeminiInitParams->SoftGeminiEnable != SG_DISABLE)) 274 { /* called only if different than SG_DISABLE */ 275 status = SoftGemini_setEnableParam(hSoftGemini, pSoftGeminiInitParams->SoftGeminiEnable, TI_FALSE); 276 } 277 278 if (status == TI_OK) 279 { 280TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INIT, " SoftGemini_config() - configured successfully\n"); 281 } 282 else 283 { 284TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_ERROR, " SoftGemini_config() - Error configuring module \n"); 285 } 286 287 return status; 288} 289 290/************************************************************************ 291 * SoftGemini_destroy * 292 ************************************************************************ 293DESCRIPTION: SoftGemini module destroy function, called by the config mgr in the destroy phase 294 performs the following: 295 - Free all memory aloocated by the module 296 297INPUT: hSoftGemini - SoftGemini handle. 298 299 300OUTPUT: 301 302RETURN: TI_OK on success, TI_NOK otherwise 303 304************************************************************************/ 305TI_STATUS SoftGemini_destroy(TI_HANDLE hSoftGemini) 306{ 307 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 308 309 if (pSoftGemini != NULL) 310 { 311 os_memoryFree( pSoftGemini->hOs, (TI_HANDLE)pSoftGemini , sizeof(SoftGemini_t)); 312 } 313 314 return TI_OK; 315} 316 317 318/*********************************************************************** 319 * SoftGemini_setParam 320 *********************************************************************** 321DESCRIPTION: SoftGemini set param function, called by the following: 322 - config mgr in order to set a parameter receiving from the OS abstraction layer. 323 - From inside the driver 324 325INPUT: hSoftGemini - SoftGemini handle. 326 pParam - Pointer to the parameter 327 328OUTPUT: 329 330RETURN: TI_OK on success, TI_NOK otherwise 331 332************************************************************************/ 333TI_STATUS SoftGemini_setParam(TI_HANDLE hSoftGemini, 334 paramInfo_t *pParam) 335{ 336 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 337 TI_STATUS return_value = TI_OK; 338 339TRACE1(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, " SoftGemini_setParam() (0x%x)\n", pParam->paramType); 340 341 switch(pParam->paramType) 342 { 343 344 case SOFT_GEMINI_SET_ENABLE: 345 346 return_value = SoftGemini_setEnableParam(hSoftGemini,pParam->content.SoftGeminiEnable, TI_FALSE); 347 break; 348 349 case SOFT_GEMINI_SET_CONFIG: 350 351 /* copy new params to SoftGemini module */ 352 SoftGemini_setConfigParam(hSoftGemini,pParam->content.SoftGeminiParamArray); 353 354 /* set new params to FW */ 355 return_value = SoftGemini_setParamsToFW(hSoftGemini, &(pSoftGemini->SoftGeminiParam)); 356 357 if (pSoftGemini->bProtectiveMode == TI_TRUE) 358 { 359 /* set new configurations of scan to scancncn */ 360 scanCncn_SGconfigureScanParams(pSoftGemini->hScanCncn,TI_TRUE, 361 (TI_UINT8)pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_AUTO_SCAN_PROBE_REQ], 362 pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_HV3_MAX_OVERRIDE], 363 pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_ACTIVE_SCAN_DURATION_FACTOR_HV3]); 364 } 365 break; 366 367 default: 368TRACE1(pSoftGemini->hReport, REPORT_SEVERITY_ERROR, " SoftGemini_setParam(), Params is not supported, %d\n\n", pParam->paramType); 369 return PARAM_NOT_SUPPORTED; 370 } 371 372 return return_value; 373} 374 375/*********************************************************************** 376 * SoftGemini_getParam 377 *********************************************************************** 378DESCRIPTION: SoftGemini get param function, called by the following: 379 - config mgr in order to get a parameter from the OS abstraction layer. 380 - From inside the dirver 381 382INPUT: hSoftGemini - SoftGemini handle. 383 384 385OUTPUT: pParam - Pointer to the parameter 386 387RETURN: TI_OK on success, TI_NOK otherwise 388 389************************************************************************/ 390TI_STATUS SoftGemini_getParam(TI_HANDLE hSoftGemini, 391 paramInfo_t *pParam) 392{ 393 switch (pParam->paramType) 394 { 395 case SOFT_GEMINI_GET_CONFIG: 396 SoftGemini_printParams(hSoftGemini); 397 break; 398 } 399 400 return TI_OK; 401} 402 403 404 405/*************************************************************************** 406* SoftGemini_setEnableParam * 407**************************************************************************** 408* DESCRIPTION: The function sets the appropriate Enable value, 409* configures SCR , POWER MGR , DATA CTRL , FW. 410* 411* INPUTS: pSoftGemini - the object 412***************************************************************************/ 413static TI_STATUS SoftGemini_setEnableParam(TI_HANDLE hSoftGemini, ESoftGeminiEnableModes SoftGeminiEnable, TI_BOOL recovery) 414{ 415 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 416 TTwdParamInfo param; 417 TI_STATUS return_value = TI_OK; 418 419TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, " setSoftGeminiEnableParam() - Old value = , New value = \n"); 420 421 422 /* 423 * PsPoll work around is active. Just save the value and configure it later 424 */ 425 if ( pSoftGemini->bPsPollFailureActive ) 426 { 427 TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, " setSoftGeminiEnableParam() - while PsPollFailure is active\n"); 428 429 pSoftGemini->PsPollFailureLastEnableValue = SoftGeminiEnable; 430 return TI_OK; 431 } 432 433 /**********************************/ 434 /* Sanity check on enable values */ 435 /********************************/ 436 437 /* Old Value New Value */ 438 /* | | */ 439 /* \|/ \|/ */ 440 441 if ((pSoftGemini->SoftGeminiEnable == SoftGeminiEnable) && !recovery) 442 { 443TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_ERROR, " - setting same value \n"); 444 return TI_NOK; 445 } 446 447 /*******************************/ 448 /* Make the necessary actions */ 449 /*****************************/ 450 451 switch (SoftGeminiEnable) 452 { 453 case SG_PROTECTIVE: 454 case SG_OPPORTUNISTIC: 455 456 /* set FW with SG_ENABLE */ 457 param.paramType = TWD_SG_ENABLE_PARAM_ID; 458 param.content.SoftGeminiEnable = SoftGeminiEnable; 459 return_value = TWD_SetParam (pSoftGemini->hTWD, ¶m); 460 461 break; 462 463 case SG_DISABLE: 464 465 /* set FW with SG_DISABLE */ 466 param.paramType = TWD_SG_ENABLE_PARAM_ID; 467 param.content.SoftGeminiEnable = SG_DISABLE; 468 return_value = TWD_SetParam (pSoftGemini->hTWD, ¶m); 469 470 if (pSoftGemini->bDriverEnabled) 471 { 472 SoftGemini_DisableDriver(hSoftGemini); 473 } 474 475 break; 476 477 default: 478TRACE1(pSoftGemini->hReport, REPORT_SEVERITY_ERROR, " defualt :%d\n",SoftGeminiEnable); 479 return TI_NOK; 480 } 481 482 /* Pass to the new enable state */ 483 pSoftGemini->SoftGeminiEnable = SoftGeminiEnable; 484 485 if (TI_OK != return_value) 486 { 487TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_ERROR, " can't configure enable param to FW :\n"); 488 } 489 490 return return_value; 491} 492 493/*************************************************************************** 494* SoftGemini_setConfigParam * 495**************************************************************************** 496* DESCRIPTION: The function sets params 497* 498* INPUTS: pSoftGemini - the object 499* param - params to be configured 500***************************************************************************/ 501static void SoftGemini_setConfigParam(TI_HANDLE hSoftGemini, TI_UINT32 *param) 502{ 503 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 504 505 /* param[0] - SG parameter index, param[1] - SG parameter value */ 506 pSoftGemini->SoftGeminiParam.coexParams[(TI_UINT8)param[0]] = (TI_UINT32)param[1]; 507 pSoftGemini->SoftGeminiParam.paramIdx = (TI_UINT8)param[0]; 508} 509 510/*************************************************************************** 511* SoftGemini_printParams * 512**************************************************************************** 513* DESCRIPTION: Print SG Parameters. 514* 515* INPUTS: pSoftGemini - the object 516***************************************************************************/ 517void SoftGemini_printParams(TI_HANDLE hSoftGemini) 518{ 519#ifdef REPORT_LOG 520 521 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 522 TSoftGeminiParams *SoftGeminiParam = &pSoftGemini->SoftGeminiParam; 523 524 WLAN_OS_REPORT(("[0]: coexBtPerThreshold = %d\n", SoftGeminiParam->coexParams[SOFT_GEMINI_BT_PER_THRESHOLD])); 525 WLAN_OS_REPORT(("[1]: coexHv3MaxOverride = %d \n", SoftGeminiParam->coexParams[SOFT_GEMINI_HV3_MAX_OVERRIDE])); 526 WLAN_OS_REPORT(("[2]: coexBtNfsSampleInterval = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_BT_NFS_SAMPLE_INTERVAL])); 527 WLAN_OS_REPORT(("[3]: coexBtLoadRatio = %d (%)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_BT_LOAD_RATIO])); 528 WLAN_OS_REPORT(("[4]: coexAutoPsMode = %s \n", (SoftGeminiParam->coexParams[SOFT_GEMINI_AUTO_PS_MODE]?"Enabled":"Disabled"))); 529 WLAN_OS_REPORT(("[5]: coexAutoScanEnlargedNumOfProbeReqPercent = %d (%)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_AUTO_SCAN_PROBE_REQ])); 530 WLAN_OS_REPORT(("[6]: coexHv3AutoScanEnlargedScanWinodowPercent = %d (%)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_ACTIVE_SCAN_DURATION_FACTOR_HV3])); 531 WLAN_OS_REPORT(("[7]: coexAntennaConfiguration = %s (0 = Single, 1 = Dual) \n", (SoftGeminiParam->coexParams[SOFT_GEMINI_ANTENNA_CONFIGURATION]?"Dual":"Single"))); 532 WLAN_OS_REPORT(("[8]: coexMaxConsecutiveBeaconMissPrecent = %d (%)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_BEACON_MISS_PERCENT])); 533 WLAN_OS_REPORT(("[9]: coexAPRateAdapationThr = %d\n", SoftGeminiParam->coexParams[SOFT_GEMINI_RATE_ADAPT_THRESH])); 534 WLAN_OS_REPORT(("[10]: coexAPRateAdapationSnr = %d\n", SoftGeminiParam->coexParams[SOFT_GEMINI_RATE_ADAPT_SNR])); 535 WLAN_OS_REPORT(("[11]: coexWlanPsBtAclMasterMinBR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_MASTER_MIN_BR])); 536 WLAN_OS_REPORT(("[12]: coexWlanPsBtAclMasterMaxBR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_MASTER_MAX_BR])); 537 WLAN_OS_REPORT(("[13]: coexWlanPsMaxBtAclMasterBR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_MAX_BT_ACL_MASTER_BR])); 538 WLAN_OS_REPORT(("[14]: coexWlanPsBtAclSlaveMinBR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_SLAVE_MIN_BR])); 539 WLAN_OS_REPORT(("[15]: coexWlanPsBtAclSlaveMaxBR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_SLAVE_MAX_BR])); 540 WLAN_OS_REPORT(("[16]: coexWlanPsMaxBtAclSlaveBR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_MAX_BT_ACL_SLAVE_BR])); 541 WLAN_OS_REPORT(("[17]: coexWlanPsBtAclMasterMinEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_MASTER_MIN_EDR])); 542 WLAN_OS_REPORT(("[18]: coexWlanPsBtAclMasterMaxEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_MASTER_MAX_EDR])); 543 WLAN_OS_REPORT(("[19]: coexWlanPsMaxBtAclMasterEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_MAX_BT_ACL_MASTER_EDR])); 544 WLAN_OS_REPORT(("[20]: coexWlanPsBtAclSlaveMinEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_SLAVE_MIN_EDR])); 545 WLAN_OS_REPORT(("[21]: coexWlanPsBtAclSlaveMaxEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_SLAVE_MAX_EDR])); 546 WLAN_OS_REPORT(("[22]: coexWlanPsMaxBtAclSlaveEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_PS_MAX_BT_ACL_SLAVE_EDR])); 547 WLAN_OS_REPORT(("[23]: coexRxt = %d (usec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_RXT])); 548 WLAN_OS_REPORT(("[24]: coexTxt = %d (usec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_TXT])); 549 WLAN_OS_REPORT(("[25]: coexAdaptiveRxtTxt = %s \n", (SoftGeminiParam->coexParams[SOFT_GEMINI_ADAPTIVE_RXT_TXT]?"Enabled":"Disabled"))); 550 WLAN_OS_REPORT(("[26]: coexPsPollTimeout = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_PS_POLL_TIMEOUT])); 551 WLAN_OS_REPORT(("[27]: coexUpsdTimeout = %d (msec) \n", SoftGeminiParam->coexParams[SOFT_GEMINI_UPSD_TIMEOUT])); 552 WLAN_OS_REPORT(("[28]: coexWlanActiveBtAclMasterMinEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR])); 553 WLAN_OS_REPORT(("[29]: coexWlanActiveBtAclMasterMaxEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR])); 554 WLAN_OS_REPORT(("[30]: coexWlanActiveMaxBtAclMasterEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR])); 555 WLAN_OS_REPORT(("[31]: coexWlanActiveBtAclSlaveMinEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR])); 556 WLAN_OS_REPORT(("[32]: coexWlanActiveBtAclSlaveMaxEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR])); 557 WLAN_OS_REPORT(("[33]: coexWlanActiveMaxBtAclSlaveEDR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR])); 558 WLAN_OS_REPORT(("[34]: coexWlanActiveBtAclMinBR = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_ACTIVE_BT_ACL_MIN_BR])); 559 WLAN_OS_REPORT(("[35]: coexWlanActiveBtAclMinBr = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_ACTIVE_BT_ACL_MAX_BR])); 560 WLAN_OS_REPORT(("[36]: coexWlanActiveMaxBtAclBr = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_WLAN_ACTIVE_MAX_BT_ACL_BR])); 561 WLAN_OS_REPORT(("[37]: coexHv3AutoEnlargePassiveScanWindowPercent = %d (%)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_PASSIVE_SCAN_DURATION_FACTOR_HV3])); 562 WLAN_OS_REPORT(("[38]: coexA2DPAutoEnlargePassiveScanWindowPercent = %d (%) \n", SoftGeminiParam->coexParams[SOFT_GEMINI_PASSIVE_SCAN_DURATION_FACTOR_A2DP])); 563 WLAN_OS_REPORT(("[39]: coexPassiveScanA2dpBtTime = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_PASSIVE_SCAN_A2DP_BT_TIME])); 564 WLAN_OS_REPORT(("[40]: coexPassiveScanA2dpWlanTime = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_PASSIVE_SCAN_A2DP_WLAN_TIME])); 565 WLAN_OS_REPORT(("[41]: CoexHv3MaxServed = %d \n", SoftGeminiParam->coexParams[SOFT_GEMINI_HV3_MAX_SERVED])); 566 WLAN_OS_REPORT(("[42]: coexDhcpTime = %d (msec)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_DHCP_TIME])); 567 WLAN_OS_REPORT(("[43]: coexA2dpAutoScanEnlargedScanWinodowPercent = %d (%)\n", SoftGeminiParam->coexParams[SOFT_GEMINI_ACTIVE_SCAN_DURATION_FACTOR_A2DP])); 568 WLAN_OS_REPORT(("[44]: coexTempParam1 = %d \n", SoftGeminiParam->coexParams[SOFT_GEMINI_TEMP_PARAM_1])); 569 WLAN_OS_REPORT(("[45]: coexTempParam2 = %d \n", SoftGeminiParam->coexParams[SOFT_GEMINI_TEMP_PARAM_2])); 570 WLAN_OS_REPORT(("[46]: coexTempParam3 = %d \n", SoftGeminiParam->coexParams[SOFT_GEMINI_TEMP_PARAM_3])); 571 WLAN_OS_REPORT(("[47]: coexTempParam4 = %d \n", SoftGeminiParam->coexParams[SOFT_GEMINI_TEMP_PARAM_4])); 572 WLAN_OS_REPORT(("[48]: coexTempParam5 = %d \n", SoftGeminiParam->coexParams[SOFT_GEMINI_TEMP_PARAM_5])); 573 WLAN_OS_REPORT(("Enable mode : %s\n", SoftGemini_ConvertModeToString(pSoftGemini->SoftGeminiEnable))); 574 WLAN_OS_REPORT(("Driver Enabled : %s\n",(pSoftGemini->bDriverEnabled ? "YES" : "NO"))); 575 WLAN_OS_REPORT(("Protective mode : %s\n", (pSoftGemini->bProtectiveMode ? "ON" : "OFF"))); 576 WLAN_OS_REPORT(("PsPoll failure active : %s\n", (pSoftGemini->bPsPollFailureActive ? "YES" : "NO"))); 577 578#endif 579} 580 581/*************************************************************************** 582* SoftGemini_setParamsToFW * 583**************************************************************************** 584* DESCRIPTION: The function sets the FW with the appropriate parameters set. 585* 586* INPUTS: pSoftGemini - the object 587* 588* 589* OUTPUT: 590* 591* RETURNS: 592***************************************************************************/ 593static TI_STATUS SoftGemini_setParamsToFW(TI_HANDLE hSoftGemini, TSoftGeminiParams *softGeminiParams) 594{ 595 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 596 TTwdParamInfo param; 597 598 os_memoryCopy(pSoftGemini->hOs,¶m.content.SoftGeminiParam, softGeminiParams, sizeof(TSoftGeminiParams)); 599 param.paramType = TWD_SG_CONFIG_PARAM_ID; 600 return TWD_SetParam (pSoftGemini->hTWD, ¶m); 601} 602 603 604/*************************************************************************** 605* SoftGemini_EnableDriver * 606**************************************************************************** 607* DESCRIPTION: Activated when SG is enabled (after CLI or FW command) 608* 609* INPUTS: pSoftGemini - the object 610* 611***************************************************************************/ 612static TI_STATUS SoftGemini_EnableDriver(TI_HANDLE hSoftGemini) 613{ 614 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 615 TI_STATUS return_value = TI_OK; 616 617TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, "\n"); 618 619 pSoftGemini->bDriverEnabled = TI_TRUE; 620 621 /* Check if coexAutoPsMode - Co-ex is enabled to enter/exit P.S */ 622 if ( pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_AUTO_PS_MODE]) 623 { 624 SoftGemini_SetPS(pSoftGemini); 625 } 626 627 scr_setMode(pSoftGemini->hSCR, SCR_MID_SG); 628 629 return return_value; 630} 631 632/*************************************************************************** 633* SoftGemini_DisableDriver * 634**************************************************************************** 635* DESCRIPTION: Activated when SG is disabled (after CLI or FW command) 636* 637* INPUTS: pSoftGemini - the object 638* 639***************************************************************************/ 640static TI_STATUS SoftGemini_DisableDriver(TI_HANDLE hSoftGemini) 641{ 642 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 643 TI_STATUS return_value = TI_OK; 644 645TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, "\n"); 646 647 pSoftGemini->bDriverEnabled = TI_FALSE; 648 649 scr_setMode(pSoftGemini->hSCR, SCR_MID_NORMAL); 650 651 652 /* Check if coexAutoPsMode - Co-ex is enabled to enter/exit P.S */ 653 if ( pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_AUTO_PS_MODE]) 654 { 655 SoftGemini_unSetPS(pSoftGemini); 656 } 657 658 /* Undo the changes that were made when Protective mode was on */ 659 if (pSoftGemini->bProtectiveMode) 660 { 661 SoftGemini_DisableProtectiveMode(hSoftGemini); 662 } 663 664 return return_value; 665} 666 667/*************************************************************************** 668* SoftGemini_SetPS * 669**************************************************************************** 670* DESCRIPTION: Set Always PS to PowerMgr 671* 672* INPUTS: pSoftGemini - the object 673* 674***************************************************************************/ 675static TI_STATUS SoftGemini_SetPS(SoftGemini_t *pSoftGemini) 676{ 677 paramInfo_t param; 678 bssEntry_t *pBssInfo=NULL; 679 680 if (pSoftGemini->hCurrBss) 681 { 682 pBssInfo = currBSS_getBssInfo(pSoftGemini->hCurrBss); 683 } 684 else 685 { 686 TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_ERROR, "SoftGemini_SetPS: hCurrBss = NULL!!!\n"); 687 } 688 689 TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, "\n"); 690 691 if (pBssInfo) 692 { 693 if ((pBssInfo->band == RADIO_BAND_2_4_GHZ)) 694 { 695 TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, " SG-setPS: band == RADIO_BAND_2_4_GHZ"); 696 697 /* Set Params to Power Mgr for SG priority */ 698 param.paramType = POWER_MGR_POWER_MODE; 699 param.content.powerMngPowerMode.PowerMode = POWER_MODE_PS_ONLY; 700 param.content.powerMngPowerMode.PowerMngPriority = POWER_MANAGER_SG_PRIORITY; 701 powerMgr_setParam(pSoftGemini->hPowerMgr,¶m); 702 703 /* enable SG priority for Power Mgr */ 704 param.paramType = POWER_MGR_ENABLE_PRIORITY; 705 param.content.powerMngPriority = POWER_MANAGER_SG_PRIORITY; 706 return powerMgr_setParam(pSoftGemini->hPowerMgr,¶m); 707 } 708 else 709 { 710 TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, " SG-setPS: band == RADIO_BAND_5_GHZ"); 711 } 712 } 713 return TI_OK; 714} 715 716/*************************************************************************** 717* SoftGemini_unSetPS * 718**************************************************************************** 719* DESCRIPTION: unSet Always PS to PowerMgr 720* 721* INPUTS: pSoftGemini - the object 722* 723***************************************************************************/ 724static TI_STATUS SoftGemini_unSetPS(SoftGemini_t *pSoftGemini) 725{ 726 paramInfo_t param; 727 728TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, ", SG-unSetPS \n"); 729 730 /* disable SG priority for Power Mgr*/ 731 param.paramType = POWER_MGR_DISABLE_PRIORITY; 732 param.content.powerMngPriority = POWER_MANAGER_SG_PRIORITY; 733 return powerMgr_setParam(pSoftGemini->hPowerMgr,¶m); 734 735} 736 737/*************************************************************************** 738* SoftGemini_EnableProtectiveMode * 739**************************************************************************** 740* DESCRIPTION: Activated when FW inform us that protective mode is ON 741* 742* 743* INPUTS: pSoftGemini - the object 744* 745***************************************************************************/ 746void SoftGemini_EnableProtectiveMode(TI_HANDLE hSoftGemini) 747{ 748 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 749 paramInfo_t param; 750 751 pSoftGemini->bProtectiveMode = TI_TRUE; 752 753 /* set new configurations of SG roaming parameters */ 754 755 /* This code should be removed on SG stage 2 integration 756 currBSS_SGconfigureBSSLoss(pSoftGemini->hCurrBss,pSoftGemini->BSSLossCompensationPercent,TI_TRUE); */ 757 758 /* set new configurations of scan to scancncn */ 759 scanCncn_SGconfigureScanParams(pSoftGemini->hScanCncn,TI_TRUE, 760 (TI_UINT8)pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_AUTO_SCAN_PROBE_REQ], 761 pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_HV3_MAX_OVERRIDE], 762 pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_ACTIVE_SCAN_DURATION_FACTOR_HV3]); 763 764 /* Call the power manager to enter short doze */ 765TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, " SoftGemini_EnableProtectiveMode set SD"); 766 767 /* Set Params to Power Mgr for SG priority */ 768 param.paramType = POWER_MGR_POWER_MODE; 769 param.content.powerMngPowerMode.PowerMode = POWER_MODE_SHORT_DOZE; 770 param.content.powerMngPowerMode.PowerMngPriority = POWER_MANAGER_SG_PRIORITY; 771 powerMgr_setParam(pSoftGemini->hPowerMgr,¶m); 772} 773 774/*************************************************************************** 775* SoftGemini_DisableProtectiveMode * 776**************************************************************************** 777* DESCRIPTION: Activated when FW inform us that protective mode is OFF or SG is disabled 778* 779* INPUTS: pSoftGemini - the object 780* 781***************************************************************************/ 782void SoftGemini_DisableProtectiveMode(TI_HANDLE hSoftGemini) 783{ 784 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 785 786TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, "\n"); 787 788 pSoftGemini->bProtectiveMode = TI_FALSE; 789 790 SoftGemini_RemoveProtectiveModeParameters(hSoftGemini); 791} 792 793/*************************************************************************** 794* SoftGemini_DisableProtectiveMode * 795**************************************************************************** 796* DESCRIPTION: Called from SoftGemini_DisableProtectiveMode() when FW inform 797* us that protective mode is OFF or SG is disabled, or from 798* SoftGemini_unSetPSmode() when driver disconnects from AP. 799* 800* INPUTS: pSoftGemini - the object 801* 802***************************************************************************/ 803 804void SoftGemini_RemoveProtectiveModeParameters(TI_HANDLE hSoftGemini) 805{ 806 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 807 paramInfo_t param; 808 809TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, "\n"); 810 811 /* don't use the SG roaming parameters */ 812 currBSS_SGconfigureBSSLoss(pSoftGemini->hCurrBss,0,TI_FALSE); 813 814 /* don't use the SG scan parameters */ 815 scanCncn_SGconfigureScanParams(pSoftGemini->hScanCncn,TI_FALSE,0,0,0); 816 817 /* Call the power manager to exit short doze */ 818 /* Set Params to Power Mgr for SG priority */ 819 param.paramType = POWER_MGR_POWER_MODE; 820 param.content.powerMngPowerMode.PowerMode = POWER_MODE_PS_ONLY; 821 param.content.powerMngPowerMode.PowerMngPriority = POWER_MANAGER_SG_PRIORITY; 822 powerMgr_setParam(pSoftGemini->hPowerMgr,¶m); 823} 824 825/*************************************************************************** 826* SoftGemini_SenseIndicationCB * 827**************************************************************************** 828* DESCRIPTION: This is the the function which is called for sense mode indication from FW 829* (i.e. we are in SENSE mode and FW detects BT activity ) 830* SENSE_MODE_ENABLE - Indicates that FW detected BT activity 831* SENSE_MODE_DISABLE - Indicates that FW doesn't detect BT activity for a period of time 832* 833* INPUTS: pSoftGemini - the object 834* NOTE This function is located in the API for debug purposes 835***************************************************************************/ 836 837void SoftGemini_SenseIndicationCB( TI_HANDLE hSoftGemini, char* str, TI_UINT32 strLen ) 838{ 839 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 840 841 if (pSoftGemini->SoftGeminiEnable == SG_DISABLE) { 842TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_WARNING, ": SG is disabled, existing"); 843 return; 844 } 845 846 if ( (SENSE_MODE_ENABLE == *str) && (!pSoftGemini->bDriverEnabled) ) 847 { 848 SoftGemini_EnableDriver(hSoftGemini); 849 } 850 else if ( (SENSE_MODE_DISABLE == *str) && (pSoftGemini->bDriverEnabled) ) 851 { 852 SoftGemini_DisableDriver(hSoftGemini); 853 } 854} 855 856/*************************************************************************** 857* SoftGemini_ProtectiveIndicationCB * 858**************************************************************************** 859* DESCRIPTION: This is the the function which is called when FW starts Protective mode (i.e BT voice) 860* 861* PROTECTIVE_MODE_ON - FW is activated on protective mode (BT voice is running) 862* PROTECTIVE_MODE_OFF - FW is not activated on protective mode 863* 864* INPUTS: pSoftGemini - the object 865* NOTE This function is located in the API for debug purposes 866***************************************************************************/ 867 868void SoftGemini_ProtectiveIndicationCB( TI_HANDLE hSoftGemini, char* str, TI_UINT32 strLen ) 869{ 870 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 871 872TRACE1(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, " with 0x%x\n",*str); 873 874 if (SG_DISABLE != pSoftGemini->SoftGeminiEnable) 875 { 876 if ((!pSoftGemini->bProtectiveMode) && (PROTECTIVE_MODE_ON == *str)) 877 { 878 SoftGemini_EnableProtectiveMode(hSoftGemini); 879 } 880 else if ((pSoftGemini->bProtectiveMode) && (PROTECTIVE_MODE_OFF == *str)) 881 { 882 SoftGemini_DisableProtectiveMode(hSoftGemini); 883 } 884 else 885 { 886TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, " : Protective mode called when Protective mode is \n"); 887 } 888 } 889 else 890 { 891TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_WARNING, " : Protective mode called when SG mode is ? \n"); 892 } 893} 894 895/*************************************************************************** 896* SoftGemini_ConvertModeToString * 897****************************************************************************/ 898#ifdef REPORT_LOG 899 900char* SoftGemini_ConvertModeToString(ESoftGeminiEnableModes SoftGeminiEnable) 901{ 902 switch(SoftGeminiEnable) 903 { 904 case SG_PROTECTIVE: return "SG_PROTECTIVE"; 905 case SG_DISABLE: return "SG_DISABLE"; 906 case SG_OPPORTUNISTIC: return "SG_OPPORTUNISTIC"; 907 default: 908 return "ERROR"; 909 } 910} 911 912#endif 913 914/*************************************************************************** 915* SoftGemini_getSGMode * 916****************************************************************************/ 917ESoftGeminiEnableModes SoftGemini_getSGMode(TI_HANDLE hSoftGemini) 918{ 919 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 920 return pSoftGemini->SoftGeminiEnable; 921} 922 923/*************************************************************************** 924* SoftGemini_handleRecovery * 925**************************************************************************** 926* DESCRIPTION: The function reconfigures WHAL with the SG parameters. 927* 928* INPUTS: pSoftGemini - the object 929***************************************************************************/ 930TI_STATUS SoftGemini_handleRecovery(TI_HANDLE hSoftGemini) 931{ 932 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 933 ESoftGeminiEnableModes realSoftGeminiEnableMode; 934 935 realSoftGeminiEnableMode = pSoftGemini->SoftGeminiEnable; 936 /* Disable the SG */ 937 SoftGemini_setEnableParam(hSoftGemini, SG_DISABLE, TI_TRUE); 938 TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, "Disable SG \n"); 939 940 pSoftGemini->SoftGeminiEnable = realSoftGeminiEnableMode; 941 /* Set enable param */ 942 943 SoftGemini_setEnableParam(hSoftGemini, pSoftGemini->SoftGeminiEnable, TI_TRUE); 944 TRACE1(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, "Set SG to-%d\n", pSoftGemini->SoftGeminiEnable); 945 946 /* Config the params to FW */ 947 948 SoftGemini_setParamsToFW(hSoftGemini, &pSoftGemini->SoftGeminiParam); 949 /*SoftGemini_printParams(hSoftGemini);*/ 950 return TI_OK; 951} 952/*************************************************************************** 953* SoftGemini_startPsPollFailure * 954**************************************************************************** 955* DESCRIPTION: After Ps-Poll failure we disable the SG 956* 957* INPUTS: pSoftGemini - the object 958***************************************************************************/ 959void SoftGemini_startPsPollFailure(TI_HANDLE hSoftGemini) 960 { 961 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 962 963 TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, "\n"); 964 965 if ( (!pSoftGemini->bPsPollFailureActive) && (pSoftGemini->SoftGeminiParam.coexParams[SOFT_GEMINI_AUTO_PS_MODE] == TI_TRUE) ) 966 { 967 pSoftGemini->PsPollFailureLastEnableValue = pSoftGemini->SoftGeminiEnable; 968 969 /* Disable SG if needed */ 970 if ( pSoftGemini->SoftGeminiEnable != SG_DISABLE ) 971 { 972 SoftGemini_setEnableParam(hSoftGemini, SG_DISABLE, TI_FALSE); 973 } 974 975 pSoftGemini->bPsPollFailureActive = TI_TRUE; 976 } 977 else /* Calling SoftGemini_startPsPollFailure twice ? */ 978 { 979 TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_WARNING, "Calling SoftGemini_startPsPollFailure while bPsPollFailureActive is TRUE\n"); 980 } 981 } 982 983/*************************************************************************** 984* SoftGemini_endPsPollFailure * 985**************************************************************************** 986* DESCRIPTION: Return to normal behavior after the PsPoll failure 987* 988* INPUTS: pSoftGemini - the object 989***************************************************************************/ 990void SoftGemini_endPsPollFailure(TI_HANDLE hSoftGemini) 991{ 992 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini; 993 994 TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, "\n"); 995 996 if ( pSoftGemini->bPsPollFailureActive ) 997 { 998 pSoftGemini->bPsPollFailureActive = TI_FALSE; 999 1000 /* return to previous value */ 1001 if ( pSoftGemini->PsPollFailureLastEnableValue != SG_DISABLE ) 1002 { 1003 SoftGemini_setEnableParam(hSoftGemini, pSoftGemini->PsPollFailureLastEnableValue, TI_FALSE); 1004 } 1005 } 1006 else /* Calling SoftGemini_endPsPollFailure twice ? */ 1007 { 1008 TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_WARNING, "Calling SoftGemini_endPsPollFailure while bPsPollFailureActive is FALSE\n"); 1009 } 1010} 1011 1012 1013