• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * PowerSrv.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 powerSrv.c
35  *  \brief This is the powerSrv module implementation.
36  *  \author Assaf Azulay
37  *  \date 19-Oct-2005
38  */
39 
40 /****************************************************************************
41  *                                                                                                           *
42  *   MODULE:  powerSrv                                                                                  *
43  *   PURPOSE: powerSrv Module implementation.                                                   *
44  *                                                                                                              *
45  ****************************************************************************/
46 
47 #define __FILE_ID__  FILE_ID_113
48 #include "tidef.h"
49 #include "osApi.h"
50 #include "report.h"
51 #include "timer.h"
52 #include "PowerSrv.h"
53 #include "PowerSrv_API.h"
54 #include "PowerSrvSM.h"
55 #include "eventMbox_api.h"
56 
57 
58 /*****************************************************************************
59  **         Defines                                                         **
60  *****************************************************************************/
61 
62 
63 
64 /****************************************************************************************
65 **         Private Function prototypes                                                                              **
66 ****************************************************************************************/
67 static void     powerSrv802_11PsReport  (TI_HANDLE hPowerSrv, char* str , TI_UINT32 strLen);
68 TI_STATUS   powerSrvProcessRequest  (TI_HANDLE hPowerSrv, powerSrvMode_e requestMode);
69 void powerSrvCreatePssRequest (TI_HANDLE                    hPowerSrv,
70                                powerSrvMode_e              requestMode,
71                                powerSrvRequestState_e      requestState,
72                                E80211PsMode                psMode,
73                                TI_BOOL                        sendNullDataOnExit,
74                                void *                      powerSaveCBObject,
75                                powerSaveCmpltCB_t          powerSaveCompleteCB,
76                                powerSaveCmdResponseCB_t    powerSaveCmdResponseCB);
77 
78 /***************************************************************************************
79 **                                 Functions                                                                    **
80 ****************************************************************************************/
81 
82 
83 
84 /****************************************************************************************
85  *                        powerSrv_create                                                           *
86  ****************************************************************************************
87 DESCRIPTION: Power Server module creation function, called by the MAC Services create in creation phase
88                 performs the following:
89                 -   Allocate the Power Server handle
90                 -   Creates the Power Server State Machine
91 
92 INPUT:          - hOs - Handle to OS
93 
94 
95 OUTPUT:
96 
97 RETURN:     Handle to the Power Server module on success, NULL otherwise
98 ****************************************************************************************/
powerSrv_create(TI_HANDLE hOs)99 TI_HANDLE powerSrv_create(TI_HANDLE hOs)
100 {
101     powerSrv_t * pPowerSrv = NULL;
102     pPowerSrv = (powerSrv_t*) os_memoryAlloc (hOs, sizeof(powerSrv_t));
103     if ( pPowerSrv == NULL )
104     {
105         WLAN_OS_REPORT(("powerSrv_create - Memory Allocation Error!\n"));
106         return NULL;
107     }
108 
109     os_memoryZero (hOs, pPowerSrv, sizeof(powerSrv_t));
110 
111     pPowerSrv->hOS = hOs;
112 
113     /*creation of the State Machine*/
114     pPowerSrv->hPowerSrvSM = powerSrvSM_create(hOs);
115     if ( pPowerSrv->hPowerSrvSM == NULL )
116     {
117         WLAN_OS_REPORT(("powerSrv_create - Error in create PowerSrvSM module!\n"));
118         powerSrv_destroy(pPowerSrv);
119         return NULL;
120     }
121 
122     return pPowerSrv;
123 
124 }
125 
126 
127 /****************************************************************************************
128  *                        powerSrv_destroy                                                          *
129  ****************************************************************************************
130 DESCRIPTION: Power Server module destroy function, c
131                 -   delete Power Server allocation
132                 -   call the destroy function of the State machine
133 
134 INPUT:          - hPowerSrv - Handle to the Power Server
135 
136 
137 OUTPUT:
138 
139 RETURN:    TI_STATUS - TI_OK on success else TI_NOK.
140 ****************************************************************************************/
powerSrv_destroy(TI_HANDLE hPowerSrv)141 TI_STATUS powerSrv_destroy(TI_HANDLE hPowerSrv)
142 {
143     powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv;
144 
145     if ( pPowerSrv->hPowerSrvSM != NULL )
146     {
147         powerSrvSM_destroy(pPowerSrv->hPowerSrvSM);
148     }
149 
150     os_memoryFree(pPowerSrv->hOS , pPowerSrv , sizeof(powerSrv_t));
151 
152     return TI_OK;
153 }
154 
155 
156 /****************************************************************************************
157  *                        powerSrvSM_init                                                           *
158  ****************************************************************************************
159 DESCRIPTION: Power Server module initialize function, called by the MAC Services in initialization phase
160                 performs the following:
161                 -   init the Power server to active state.
162                 -   call the init function of the state machine.
163 
164 INPUT:      - hPowerSrv         - handle to the PowerSrv object.
165             - hReport           - handle to the Report object.
166             - hEventMbox        - handle to the Event Mbox object.
167             - hCmdBld           - handle to the Command Builder object.
168 
169 OUTPUT:
170 RETURN:    TI_STATUS - TI_OK on success else TI_NOK.
171 ****************************************************************************************/
powerSrv_init(TI_HANDLE hPowerSrv,TI_HANDLE hReport,TI_HANDLE hEventMbox,TI_HANDLE hCmdBld,TI_HANDLE hTimer)172 TI_STATUS powerSrv_init (TI_HANDLE hPowerSrv,
173                          TI_HANDLE hReport,
174                          TI_HANDLE hEventMbox,
175                          TI_HANDLE hCmdBld,
176                          TI_HANDLE hTimer)
177 {
178     powerSrv_t* pPowerSrv = (powerSrv_t*)hPowerSrv;
179 
180     pPowerSrv->hReport = hReport;
181     pPowerSrv->hEventMbox = hEventMbox;
182 
183     /*
184     init PowerSrv state machine.
185     */
186     powerSrvSM_init (pPowerSrv->hPowerSrvSM, hReport, hCmdBld, hTimer);
187 
188     pPowerSrv->currentMode = USER_MODE;
189 
190     /*init all request with init values*/
191     powerSrvCreatePssRequest(hPowerSrv,
192                              USER_MODE,
193                              HANDLED_REQUEST,
194                              POWER_SAVE_OFF,
195                              TI_FALSE,
196                              NULL,
197                              NULL,
198                              NULL);
199     powerSrvCreatePssRequest(hPowerSrv,
200                              DRIVER_MODE,
201                              HANDLED_REQUEST,
202                              POWER_SAVE_OFF,
203                              TI_FALSE,
204                              NULL,
205                              NULL,
206                              NULL);
207     pPowerSrv->userLastRequestMode = (powerSrvMode_e)POWER_SAVE_OFF;
208     pPowerSrv->pCurrentRequest  = & pPowerSrv->userRequest;
209 
210     /*
211     register for Event
212     */
213 
214 	eventMbox_RegisterEvent (hEventMbox,
215                              TWD_OWN_EVENT_PS_REPORT,
216                              (void *)powerSrv802_11PsReport,
217                              hPowerSrv);
218 
219     eventMbox_UnMaskEvent (hEventMbox, TWD_OWN_EVENT_PS_REPORT, NULL, NULL);
220 
221     TRACE0(pPowerSrv->hReport, REPORT_SEVERITY_INIT, "powerSrv Initialized \n");
222 
223     return TI_OK;
224 }
225 
226 /****************************************************************************************
227  *                        powerSrv_restart															*
228  ****************************************************************************************
229 DESCRIPTION: Restart the scan SRV module upon recovery.
230 				-	init the Power server to active state.
231 				-	call the init function of the state machine.
232 
233 INPUT:     	- hPowerSrv 			- handle to the PowerSrv object.
234 
235 OUTPUT:
236 RETURN:    TI_STATUS - TI_OK on success else TI_NOK.
237 ****************************************************************************************/
powerSrv_restart(TI_HANDLE hPowerSrv)238 TI_STATUS powerSrv_restart(	TI_HANDLE hPowerSrv)
239 {
240     powerSrv_t* pPowerSrv = (powerSrv_t*)hPowerSrv;
241 	PowerSrvSM_t *pPowerSrvSM = (PowerSrvSM_t*)pPowerSrv->hPowerSrvSM;
242     /*
243     init PowerSrv state machine.
244     */
245 	/*
246 	the PowerSrvSM start in active mode (POWER_SRV_STATE_ACTIVE)
247 	the PowerSrvSM::currentState must be sync with the PowerSrv::desiredPowerModeProfile (POWER_MODE_ACTIVE).
248 	*/
249 	pPowerSrvSM->currentState = POWER_SRV_STATE_ACTIVE;
250     pPowerSrv->currentMode = USER_MODE;
251     tmr_StopTimer (pPowerSrvSM->hPwrSrvSmTimer);
252 
253     /*init all request with init values*/
254     powerSrvCreatePssRequest(hPowerSrv,
255 							USER_MODE,
256 							HANDLED_REQUEST,
257 							POWER_SAVE_OFF,
258 							TI_FALSE,
259 							NULL,
260 							NULL,
261 							NULL);
262     powerSrvCreatePssRequest(hPowerSrv,
263 							DRIVER_MODE,
264 							HANDLED_REQUEST,
265 							POWER_SAVE_OFF,
266 							TI_FALSE,
267 							NULL,
268 							NULL,
269 							NULL);
270 	pPowerSrv->userLastRequestMode = (powerSrvMode_e)POWER_SAVE_OFF;
271     pPowerSrv->pCurrentRequest 	= & pPowerSrv->userRequest;
272 
273 	/*
274 	register for Event
275 	*/
276 	eventMbox_RegisterEvent (pPowerSrv->hEventMbox,
277 							 TWD_OWN_EVENT_PS_REPORT,
278 							 (void *)powerSrv802_11PsReport,
279 							 hPowerSrv);
280 
281 	eventMbox_UnMaskEvent (pPowerSrv->hEventMbox, TWD_OWN_EVENT_PS_REPORT, NULL, NULL);
282 
283     return TI_OK;
284 }
285 
286 /****************************************************************************************
287  *                        powerSrv_config                                                           *
288  ****************************************************************************************
289 DESCRIPTION: Power Server module configuration function, called by the MAC Services in configure phase
290                 performs the following:
291                 -   init the Power server to active state.
292                 -   call the init function of the state machine.
293 
294 INPUT:      - hPowerSrv             - handle to the PowerSrv object.
295             - pPowerSrvInitParams   - the Power Server initialize parameters.
296 
297 OUTPUT:
298 RETURN:    TI_STATUS - TI_OK on success else TI_NOK.
299 ****************************************************************************************/
powerSrv_config(TI_HANDLE hPowerSrv,TPowerSrvInitParams * pPowerSrvInitParams)300 TI_STATUS powerSrv_config(  TI_HANDLE               hPowerSrv,
301                             TPowerSrvInitParams    *pPowerSrvInitParams)
302 {
303     powerSrv_t* pPowerSrv = (powerSrv_t*)hPowerSrv;
304 
305     /*
306     config PowerSrv state machine.
307     */
308     powerSrvSM_config(   pPowerSrv->hPowerSrvSM,
309                          pPowerSrvInitParams);
310 
311     return TI_OK;
312 }
313 /****************************************************************************************
314  *                        powerSrv_SetPsMode                                                            *
315  ****************************************************************************************
316 DESCRIPTION: This function is a user mode request from the Power Save Server.
317               it will create a Request from the "USER_REQUEST" and will try to perform the user request for PS/Active.
318               this will be done in respect of priority to Driver request.
319 
320 INPUT:      - hPowerSrv                         - handle to the PowerSrv object.
321             - psMode                            - Power save/Active request
322             - sendNullDataOnExit                -
323             - powerSaveCBObject     - handle to the Callback function module.
324             - powerSaveCompleteCB           - Callback function - for success/faild notification.
325 OUTPUT:
326 RETURN:    TI_STATUS - TI_OK / PENDING / TI_NOK.
327 ****************************************************************************************/
powerSrv_SetPsMode(TI_HANDLE hPowerSrv,E80211PsMode psMode,TI_BOOL sendNullDataOnExit,void * powerSaveCBObject,powerSaveCmpltCB_t powerSaveCompleteCB,powerSaveCmdResponseCB_t powerSavecmdResponseCB)328 TI_STATUS powerSrv_SetPsMode(   TI_HANDLE                   hPowerSrv,
329                                 E80211PsMode                psMode,
330                                 TI_BOOL                        sendNullDataOnExit,
331                                 void *                      powerSaveCBObject,
332                                 powerSaveCmpltCB_t          powerSaveCompleteCB,
333                                 powerSaveCmdResponseCB_t    powerSavecmdResponseCB)
334 
335 {
336     powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv;
337     TI_STATUS status;
338 /*creating the request from type - "user"*/
339     powerSrvCreatePssRequest(hPowerSrv,
340                              USER_MODE,
341                              NEW_REQUEST,
342                              psMode,
343                              sendNullDataOnExit,
344                              powerSaveCBObject,
345                              powerSaveCompleteCB,
346                              powerSavecmdResponseCB);
347 
348 /*the request will be handled if the Power server is not in Driver mode.*/
349     if ( pPowerSrv->currentMode==USER_MODE )
350     {
351         status = powerSrvProcessRequest(hPowerSrv,pPowerSrv->userRequest.requestMode);
352     }
353     else/*driver mode*/
354     {
355         pPowerSrv->userRequest.requestState = PENDING_REQUEST;
356         status = POWER_SAVE_802_11_PENDING;
357     }
358     return status;
359 
360 }
361 
362 
363 /****************************************************************************************
364  *                        powerSrv_ReservePS                                                        *
365  ****************************************************************************************
366 DESCRIPTION: This function is a driver mode request to set the 802.11 Power Save state and reserve the module.
367               The module should not be in driver mode when this request is made.
368               If this function is called when the module is already in driver mode the result is unexpected.
369               If the request cannot be fulfilled because of currently executing user mode request,
370               then the function will return PENDING and the powerSaveCompleteCB function will be called when the request is fulfilled.
371               If the request can be fulfilled immediately and the Power Save state required is the current state
372               (This is always the case when PSMode = KEEP_CURRENT),
373               then the module will be reserved and the function will return TI_OK - the callback function will not be called.??
374               If the request can be fulfilled immediately and requires a Power Save state transition,
375               then the return value will be TI_OK and the powerSaveCompleteCB function will be called by the Power Save Server
376               when the request is complete.
377 
378 INPUT:      - hPowerSrv                         - handle to the PowerSrv object.
379             - psMode                            - Power save/Active request
380             - sendNullDataOnExit                -
381             - powerSaveCBObject     - handle to the Callback function module.
382             - powerSaveCompleteCB           - Callback function - for success/faild notification.
383 OUTPUT:
384 RETURN:    TI_STATUS - TI_OK / PENDING / TI_NOK.
385 ****************************************************************************************/
powerSrv_ReservePS(TI_HANDLE hPowerSrv,E80211PsMode psMode,TI_BOOL sendNullDataOnExit,void * powerSaveCBObject,powerSaveCmpltCB_t powerSaveCompleteCB)386 TI_STATUS powerSrv_ReservePS(   TI_HANDLE               hPowerSrv,
387                                 E80211PsMode            psMode,
388                                 TI_BOOL                    sendNullDataOnExit,
389                                 void *                  powerSaveCBObject,
390                                 powerSaveCmpltCB_t      powerSaveCompleteCB)
391 {
392     powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv;
393     TI_STATUS status;
394 
395     /*creating the request from type - "driver"*/
396     if ( psMode == POWER_SAVE_KEEP_CURRENT )
397     {
398         psMode = pPowerSrv->userRequest.psMode;
399     }
400 
401     powerSrvCreatePssRequest(hPowerSrv,
402                              DRIVER_MODE,
403                              NEW_REQUEST,
404                              psMode,
405                              sendNullDataOnExit,
406                              powerSaveCBObject,
407                              powerSaveCompleteCB,
408                              NULL);
409     /*try to execute the request*/
410     status = powerSrvProcessRequest(hPowerSrv,pPowerSrv->driverRequest.requestMode);
411     return status;
412 
413 }
414 
415 
416 /****************************************************************************************
417  *                        powerSrv_ReleasePS                                                        *
418  ****************************************************************************************
419 DESCRIPTION: This function is used to release a previous driver mode request issued with the ReservPS API.
420               it creates a Driver request and the server act like it is a normal driver request.
421               the server will send the request with a simple optimization - if there is a pending or
422               new user request - the request will be added in the driver request, in this way when the
423               user request  will be executed there will be nothing to do, in the same manner if there
424               are no user / driver request to execute we will send the last user request in Driver mode.
425 
426 
427 
428 
429 INPUT:      - hPowerSrv                         - handle to the PowerSrv object.
430             - sendNullDataOnExit                -
431             - powerSaveCBObject     - handle to the Callback function module.
432             - powerSaveCompleteCB           - Callback function - for success/faild notification.
433 OUTPUT:
434 RETURN:    TI_STATUS - TI_OK / PENDING / TI_NOK.
435 ****************************************************************************************/
powerSrv_ReleasePS(TI_HANDLE hPowerSrv,TI_BOOL sendNullDataOnExit,void * powerSaveCBObject,powerSaveCmpltCB_t powerSaveCompleteCB)436 TI_STATUS powerSrv_ReleasePS(   TI_HANDLE                   hPowerSrv,
437                                 TI_BOOL                        sendNullDataOnExit,
438                                 void *                          powerSaveCBObject,
439                                 powerSaveCmpltCB_t              powerSaveCompleteCB)
440 {
441     powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv;
442     TI_STATUS status;
443 
444     /*creating the request from type - "driver"*/
445 
446     if (pPowerSrv->driverRequest.requestMode == POWER_SAVE_802_11_PENDING)
447     {
448         powerSrvCreatePssRequest(hPowerSrv,
449                                  DRIVER_MODE,
450                                  HANDLED_REQUEST,
451                                  POWER_SAVE_OFF,
452                                  TI_FALSE,
453                                  NULL,
454                                  NULL,
455                                  NULL);
456         return POWER_SAVE_802_11_IS_CURRENT;
457     }
458 
459     /*creating the request from type - "driver"*/
460     powerSrvCreatePssRequest(hPowerSrv,
461                              DRIVER_MODE,
462                              NEW_REQUEST,
463                              POWER_SAVE_KEEP_CURRENT,
464                              sendNullDataOnExit,
465                              powerSaveCBObject,
466                              powerSaveCompleteCB,
467                              NULL);
468     if ( pPowerSrv->userRequest.requestState == NEW_REQUEST ||
469          pPowerSrv->userRequest.requestState == PENDING_REQUEST )
470     {
471         pPowerSrv->driverRequest.psMode = pPowerSrv->userRequest.psMode;
472     }
473     else
474     {
475         pPowerSrv->driverRequest.psMode = (E80211PsMode)pPowerSrv->userLastRequestMode;
476     }
477 
478 
479 
480     status = powerSrvProcessRequest(hPowerSrv,pPowerSrv->driverRequest.requestMode);
481     /*if the request was not executed we should not change the mode*/
482     if (status != POWER_SAVE_802_11_PENDING)
483     {
484         pPowerSrv->currentMode = USER_MODE;
485     }
486     return status;
487 }
488 
489 
490 
491 /****************************************************************************************
492  *                        powerSrv_getPsStatus                                                       *
493  *****************************************************************************************
494 DESCRIPTION: This function returns the true state of power.
495 
496 INPUT:      - hPowerSrv                         - handle to the PowerSrv object.
497 
498 OUTPUT:
499 RETURN:    TI_BOOL - true if the SM is in PS state -  false otherwise
500 ****************************************************************************************/
powerSrv_getPsStatus(TI_HANDLE hPowerSrv)501 TI_BOOL powerSrv_getPsStatus(TI_HANDLE hPowerSrv)
502 {
503     powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv;
504     PowerSrvSMStates_e smState;
505     smState = powerSrvSM_getCurrentState(pPowerSrv->hPowerSrvSM);
506     return(smState == POWER_SRV_STATE_PS );
507 }
508 
509 
510 /****************************************************************************************
511 *                        powerSrv_SetRateModulation                                                         *
512 *****************************************************************************************
513 DESCRIPTION: Sets the rate modulation according to the current Radio Mode.
514 
515 INPUT:      - hPowerSrv                         - handle to the PowerSrv object.
516            - dot11mode_e - The current radio mode (A or G)
517 
518 OUTPUT:
519 RETURN:    TI_BOOL - true if the SM is in PS state -  false otherwise
520 ****************************************************************************************/
powerSrv_SetRateModulation(TI_HANDLE hPowerSrv,TI_UINT16 rate)521 void powerSrv_SetRateModulation(TI_HANDLE hPowerSrv, TI_UINT16  rate)
522 {
523     powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv;
524     powerSrvSM_setRateModulation(pPowerSrv->hPowerSrvSM,rate);
525 
526     return;
527 }
528 
529 /**
530  * \Gets the rate modulation.
531  *
532  * Function Scope \e Public.\n
533  * Parameters:\n
534  * 1) TI_HANDLE - handle to the PowerSrvSM object.\n
535  * 2) dot11mode_e - The current radio mode (A or G)
536  * Return: None.\n
537  */
powerSrv_GetRateModulation(TI_HANDLE hPowerSrv)538 TI_UINT32 powerSrv_GetRateModulation(TI_HANDLE hPowerSrv)
539 {
540     powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv;
541     return powerSrvSM_getRateModulation(pPowerSrv->hPowerSrvSM);
542 }
543 
544 
545 
546 
547 /*****************************************************************************
548  **         Private Function prototypes                                                             **
549  *****************************************************************************/
550 
551 
552 /****************************************************************************************
553  *                        powerSrv802_11PsReport                                                    *
554  ****************************************************************************************
555 DESCRIPTION:  This function is the call back for the TWD control when a PS event triggered
556               This function is responsible for the process "keep alive".
557               the function handles the event and sends it to the state machine, after sending the events
558               the function handles the next request with respect to driver request priority.
559               if a request is already done then we will call the request call back (if exist!).
560 
561 
562 
563 
564 INPUT:      - hPowerSrv                         - handle to the PowerSrv object.
565             - str                               - Event string
566             - strLen                            - string length
567 
568 OUTPUT:
569 RETURN:    void.
570 ****************************************************************************************/
powerSrv802_11PsReport(TI_HANDLE hPowerSrv,char * str,TI_UINT32 strLen)571 static void powerSrv802_11PsReport(TI_HANDLE hPowerSrv, char* str , TI_UINT32 strLen)
572 {
573     powerSrv_t *    pPowerSrv = (powerSrv_t*)hPowerSrv;
574     TI_UINT8           PowerSaveStatus;
575     E80211PsMode    currentPsMode;
576     TI_STATUS       status = TI_OK;
577 
578     /*copy the event*/
579     os_memoryCopy(pPowerSrv->hOS, (void *)&PowerSaveStatus, (void *)str, strLen);
580 
581     TRACE1( pPowerSrv->hReport, REPORT_SEVERITY_INFORMATION, "PS callback with status: %d\n", PowerSaveStatus);
582 
583     /* Handling the event*/
584     switch ( (EventsPowerSave_e)PowerSaveStatus )
585     {
586     case ENTER_POWER_SAVE_FAIL:
587     case EXIT_POWER_SAVE_FAIL:
588         TRACE0( pPowerSrv->hReport, REPORT_SEVERITY_WARNING, "Power save enter or exit failed!\n");
589         powerSrvSM_SMApi(pPowerSrv->hPowerSrvSM,POWER_SRV_EVENT_FAIL);
590         break;
591 
592     case ENTER_POWER_SAVE_SUCCESS:
593 	case EXIT_POWER_SAVE_SUCCESS:
594         powerSrvSM_SMApi(pPowerSrv->hPowerSrvSM,POWER_SRV_EVENT_SUCCESS);
595         /*update the last user request if the request was a user request*/
596         if ( pPowerSrv->currentMode == USER_MODE )
597         {
598             pPowerSrv->userLastRequestMode= (powerSrvMode_e)pPowerSrv->userRequest.psMode;
599         }
600         break;
601 
602     default:
603         TRACE1( pPowerSrv->hReport, REPORT_SEVERITY_ERROR, "Unrecognized status at PS callback %d\n", PowerSaveStatus );
604         break;
605     }
606 
607     /*this reflects the true power save state - power save IFF state machine in PS state.*/
608     if ( (EventsPowerSave_e)PowerSaveStatus == ENTER_POWER_SAVE_SUCCESS )
609     {
610         currentPsMode = POWER_SAVE_ON;
611     }
612     else
613     {
614         currentPsMode = POWER_SAVE_OFF;
615     }
616 
617     /*in case of  request has been already handled - calling the CB*/
618     if ( pPowerSrv->pCurrentRequest->requestState == HANDLED_REQUEST )
619     {
620         if ( pPowerSrv->pCurrentRequest->powerSrvCompleteCB != NULL )
621         {
622             pPowerSrv->pCurrentRequest->powerSrvCompleteCB( pPowerSrv->pCurrentRequest->powerSaveCBObject,
623                                                             currentPsMode,
624                                                             (EventsPowerSave_e)PowerSaveStatus);
625 
626         }
627     }
628 
629     /*starting again to handle waiting requests  */
630     /*priority to driver request*/
631     if ( pPowerSrv->driverRequest.requestState == NEW_REQUEST ||
632          pPowerSrv->driverRequest.requestState == PENDING_REQUEST )
633     {
634         status = powerSrvProcessRequest(hPowerSrv,pPowerSrv->driverRequest.requestMode);
635     }
636     else/*user request*/
637     {
638         if ( pPowerSrv->currentMode==USER_MODE )
639         {
640             if ( pPowerSrv->userRequest.requestState == NEW_REQUEST||
641                  pPowerSrv->userRequest.requestState == PENDING_REQUEST )
642             {
643                 status = powerSrvProcessRequest(hPowerSrv,pPowerSrv->userRequest.requestMode);
644             }
645 
646         }
647     }
648     if ( status == POWER_SAVE_802_11_IS_CURRENT )/*in case of already or habdled*/
649     {
650         if ( pPowerSrv->pCurrentRequest->powerSrvCompleteCB != NULL )
651         {
652             pPowerSrv->pCurrentRequest->powerSrvCompleteCB(pPowerSrv->pCurrentRequest->powerSaveCBObject,
653                                                            pPowerSrv->pCurrentRequest->psMode,
654                                                            ((pPowerSrv->pCurrentRequest->psMode == POWER_SAVE_ON) ?
655                                                             ENTER_POWER_SAVE_SUCCESS :
656                                                             EXIT_POWER_SAVE_SUCCESS));
657         }
658     }
659 
660 
661 }
662 
663 
664 /****************************************************************************************
665  *                        powerSrvProcessRequest                                                    *
666  ****************************************************************************************
667 DESCRIPTION: This function receive the request before sending it to the state machine, checks if it
668               possible to be applied and pass it to the state machine.
669 
670 
671 
672 INPUT:      - hPowerSrv                         - handle to the PowerSrv object.
673             - requestMode                   - Driver or User mode
674 
675 
676 OUTPUT:
677 RETURN:    TI_STATUS - TI_OK / PENDING / TI_NOK.
678 ****************************************************************************************/
powerSrvProcessRequest(TI_HANDLE hPowerSrv,powerSrvMode_e requestMode)679 TI_STATUS powerSrvProcessRequest (TI_HANDLE hPowerSrv, powerSrvMode_e requestMode)
680 {
681     PowerSrvSMStates_e powerSrvSmState;
682     powerSrvRequest_t*      pPrcessedRequest;
683     TI_STATUS smApiStatus;
684     powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv;
685 
686 
687 
688 /*determine what is the current request*/
689     if ( requestMode == DRIVER_MODE )
690     {
691         pPrcessedRequest = &(pPowerSrv->driverRequest);
692     }
693     else
694     {
695         pPrcessedRequest = &(pPowerSrv->userRequest);
696     }
697 
698 /*in case that the state machine is in a pending state and it is a driver
699    request we will return Pending and not call the SM. the request will
700    be processed in the next event - according to the 802_11_Report.*/
701     powerSrvSmState = powerSrvSM_getCurrentState(pPowerSrv->hPowerSrvSM);
702 
703     if ( (powerSrvSmState == POWER_SRV_STATE_PEND_ACTIVE ||
704           powerSrvSmState == POWER_SRV_STATE_PEND_PS) &&
705          pPowerSrv->pCurrentRequest->requestMode == DRIVER_MODE )
706     {
707         pPrcessedRequest->requestState = PENDING_REQUEST;
708         return POWER_SAVE_802_11_PENDING;
709     }
710     /*Set the correct request to the SM*/
711     powerSrvSm_setSmRequest(pPowerSrv->hPowerSrvSM ,pPrcessedRequest);
712 
713     /*call the SM with the correct request*/
714 
715     if ( pPrcessedRequest->psMode == POWER_SAVE_ON )
716     {
717         smApiStatus = powerSrvSM_SMApi(pPowerSrv->hPowerSrvSM,POWER_SRV_EVENT_REQUEST_PS);
718     }
719     else
720     {
721         smApiStatus = powerSrvSM_SMApi(pPowerSrv->hPowerSrvSM,POWER_SRV_EVENT_REQUEST_ACTIVE);
722     }
723 
724     /*if =! pending updating the current request pointer.*/
725     if ( pPrcessedRequest->requestState != PENDING_REQUEST )
726     {
727         pPowerSrv->pCurrentRequest = pPrcessedRequest;
728         pPowerSrv->currentMode = pPowerSrv->pCurrentRequest->requestMode;
729     }
730 
731 
732     return smApiStatus;
733 }
734 
735 
736 /****************************************************************************************
737  *                        powerSrvCreatePssRequest                                                  *
738  ****************************************************************************************
739 DESCRIPTION: This function create a request acording to it's type:
740                                                         - User
741                                                         -Driver
742 
743 
744 INPUT:      - hPowerSrv                         - handle to the PowerSrv object.
745             - requestMode                   - request type : Driver/User
746             - psMode                            - Power save/Active request
747             - sendNullDataOnExit                -
748             - powerSaveCBObject     - handle to the Callback functin module.
749             - powerSaveCompleteCB           - Calback function - for success/faild notification.
750 
751 OUTPUT:
752 RETURN:    void.
753 ****************************************************************************************/
powerSrvCreatePssRequest(TI_HANDLE hPowerSrv,powerSrvMode_e requestMode,powerSrvRequestState_e requestState,E80211PsMode psMode,TI_BOOL sendNullDataOnExit,void * powerSaveCBObject,powerSaveCmpltCB_t powerSaveCompleteCB,powerSaveCmdResponseCB_t powerSaveCmdResponseCB)754 void powerSrvCreatePssRequest (TI_HANDLE                    hPowerSrv,
755                                powerSrvMode_e              requestMode,
756                                powerSrvRequestState_e      requestState,
757                                E80211PsMode                psMode,
758                                TI_BOOL                        sendNullDataOnExit,
759                                void *                      powerSaveCBObject,
760                                powerSaveCmpltCB_t          powerSaveCompleteCB,
761                                powerSaveCmdResponseCB_t    powerSaveCmdResponseCB)
762 {
763     powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv;
764     if ( requestMode==USER_MODE )
765     {
766         pPowerSrv->userRequest.requestState             = requestState;
767         pPowerSrv->userRequest.requestMode              = requestMode;
768         pPowerSrv->userRequest.psMode                   = psMode;
769         pPowerSrv->userRequest.sendNullDataOnExit           = sendNullDataOnExit;
770         pPowerSrv->userRequest.powerSaveCBObject            = powerSaveCBObject;
771         pPowerSrv->userRequest.powerSrvCompleteCB       = powerSaveCompleteCB;
772         pPowerSrv->userRequest.powerSaveCmdResponseCB   = powerSaveCmdResponseCB;
773     }
774     else /*driver request*/
775     {
776         pPowerSrv->driverRequest.requestState               = requestState;
777         pPowerSrv->driverRequest.requestMode                = requestMode;
778         pPowerSrv->driverRequest.psMode                 = psMode;
779         pPowerSrv->driverRequest.sendNullDataOnExit             = sendNullDataOnExit;
780         pPowerSrv->driverRequest.powerSaveCBObject      = powerSaveCBObject;
781         pPowerSrv->driverRequest.powerSrvCompleteCB         = powerSaveCompleteCB;
782         pPowerSrv->driverRequest.powerSaveCmdResponseCB     = NULL;
783     }
784 }
785 
786 
787 
788 /****************************************************************************************
789  *                        powerSrvRegisterFailureEventCB                                                    *
790  ****************************************************************************************
791 DESCRIPTION: Registers a failure event callback for scan error notifications.
792 
793 
794 INPUT:      - hPowerSrv         - handle to the PowerSrv object.
795             - failureEventCB    - the failure event callback function.\n
796             - hFailureEventObj - handle to the object passed to the failure event callback function.
797 
798 OUTPUT:
799 RETURN:    void.
800 ****************************************************************************************/
powerSrvRegisterFailureEventCB(TI_HANDLE hPowerSrv,void * failureEventCB,TI_HANDLE hFailureEventObj)801 void powerSrvRegisterFailureEventCB( TI_HANDLE hPowerSrv,
802                                      void * failureEventCB, TI_HANDLE hFailureEventObj )
803 {
804     powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv;
805 
806     pPowerSrv->failureEventFunc = (TFailureEventCb)failureEventCB;
807     pPowerSrv->failureEventObj  = hFailureEventObj;
808 
809     /* register the failure event CB also with the PS SM */
810     powerSrvSM_RegisterFailureEventCB( pPowerSrv->hPowerSrvSM, failureEventCB, hFailureEventObj );
811 }
812 
813