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
74 static TI_STATUS SoftGemini_setEnableParam(TI_HANDLE hSoftGemini, ESoftGeminiEnableModes SoftGeminiEnable, TI_BOOL recovery);
75 static TI_STATUS SoftGemini_setParamsToFW(TI_HANDLE hSoftGemini, TSoftGeminiParams *SoftGeminiParam);
76 static TI_STATUS SoftGemini_EnableDriver(TI_HANDLE hSoftGemini);
77 static TI_STATUS SoftGemini_DisableDriver(TI_HANDLE hSoftGemini);
78 static TI_STATUS SoftGemini_SetPS(SoftGemini_t *pSoftGemini);
79 static TI_STATUS SoftGemini_unSetPS(SoftGemini_t *pSoftGemini);
80 static void SoftGemini_RemoveProtectiveModeParameters(TI_HANDLE hSoftGemini);
81 static void SoftGemini_setConfigParam(TI_HANDLE hSoftGemini, TI_UINT32 *param);
82 static void SoftGemini_EnableProtectiveMode(TI_HANDLE hSoftGemini);
83 static void SoftGemini_DisableProtectiveMode(TI_HANDLE hSoftGemini);
84 #ifdef REPORT_LOG
85 static char* SoftGemini_ConvertModeToString(ESoftGeminiEnableModes SoftGeminiEnable);
86 #endif
87
88 /********************************************************************************/
89 /* Interface functions Implementation. */
90 /********************************************************************************/
91 /************************************************************************
92 * SoftGemini_SetPSmode *
93 ************************************************************************
94 DESCRIPTION: SoftGemini module, called by the conn_Infra on connection
95 performs the following:
96 - Enables SG if needed
97 - Enables the SG power mode
98 INPUT: hSoftGemini - Handle to SoftGemini
99
100 OUTPUT:
101
102 RETURN:
103
104 ************************************************************************/
SoftGemini_SetPSmode(TI_HANDLE hSoftGemini)105 void 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 ************************************************************************
133 DESCRIPTION: SoftGemini module, called by the conn_Infra after disconnecting
134 performs the following:
135 - Disables the SG
136 - Disables the SG power mode
137 INPUT: hSoftGemini - Handle to SoftGemini
138
139 OUTPUT:
140
141 RETURN:
142
143 ************************************************************************/
SoftGemini_unSetPSmode(TI_HANDLE hSoftGemini)144 void 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 ************************************************************************
172 DESCRIPTION: SoftGemini module creation function, called by the config mgr in creation phase
173 performs the following:
174 - Allocate the SoftGemini handle
175
176 INPUT: hOs - Handle to OS
177
178
179 OUTPUT:
180
181 RETURN: Handle to the SoftGemini module on success, NULL otherwise
182
183 ************************************************************************/
SoftGemini_create(TI_HANDLE hOs)184 TI_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 ************************************************************************
202 DESCRIPTION: 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
207 INPUT: pStadHandles - The driver modules handles
208
209 OUTPUT:
210
211 RETURN: void
212 ************************************************************************/
SoftGemini_init(TStadHandlesList * pStadHandles)213 void 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
SoftGemini_SetDefaults(TI_HANDLE hSoftGemini,SoftGeminiInitParams_t * pSoftGeminiInitParams)229 TI_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 {
280 TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INIT, " SoftGemini_config() - configured successfully\n");
281 }
282 else
283 {
284 TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_ERROR, " SoftGemini_config() - Error configuring module \n");
285 }
286
287 return status;
288 }
289
290 /************************************************************************
291 * SoftGemini_destroy *
292 ************************************************************************
293 DESCRIPTION: 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
297 INPUT: hSoftGemini - SoftGemini handle.
298
299
300 OUTPUT:
301
302 RETURN: TI_OK on success, TI_NOK otherwise
303
304 ************************************************************************/
SoftGemini_destroy(TI_HANDLE hSoftGemini)305 TI_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 ***********************************************************************
321 DESCRIPTION: 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
325 INPUT: hSoftGemini - SoftGemini handle.
326 pParam - Pointer to the parameter
327
328 OUTPUT:
329
330 RETURN: TI_OK on success, TI_NOK otherwise
331
332 ************************************************************************/
SoftGemini_setParam(TI_HANDLE hSoftGemini,paramInfo_t * pParam)333 TI_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
339 TRACE1(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:
368 TRACE1(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 ***********************************************************************
378 DESCRIPTION: 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
382 INPUT: hSoftGemini - SoftGemini handle.
383
384
385 OUTPUT: pParam - Pointer to the parameter
386
387 RETURN: TI_OK on success, TI_NOK otherwise
388
389 ************************************************************************/
SoftGemini_getParam(TI_HANDLE hSoftGemini,paramInfo_t * pParam)390 TI_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 ***************************************************************************/
SoftGemini_setEnableParam(TI_HANDLE hSoftGemini,ESoftGeminiEnableModes SoftGeminiEnable,TI_BOOL recovery)413 static 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
419 TRACE0(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 {
443 TRACE0(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:
478 TRACE1(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 {
487 TRACE0(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 ***************************************************************************/
SoftGemini_setConfigParam(TI_HANDLE hSoftGemini,TI_UINT32 * param)501 static 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 ***************************************************************************/
SoftGemini_printParams(TI_HANDLE hSoftGemini)517 void 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 ***************************************************************************/
SoftGemini_setParamsToFW(TI_HANDLE hSoftGemini,TSoftGeminiParams * softGeminiParams)593 static 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 ***************************************************************************/
SoftGemini_EnableDriver(TI_HANDLE hSoftGemini)612 static TI_STATUS SoftGemini_EnableDriver(TI_HANDLE hSoftGemini)
613 {
614 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini;
615 TI_STATUS return_value = TI_OK;
616
617 TRACE0(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 ***************************************************************************/
SoftGemini_DisableDriver(TI_HANDLE hSoftGemini)640 static TI_STATUS SoftGemini_DisableDriver(TI_HANDLE hSoftGemini)
641 {
642 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini;
643 TI_STATUS return_value = TI_OK;
644
645 TRACE0(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 ***************************************************************************/
SoftGemini_SetPS(SoftGemini_t * pSoftGemini)675 static 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 ***************************************************************************/
SoftGemini_unSetPS(SoftGemini_t * pSoftGemini)724 static TI_STATUS SoftGemini_unSetPS(SoftGemini_t *pSoftGemini)
725 {
726 paramInfo_t param;
727
728 TRACE0(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 ***************************************************************************/
SoftGemini_EnableProtectiveMode(TI_HANDLE hSoftGemini)746 void 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 */
765 TRACE0(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 ***************************************************************************/
SoftGemini_DisableProtectiveMode(TI_HANDLE hSoftGemini)782 void SoftGemini_DisableProtectiveMode(TI_HANDLE hSoftGemini)
783 {
784 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini;
785
786 TRACE0(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
SoftGemini_RemoveProtectiveModeParameters(TI_HANDLE hSoftGemini)804 void SoftGemini_RemoveProtectiveModeParameters(TI_HANDLE hSoftGemini)
805 {
806 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini;
807 paramInfo_t param;
808
809 TRACE0(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
SoftGemini_SenseIndicationCB(TI_HANDLE hSoftGemini,char * str,TI_UINT32 strLen)837 void 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) {
842 TRACE0(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
SoftGemini_ProtectiveIndicationCB(TI_HANDLE hSoftGemini,char * str,TI_UINT32 strLen)868 void SoftGemini_ProtectiveIndicationCB( TI_HANDLE hSoftGemini, char* str, TI_UINT32 strLen )
869 {
870 SoftGemini_t *pSoftGemini = (SoftGemini_t *)hSoftGemini;
871
872 TRACE1(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 {
886 TRACE0(pSoftGemini->hReport, REPORT_SEVERITY_INFORMATION, " : Protective mode called when Protective mode is \n");
887 }
888 }
889 else
890 {
891 TRACE0(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
SoftGemini_ConvertModeToString(ESoftGeminiEnableModes SoftGeminiEnable)900 char* 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 ****************************************************************************/
SoftGemini_getSGMode(TI_HANDLE hSoftGemini)917 ESoftGeminiEnableModes 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 ***************************************************************************/
SoftGemini_handleRecovery(TI_HANDLE hSoftGemini)930 TI_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 ***************************************************************************/
SoftGemini_startPsPollFailure(TI_HANDLE hSoftGemini)959 void 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 ***************************************************************************/
SoftGemini_endPsPollFailure(TI_HANDLE hSoftGemini)990 void 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