1 /**************************************************************************** 2 **+-----------------------------------------------------------------------+** 3 **| |** 4 **| Copyright(c) 1998 - 2008 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 ****************************************************************************/ 35 36 /**************************************************************************** 37 * 38 * MODULE: GWSI_Synchronizer.c 39 * PURPOSE: GWSI Synchronizer used to synchronize between the CMD,INT,TX 40 * 41 ****************************************************************************/ 42 43 #include "commonTypes.h" 44 #include "memMngrEx.h" /* MSDU */ 45 #include "report.h" 46 #include "nrfsm.h" 47 48 49 /* First the GWSI interface needs the HAL definitions to use them in its API */ 50 #include "TNETWIF.h" 51 #include "TNETWArb.h" 52 #include "ElpCtrl.h" 53 #include "whalHwAccess.h" 54 55 #undef BUS_GUARD_SUPPORT 56 57 58 /*********************************************************************************** 59 Internal TNWTW Arbiter SM Module Internal function use 60 **************************************************************************************/ 61 static TI_STATUS TNETWArbSM_SeizeBusOnStart (TI_HANDLE hTNETWArbSM); 62 static TI_STATUS TNETWArbSM_SeizeBusOnHwAvail (TI_HANDLE hTNETWArbSM); 63 static TI_STATUS TNETWArbSM_SeizeBus (TI_HANDLE hTNETWArbSM, BOOL bHwAvail); 64 static TI_STATUS TNETWArbSM_ReturnPendingOnStart (TI_HANDLE hTNETWArbSM); 65 static TI_STATUS TNETWArbSM_ReturnPendingOnHwAvail (TI_HANDLE hTNETWArbSM); 66 static TI_STATUS TNETWArbSM_WakeHw (TI_HANDLE hTNETWArbSM); 67 static TI_STATUS TNETWArbSM_RunClientCb (TI_HANDLE hTNETWArbSM); 68 static TI_STATUS TNETWArbSM_ReseizeBus (TI_HANDLE hTNETWArbSM); 69 static TI_STATUS TNETWArbSM_PutSleepHw (TI_HANDLE hTNETWArbSM); 70 static TI_STATUS TNETWArbSM_WaitIRQHw (TI_HANDLE hTNETWArbSM); 71 static TI_STATUS TNETWArbSM_ExitWakeUp (TI_HANDLE hTNETWArbSM); 72 static TI_STATUS TNETWArbSM_ReleaseBus (TI_HANDLE hTNETWArbSM); 73 static TI_STATUS TNETWArbSM_DoNothing (TI_HANDLE hTNETWArbSM); 74 static TI_STATUS TNETWArbSM_ActionUnexpected (TI_HANDLE hTNETWArbSM); 75 76 #if defined(BUS_GUARD_SUPPORT) 77 static void TNETWArbSM_BusAvailCB (TI_HANDLE hTNETWArbSM); 78 #endif 79 80 81 /***************************************************************************** 82 ** Public Function prototypes ** 83 *****************************************************************************/ 84 85 /** 86 * \author Yossi Peery 87 * \date 15-May-2005\n 88 * \brief Creates the object of the PowerSrv. 89 * 90 * Function Scope \e Public.\n 91 * Parameters:\n 92 * 1) TI_HANDLE - handle to the OS.\n 93 * Return Value: TI_HANDLE - handle to the PowerSrv object.\n 94 */ 95 TI_HANDLE TNETWArbSM_Create (TI_HANDLE hOs) 96 { 97 TNETWArbSM_t *pTNETWArbSM = NULL; 98 TI_STATUS status; 99 100 pTNETWArbSM = (TNETWArbSM_t*) os_memoryAlloc (hOs, sizeof(TNETWArbSM_t)); 101 if (pTNETWArbSM == NULL) 102 { 103 WLAN_OS_REPORT(("%s(%d) - Memory Allocation Error!\n",__FILE__,__LINE__)); 104 return NULL; 105 } 106 107 os_memoryZero (hOs, pTNETWArbSM, sizeof(TNETWArbSM_t)); 108 109 pTNETWArbSM->hOS = hOs; 110 111 status = nrfsm_Create (hOs, &pTNETWArbSM->hFSM, TNETWARB_SM_STATE_NUM, TNETWARBSM_EVENT_NUM); 112 if (status != OK) 113 { 114 WLAN_OS_REPORT(("%s(%d) - Error in create FSM!\n",__FILE__,__LINE__)); 115 TNETWArbSM_Destroy(pTNETWArbSM); 116 return NULL; 117 } 118 119 return pTNETWArbSM; 120 } 121 122 123 /** 124 * \author Yossi Peery 125 * \date 15-May-2005\n 126 * \brief Destroy the object of the PowerSrvSM. 127 * 128 * Function Scope \e Public.\n 129 * Parameters:\n 130 * 1) TI_HANDLE - handle to the PowerSrv object.\n 131 * Return Value: TI_STATUS - OK on success else NOK.\n 132 */ 133 TI_STATUS TNETWArbSM_Destroy (TI_HANDLE hTNETWArbSM) 134 { 135 TNETWArbSM_t *pTNETWArbSM = (TNETWArbSM_t *)hTNETWArbSM; 136 TI_HANDLE hOs = pTNETWArbSM->hOS; 137 138 if (pTNETWArbSM->hFSM != NULL) 139 { 140 nrfsm_Unload (pTNETWArbSM->hFSM); 141 } 142 143 os_memoryFree (hOs, pTNETWArbSM, sizeof(TNETWArbSM_t)); 144 145 WLAN_OS_REPORT (("%s(%d) - TNETWArbSM destroyed\n", __FILE__, __LINE__)); 146 147 return OK; 148 } 149 150 151 /** 152 * \date 15-May-2005\n 153 * \brief Initialize the PowerSrvSM module. 154 * 155 * Function Scope \e Public.\n 156 * Parameters:\n 157 * 1) TI_HANDLE - handle to the PowerSrvSM object.\n 158 * 2) TI_HANDLE - handle to the Report object. 159 * 3) TI_HANDLE - handle to the whalCtrl object. 160 * 4) TI_HANDLE - handle to the QosMgr object. 161 * 5) TI_HANDLE - handle to the Mlme object. 162 * 6) TI_HANDLE - handle to the SiteMgr object. 163 * 7) PowerSrvInitParams_t - the Power Server initialize parameters.\n 164 * Return Value: TI_STATUS - OK on success else NOK.\n 165 */ 166 TI_STATUS TNETWArbSM_Init (TI_HANDLE hTNETWArbSM, TI_HANDLE hReport, TI_HANDLE hTNETWArb, TI_HANDLE hELPCtrl, TI_HANDLE hBusArbiter) 167 { 168 TNETWArbSM_t *pTNETWArbSM = (TNETWArbSM_t *)hTNETWArbSM; 169 170 nrfsm_action_cell_t smMatrix[TNETWARB_SM_STATE_NUM][TNETWARBSM_EVENT_NUM] = 171 { 172 /* 173 * State [TNETWARBSM_STATE_IDLE] 174 */ 175 { 176 /* {TNETWARBSM_EV_START} -> TNETWARBSM_STATE_WAIT_BUS */ 177 {TNETWARBSM_STATE_WAIT_BUS , TNETWArbSM_SeizeBusOnStart}, 178 179 /* {TNETWARBSM_EV_BUS_AVAIL} -> TNETWARBSM_STATE_IDLE */ 180 {TNETWARBSM_STATE_IDLE , TNETWArbSM_ActionUnexpected}, 181 182 /* {TNETWARBSM_EV_HW_AVAIL} -> TNETWARBSM_STATE_IDLE */ 183 {TNETWARBSM_STATE_WAIT_BUS , TNETWArbSM_SeizeBusOnHwAvail}, 184 185 /* {TNETWARBSM_EV_RESTART} -> TNETWARBSM_STATE_IDLE */ 186 {TNETWARBSM_STATE_WAIT_BUS , TNETWArbSM_ReseizeBus}, 187 188 /* {TNETWARBSM_EV_FINISH} -> TNETWARBSM_STATE_IDLE */ 189 {TNETWARBSM_STATE_IDLE , TNETWArbSM_ActionUnexpected}, 190 191 /* {TNETWARBSM_EV_TXN_CMPLT} -> TNETWARBSM_STATE_IDLE */ 192 {TNETWARBSM_STATE_IDLE , TNETWArbSM_ActionUnexpected} 193 }, 194 195 /* 196 * State [TNETWARBSM_STATE_WAIT_BUS] 197 */ 198 { 199 /* {TNETWARBSM_EV_START} -> TNETWARBSM_STATE_WAIT_BUS */ 200 {TNETWARBSM_STATE_WAIT_BUS , TNETWArbSM_ReturnPendingOnStart}, 201 202 /* {TNETWARBSM_EV_BUS_AVAIL} -> TNETWARBSM_STATE_WAIT_HW */ 203 {TNETWARBSM_STATE_WAIT_HW , TNETWArbSM_WakeHw}, 204 205 /* {TNETWARBSM_EV_HW_AVAIL} -> TNETWARBSM_STATE_WAIT_BUS */ 206 {TNETWARBSM_STATE_WAIT_BUS , TNETWArbSM_ReturnPendingOnHwAvail}, 207 208 /* {TNETWARBSM_EV_RESTART} -> TNETWARBSM_STATE_WAIT_BUS */ 209 {TNETWARBSM_STATE_WAIT_BUS , TNETWArbSM_ActionUnexpected}, 210 211 /* {TNETWARBSM_EV_FINISH} -> TNETWARBSM_STATE_WAIT_BUS */ 212 {TNETWARBSM_STATE_WAIT_BUS , TNETWArbSM_ActionUnexpected}, 213 214 /* {TNETWARBSM_EV_TXN_CMPLT} -> TNETWARBSM_STATE_WAIT_BUS */ 215 {TNETWARBSM_STATE_WAIT_BUS , TNETWArbSM_ActionUnexpected} 216 }, 217 218 /* 219 * State [TNETWARBSM_STATE_WAIT_HW] 220 */ 221 { 222 /* {TNETWARBSM_EV_START} -> TNETWARBSM_STATE_WAIT_HW */ 223 {TNETWARBSM_STATE_WAIT_HW , TNETWArbSM_ReturnPendingOnStart}, 224 225 /* {TNETWARBSM_EV_BUS_AVAIL} -> TNETWARBSM_STATE_WAIT_HW */ 226 {TNETWARBSM_STATE_WAIT_HW , TNETWArbSM_DoNothing}, 227 228 /* {TNETWARBSM_EV_HW_AVAIL} -> TNETWARBSM_STATE_WAIT_TXN1 */ 229 {TNETWARBSM_STATE_WAIT_TXN1 , TNETWArbSM_ExitWakeUp}, 230 231 /* {TNETWARBSM_EV_RESTART} -> TNETWARBSM_STATE_WAIT_HW */ 232 {TNETWARBSM_STATE_WAIT_HW , TNETWArbSM_ActionUnexpected}, 233 234 /* {TNETWARBSM_EV_FINISH} -> TNETWARBSM_STATE_WAIT_HW */ 235 {TNETWARBSM_STATE_WAIT_HW , TNETWArbSM_ActionUnexpected}, 236 237 /* {TNETWARBSM_EV_TXN_CMPLT} -> TNETWARBSM_STATE_WAIT_TXN1 */ 238 {TNETWARBSM_STATE_WAIT_TXN1 , TNETWArbSM_WaitIRQHw} 239 }, 240 241 /* 242 * State [TNETWARBSM_STATE_WAIT_BUS_AFTER_HW] 243 */ 244 { 245 /* {TNETWARBSM_EV_START} -> TNETWARBSM_STATE_WAIT_HW */ 246 {TNETWARBSM_STATE_WAIT_BUS_AFTER_HW , TNETWArbSM_ReturnPendingOnStart}, 247 248 /* {TNETWARBSM_EV_BUS_AVAIL} -> TNETWARBSM_STATE_WAIT_TXN1 */ 249 {TNETWARBSM_STATE_WAIT_TXN1 , TNETWArbSM_WaitIRQHw}, 250 251 /* {TNETWARBSM_EV_HW_AVAIL} -> TNETWARBSM_STATE_RUNNING */ 252 {TNETWARBSM_STATE_WAIT_BUS_AFTER_HW , TNETWArbSM_ReturnPendingOnHwAvail}, 253 254 /* {TNETWARBSM_EV_RESTART} -> TNETWARBSM_STATE_WAIT_HW */ 255 {TNETWARBSM_STATE_WAIT_BUS_AFTER_HW , TNETWArbSM_ActionUnexpected}, 256 257 /* {TNETWARBSM_EV_FINISH} -> TNETWARBSM_STATE_WAIT_HW */ 258 {TNETWARBSM_STATE_WAIT_BUS_AFTER_HW , TNETWArbSM_ActionUnexpected}, 259 260 /* {TNETWARBSM_EV_TXN_CMPLT} -> TNETWARBSM_STATE_WAIT_BUS_AFTER_HW */ 261 {TNETWARBSM_STATE_WAIT_BUS_AFTER_HW , TNETWArbSM_ActionUnexpected} 262 }, 263 264 /* 265 * State [TNETWARBSM_STATE_WAIT_TXN1] 266 */ 267 { 268 /* {TNETWARBSM_EV_START} -> TNETWARBSM_STATE_WAIT_TXN1 */ 269 {TNETWARBSM_STATE_WAIT_TXN1 , TNETWArbSM_ReturnPendingOnStart}, 270 271 /* {TNETWARBSM_EV_BUS_AVAIL} -> TNETWARBSM_STATE_WAIT_TXN1 */ 272 {TNETWARBSM_STATE_WAIT_TXN1 , TNETWArbSM_ActionUnexpected}, 273 274 /* {TNETWARBSM_EV_HW_AVAIL} -> TNETWARBSM_STATE_RUNNING */ 275 {TNETWARBSM_STATE_RUNNING , TNETWArbSM_RunClientCb}, 276 277 /* {TNETWARBSM_EV_RESTART} -> TNETWARBSM_STATE_WAIT_TXN1 */ 278 {TNETWARBSM_STATE_WAIT_TXN1 , TNETWArbSM_ActionUnexpected}, 279 280 /* {TNETWARBSM_EV_FINISH} -> TNETWARBSM_STATE_WAIT_TXN1 */ 281 {TNETWARBSM_STATE_WAIT_TXN1 , TNETWArbSM_ActionUnexpected}, 282 283 /* {TNETWARBSM_EV_TXN_CMPLT} -> TNETWARBSM_STATE_RUNNING */ 284 {TNETWARBSM_STATE_RUNNING , TNETWArbSM_RunClientCb} 285 }, 286 287 /* 288 * State [TNETWARBSM_STATE_RUNNING] 289 */ 290 { 291 /* {TNETWARBSM_EV_START} -> TNETWARBSM_STATE_RUNNING */ 292 {TNETWARBSM_STATE_RUNNING , TNETWArbSM_ReturnPendingOnStart}, 293 294 /* {TNETWARBSM_EV_BUS_AVAIL} -> TNETWARBSM_STATE_RUNNING */ 295 {TNETWARBSM_STATE_RUNNING , TNETWArbSM_ActionUnexpected}, 296 297 /* {TNETWARBSM_EV_HW_AVAIL} -> TNETWARBSM_STATE_RUNNING */ 298 {TNETWARBSM_STATE_RUNNING , TNETWArbSM_ReturnPendingOnHwAvail}, 299 300 /* {TNETWARBSM_EV_RESTART} -> TNETWARBSM_STATE_WAIT_BUS */ 301 {TNETWARBSM_STATE_WAIT_BUS , TNETWArbSM_ReseizeBus}, 302 303 /* {TNETWARBSM_EV_FINISH} -> TNETWARBSM_STATE_IDLE */ 304 {TNETWARBSM_STATE_WAIT_TXN2 , TNETWArbSM_PutSleepHw}, 305 306 /* {TNETWARBSM_EV_TXN_CMPLT} -> TNETWARBSM_STATE_RUNNING */ 307 {TNETWARBSM_STATE_RUNNING , TNETWArbSM_ActionUnexpected} 308 }, 309 310 /* 311 * State [TNETWARBSM_STATE_WAIT_TXN2] 312 */ 313 { 314 /* {TNETWARBSM_EV_START} -> TNETWARBSM_STATE_WAIT_TXN2 */ 315 {TNETWARBSM_STATE_WAIT_TXN2 , TNETWArbSM_ReturnPendingOnStart}, 316 317 /* {TNETWARBSM_EV_BUS_AVAIL} -> TNETWARBSM_STATE_WAIT_TXN2 */ 318 {TNETWARBSM_STATE_WAIT_TXN2 , TNETWArbSM_ActionUnexpected}, 319 320 /* {TNETWARBSM_EV_HW_AVAIL} -> TNETWARBSM_STATE_WAIT_TXN2 */ 321 {TNETWARBSM_STATE_WAIT_TXN2 , TNETWArbSM_ReturnPendingOnHwAvail}, 322 323 /* {TNETWARBSM_EV_RESTART} -> TNETWARBSM_STATE_WAIT_TXN2 */ 324 {TNETWARBSM_STATE_WAIT_TXN2 , TNETWArbSM_ActionUnexpected}, 325 326 /* {TNETWARBSM_EV_FINISH} -> TNETWARBSM_STATE_WAIT_TXN2 */ 327 {TNETWARBSM_STATE_WAIT_TXN2 , TNETWArbSM_ActionUnexpected}, 328 329 /* {TNETWARBSM_EV_TXN_CMPLT} -> TNETWARBSM_STATE_IDLE */ 330 {TNETWARBSM_STATE_IDLE , TNETWArbSM_ReleaseBus} 331 }, 332 }; 333 334 nrfsm_Config (pTNETWArbSM->hFSM, 335 (nrfsm_matrix_t)smMatrix, 336 TNETWARB_SM_STATE_NUM, 337 TNETWARBSM_EVENT_NUM); 338 339 pTNETWArbSM->hReport = hReport; 340 pTNETWArbSM->hELPCtrl = hELPCtrl; 341 pTNETWArbSM->hBusArbiter = hBusArbiter; 342 pTNETWArbSM->hTNETWArb = hTNETWArb; 343 344 /* TNETWArbSM start in IDLE State (No one is running in the TNETW Arbiter) */ 345 nrfsm_SetState (pTNETWArbSM->hFSM, TNETWARBSM_STATE_IDLE); 346 347 WLAN_REPORT_INIT (pTNETWArbSM->hReport, TNETW_ARBITER_MODULE_LOG, ("TNETWArbSM Initialized\n")); 348 349 return OK; 350 } 351 352 #define TNETWArbSM_SMEvent__(hSm,ev) \ 353 (nrfsm_Event (((TNETWArbSM_t*)hSm)->hFSM, ((TNETWArbSM_t*)hSm)->event = ev, hSm) == OK) \ 354 ? ((TNETWArbSM_t*)hSm)->SMlastOperationStatus \ 355 : TNETWIF_PENDING 356 357 358 /** 359 * \date 26-Oct-2005\n 360 * \brief trigger events from the outside of the module into the state machine. 361 * 362 * Function Scope \e Public.\n 363 * Parameters:\n 364 * 1) TI_HANDLE - handle to the TNETWArbSMf object.\n 365 * 2) TnetwArbSMEvents_e - the input events to the state machine. 366 * Return Value: TI_STATUS - OK on success else NOK.\n 367 * \b Description:\n 368 * this function will trigger the fsm generic state machine function. 369 */ 370 TI_STATUS TNETWArbSM_SMEvent (TI_HANDLE hTNETWArbSM, TnetwArbSMEvents_e event) 371 { 372 return TNETWArbSM_SMEvent__ (hTNETWArbSM, event); 373 } 374 375 376 static TI_STATUS TNETWArbSM_SeizeBusOnStart (TI_HANDLE hTNETWArbSM) 377 { 378 return TNETWArbSM_SeizeBus (hTNETWArbSM, FALSE); 379 } 380 381 382 static TI_STATUS TNETWArbSM_SeizeBusOnHwAvail (TI_HANDLE hTNETWArbSM) 383 { 384 return TNETWArbSM_SeizeBus (hTNETWArbSM, TRUE); 385 } 386 387 388 /** 389 * \date 26-Oct-2005\n 390 * \brief trigger events from the outside of the module into the state machine. 391 * 392 * Function Scope \e Public.\n 393 * Parameters:\n 394 * 1) TI_HANDLE - handle to the TNETWArbSMf object.\n 395 * 2) TnetwArbSMEvents_e - the input events to the state machine. 396 * Return Value: TI_STATUS - OK on success else NOK.\n 397 * \b Description:\n 398 * this function will trigger the fsm generic state machine function. 399 */ 400 static TI_STATUS TNETWArbSM_SeizeBus (TI_HANDLE hTNETWArbSM, BOOL bHwAvail) 401 { 402 TNETWArbSM_t *pTNETWArbSM = (TNETWArbSM_t *)hTNETWArbSM; 403 TI_STATUS status; 404 405 pTNETWArbSM->bHwAvail = bHwAvail; 406 407 #if defined(BUS_GUARD_SUPPORT) 408 status = BusArb_SeizeReq (pTNETWArbSM->hBusArbiter, 409 TNETWArbSM_BusAvailCB, 410 hTNETWArbSM); 411 #else 412 /* For now assume that we always have the bus */ 413 status = TNETWIF_COMPLETE; 414 #endif 415 416 /* In case we took the Bus then generate the BUS_AVAIL Event to the State Machine */ 417 if (status == TNETWIF_COMPLETE) 418 { 419 /* Then the status could be TNETWIF_COMPLETE at this end or also can be TNETWIF_PENDING if the HW is not Awake */ 420 TNETWArbSM_SMEvent__ (hTNETWArbSM, TNETWARBSM_EV_BUS_AVAIL); 421 } 422 /* Return ERROR or PENDING to Client */ 423 else 424 { 425 pTNETWArbSM->SMlastOperationStatus = TNETWIF_PENDING; 426 } 427 428 return OK; 429 } 430 431 432 /** 433 * \date 26-Oct-2005\n 434 * \brief trigger events from the outside of the module into the state machine. 435 * 436 * Function Scope \e Public.\n 437 * Parameters:\n 438 * 1) TI_HANDLE - handle to the TNETWArbSMf object.\n 439 * Return Value: TI_STATUS - OK on success else NOK.\n 440 * \b Description:\n 441 * this function will trigger the fsm generic state machine function. 442 */ 443 #if defined(BUS_GUARD_SUPPORT) 444 static void TNETWArbSM_BusAvailCB (TI_HANDLE hTNETWArbSM) 445 { 446 TNETWArbSM_SMEvent__ (hTNETWArbSM, TNETWARBSM_EV_BUS_AVAIL); 447 } 448 #endif 449 450 451 /** 452 * \date 26-Oct-2005\n 453 * \brief trigger events from the outside of the module into the state machine. 454 * 455 * Function Scope \e Public.\n 456 * Parameters:\n 457 * 1) TI_HANDLE - handle to the TNETWArbSMf object.\n 458 * 2) TnetwArbSMEvents_e - the input events to the state machine. 459 * Return Value: TI_STATUS - OK on success else NOK.\n 460 * \b Description:\n 461 * this function will trigger the fsm generic state machine function. 462 */ 463 static TI_STATUS TNETWArbSM_WakeHw (TI_HANDLE hTNETWArbSM) 464 { 465 TNETWArbSM_t *pTNETWArbSM = (TNETWArbSM_t *)hTNETWArbSM; 466 467 /* Call the ELP Controller module to wake the FW */ 468 switch (elpCtrl_Wake (pTNETWArbSM->hELPCtrl,pTNETWArbSM->bHwAvail)) 469 { 470 case ELPCTRL_AWAKE: 471 case ELPCTRL_WLAN_RDY_COMPLETE: 472 473 TNETWArbSM_SMEvent__ (hTNETWArbSM, TNETWARBSM_EV_TXN_CMPLT); 474 break; 475 476 case ELPCTRL_WLAN_RDY: 477 478 TNETWArbSM_SMEvent__ (hTNETWArbSM, TNETWARBSM_EV_BUS_AVAIL); 479 break; 480 481 case ELPCTRL_ASLEEP: 482 case ELPCTRL_COMPLETE: 483 pTNETWArbSM->SMlastOperationStatus = TNETWIF_PENDING; 484 break; 485 486 default: 487 pTNETWArbSM->SMlastOperationStatus = TNETWIF_ERROR; 488 break; 489 } 490 491 return OK; 492 } 493 494 495 /** 496 * \date 26-Oct-2005\n 497 * \brief trigger events from the outside of the module into the state machine. 498 * 499 * Function Scope \e Public.\n 500 * Parameters:\n 501 * 1) TI_HANDLE - handle to the TNETWArbSMf object.\n 502 * Return Value: TI_STATUS - OK on success else NOK.\n 503 * \b Description:\n 504 * this function will trigger the fsm generic state machine function. 505 */ 506 void TNETWArbSM_TxnCb (TI_HANDLE hTNETWArbSM) 507 { 508 TNETWArbSM_SMEvent__ (hTNETWArbSM, TNETWARBSM_EV_TXN_CMPLT); 509 } 510 511 512 /** 513 * \date 26-Oct-2005\n 514 * \brief trigger events from the outside of the module into the state machine. 515 * 516 * Function Scope \e Public.\n 517 * Parameters:\n 518 * 1) TI_HANDLE - handle to the TNETWArbSMf object.\n 519 * 2) TnetwArbSMEvents_e - the input events to the state machine. 520 * Return Value: TI_STATUS - OK on success else NOK.\n 521 * \b Description:\n 522 * this function will do the following: 523 * 1) Dequeue from the TODO Queue the first item or process request to start 524 * 2) Set the Dequeued instance to be the Running instance 525 * 3) Call the Client callback (must be the module start_instance ) 526 */ 527 static TI_STATUS TNETWArbSM_RunClientCb (TI_HANDLE TNETWArbSM) 528 { 529 TNETWArbSM_t *pTNETWArbSM = (TNETWArbSM_t *)TNETWArbSM; 530 TNETWArb_t *pTNETWArb = (TNETWArb_t *)pTNETWArbSM->hTNETWArb; 531 TNETWARB_INSTANCE_T *pTNETWARB_Inst; 532 533 /* Mark to ElpCtrl that the IRQ was received and it should get back to AWAKE */ 534 elpCtrl_ReceivedIRQ (pTNETWArbSM->hELPCtrl); 535 536 /* First Dequeue the instance from the TODO Queue */ 537 pTNETWARB_Inst = (TNETWARB_INSTANCE_T *)TNETWArb_Dequeue 538 (&pTNETWArb->TNETWArbiter_Queues[TODO_LIST_INDEX]); 539 540 WLAN_REPORT_INFORMATION (pTNETWArbSM->hReport, 541 TNETW_ARBITER_MODULE_LOG, 542 ("\n TNETWArbSM_ProcessToDoList: DeQueued pTNETWARB_Inst %x\n", 543 pTNETWARB_Inst)); 544 545 /* If the instance is already allocated then return error to Client caller */ 546 if (pTNETWARB_Inst == NULL) 547 { 548 WLAN_REPORT_ERROR (pTNETWArbSM->hReport, 549 TNETW_ARBITER_MODULE_LOG, 550 ("\nTNETWArbSM_RunClientCb: NULL instance\n")); 551 552 pTNETWArbSM->SMlastOperationStatus = TNETWIF_ERROR; 553 554 return OK; 555 } 556 557 /* Set it to be the Running instance right now */ 558 pTNETWArb->TNETWArb_Running_instance = pTNETWARB_Inst; 559 560 /* Call the Client Callback that must here be the start function of the module */ 561 pTNETWArbSM->SMlastOperationStatus = TNETWArb_CallClientCallback (pTNETWArbSM->hTNETWArb); 562 563 return OK; 564 } 565 566 567 /** 568 * \date 26-Oct-2005\n 569 * \brief trigger events from the outside of the module into the state machine. 570 * 571 * Function Scope \e Public.\n 572 * Parameters:\n 573 * 1) TI_HANDLE - handle to the TNETWArbSMf object.\n 574 * 2) TnetwArbSMEvents_e - the input events to the state machine. 575 * Return Value: TI_STATUS - OK on success else NOK.\n 576 * \b Description:\n 577 * this function will trigger the fsm generic state machine function. 578 */ 579 static TI_STATUS TNETWArbSM_ReseizeBus (TI_HANDLE hTNETWArbSM) 580 { 581 TNETWArbSM_t *pTNETWArbSM = (TNETWArbSM_t *)hTNETWArbSM; 582 TI_STATUS status; 583 584 #if defined(BUS_GUARD_SUPPORT) 585 status = BusArb_ReseizeReq (pTNETWArbSM->hBusArbiter, 586 TNETWArbSM_BusAvailCB, 587 hTNETWArbSM); 588 589 #else 590 /* For now assume that we always have the bus */ 591 status = TNETWIF_COMPLETE; 592 #endif 593 594 /* In the case we did not get the Bus now for second time then release the HW till we will get the Callback from the Bus ARbiter */ 595 if (status == TNETWIF_PENDING) 596 { 597 pTNETWArbSM->SMlastOperationStatus = TNETWIF_PENDING; 598 } 599 /* If we got TNETWIF_COMPLETE then we could get the Bus Semaphore again then send the BUS_AVAIL Event */ 600 else if (status == TNETWIF_COMPLETE) 601 { 602 /* Get the status again through sending the BUS_AVAIL Event to the TNETW ARbiter SM */ 603 /* Then the status could be TNETWIF_COMPLETE at this end or also can be TNETWIF_PENDING if the HW is not Awake */ 604 TNETWArbSM_SMEvent__ (hTNETWArbSM, TNETWARBSM_EV_BUS_AVAIL); 605 } 606 else 607 { 608 pTNETWArbSM->SMlastOperationStatus = TNETWIF_ERROR; 609 } 610 611 return OK; 612 } 613 614 615 /** 616 * \date 26-Oct-2005\n 617 * \brief trigger events from the outside of the module into the state machine. 618 * 619 * Function Scope \e Public.\n 620 * Parameters:\n 621 * 1) TI_HANDLE - handle to the TNETWArbSMf object.\n 622 * 2) TnetwArbSMEvents_e - the input events to the state machine. 623 * Return Value: TI_STATUS - OK on success else NOK.\n 624 * \b Description:\n 625 * this function will trigger the fsm generic state machine function. 626 */ 627 static TI_STATUS TNETWArbSM_PutSleepHw (TI_HANDLE hTNETWArbSM) 628 { 629 TNETWArbSM_t *pTNETWArbSM = (TNETWArbSM_t *)hTNETWArbSM; 630 631 pTNETWArbSM->bHwAvail = FALSE; 632 633 /* The HW is not needed anymore then the FW can go to sleep */ 634 if (elpCtrl_Sleep (pTNETWArbSM->hELPCtrl) == TNETWIF_COMPLETE) 635 { 636 return TNETWArbSM_SMEvent__ (hTNETWArbSM, TNETWARBSM_EV_TXN_CMPLT); 637 638 } 639 640 pTNETWArbSM->SMlastOperationStatus = TNETWIF_PENDING; 641 642 return OK; 643 } 644 645 646 static TI_STATUS TNETWArbSM_WaitIRQHw (TI_HANDLE hTNETWArbSM) 647 { 648 TNETWArbSM_t *pTNETWArbSM = (TNETWArbSM_t *)hTNETWArbSM; 649 650 /* check whether IRQ is about to happen or not, depending on the ElpCtrl Mux state */ 651 if ( elpCtrl_isIRQComing (pTNETWArbSM->hELPCtrl) ) 652 { 653 /* Please be patient - IRQ is about to come any minute */ 654 pTNETWArbSM->SMlastOperationStatus = TNETWIF_PENDING; 655 } 656 else /* No IRQ is supposed to arrive - roll SM to next position */ 657 { 658 TNETWArbSM_SMEvent__ (hTNETWArbSM, TNETWARBSM_EV_HW_AVAIL); 659 } 660 661 return OK; 662 } 663 664 static TI_STATUS TNETWArbSM_ExitWakeUp (TI_HANDLE hTNETWArbSM) 665 { 666 TNETWArbSM_t *pTNETWArbSM = (TNETWArbSM_t *)hTNETWArbSM; 667 668 /* Inform ElpCtrl that it should exit the wake up sequence */ 669 if ( elpCtrl_exitWakeUpSeq (pTNETWArbSM->hELPCtrl) == ELPCTRL_AWAKE) 670 { 671 /* We are already awake - send TXN_COMPLETE to roll SM forward */ 672 TNETWArbSM_SMEvent__ (hTNETWArbSM, TNETWARBSM_EV_TXN_CMPLT); 673 } 674 else /* Wait till we get TXN_COMPLETE event */ 675 { 676 pTNETWArbSM->SMlastOperationStatus = TNETWIF_PENDING; 677 } 678 679 return OK; 680 } 681 682 static TI_STATUS TNETWArbSM_ReleaseBus (TI_HANDLE hTNETWArbSM) 683 { 684 TNETWArbSM_t *pTNETWArbSM = (TNETWArbSM_t *)hTNETWArbSM; 685 TNETWArb_t *pTNETWArb = (TNETWArb_t *)pTNETWArbSM->hTNETWArb; 686 687 if (TNETWArb_getfirst (&pTNETWArb->TNETWArbiter_Queues[TODO_LIST_INDEX])) 688 { 689 TNETWArbSM_SMEvent__ (hTNETWArbSM, TNETWARBSM_EV_RESTART); 690 } 691 692 else 693 { 694 /* The Bus is not needed anymore */ 695 #if defined(BUS_GUARD_SUPPORT) 696 return BusArb_ReleaseReq (pTNETWArbSM->hBusArbiter, hTNETWArbSM); 697 #else 698 pTNETWArbSM->SMlastOperationStatus = TNETWIF_COMPLETE; 699 #endif 700 } 701 702 return OK; 703 } 704 705 706 707 /** 708 * \date 26-Oct-2005\n 709 * \brief trigger events from the outside of the module into the state machine. 710 * 711 * Function Scope \e Public.\n 712 * Parameters:\n 713 * 1) TI_HANDLE - handle to the TNETWArbSMf object.\n 714 * Return Value: TI_STATUS - OK on success else NOK.\n 715 * \b Description:\n 716 * this function will trigger the fsm generic state machine function. 717 */ 718 static TI_STATUS TNETWArbSM_ReturnPendingOnStart (TI_HANDLE hTNETWArbSM) 719 { 720 TNETWArbSM_t *pTNETWArbSM = (TNETWArbSM_t *)hTNETWArbSM; 721 722 /* 723 * In this case return PENDING to the client 724 * meaning that the client will not run immediately. 725 * (Bus Busy/Hw not awake or other client running ) 726 */ 727 pTNETWArbSM->SMlastOperationStatus = TNETWIF_PENDING; 728 729 return OK; 730 } 731 732 733 static TI_STATUS TNETWArbSM_ReturnPendingOnHwAvail (TI_HANDLE hTNETWArbSM) 734 { 735 TNETWArbSM_t *pTNETWArbSM = (TNETWArbSM_t *)hTNETWArbSM; 736 737 pTNETWArbSM->bHwAvail = TRUE; 738 739 pTNETWArbSM->SMlastOperationStatus = TNETWIF_PENDING; 740 741 return OK; 742 } 743 744 745 static TI_STATUS TNETWArbSM_DoNothing (TI_HANDLE hTNETWArbSM) 746 { 747 TNETWArbSM_t *pTNETWArbSM = (TNETWArbSM_t *)hTNETWArbSM; 748 749 pTNETWArbSM->SMlastOperationStatus = TNETWIF_PENDING; 750 751 return OK; 752 } 753 754 755 /** 756 * \date 26-Oct-2005\n 757 * \brief The Event received by the TNETW Arbiter Sm at this specific state is not expected. 758 * 759 * Function Scope \e Public.\n 760 * Parameters:\n 761 * 1) TI_HANDLE - handle to the TNETWArbSMf object.\n 762 * Return Value: TI_STATUS - TNETWIF_ERROR 763 * \b Description:\n 764 * This function will only set a Log to indicate that this event is not expected in the SM 765 */ 766 TI_STATUS TNETWArbSM_ActionUnexpected (TI_HANDLE hTNETWArbSM) 767 { 768 TNETWArbSM_t *pTNETWArbSM = (TNETWArbSM_t *)hTNETWArbSM; 769 UINT32 state; 770 771 if (nrfsm_GetState (pTNETWArbSM->hFSM, &state) == OK) 772 { 773 WLAN_REPORT_ERROR (pTNETWArbSM->hReport, 774 TNETW_ARBITER_MODULE_LOG, 775 ("\nTNETWArbSM_ActionUnexpected: state=%u, event=%u\n", 776 state, 777 pTNETWArbSM->event)); 778 } 779 780 pTNETWArbSM->SMlastOperationStatus = TNETWIF_ERROR; 781 782 return OK; 783 } 784
