diff -r 000000000000 -r 10c42ec6c05f TWD/MacServices/PowerSrv.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/TWD/MacServices/PowerSrv.c Tue Jun 29 12:34:26 2010 +0100 @@ -0,0 +1,817 @@ +/* + * PowerSrv.c + * + * Copyright(c) 1998 - 2010 Texas Instruments. All rights reserved. + * All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 or BSD License which accompanies + * this distribution. The Eclipse Public License is available at + * http://www.eclipse.org/legal/epl-v10.html and the BSD License is as below. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name Texas Instruments nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** \file powerSrv.c + * \brief This is the powerSrv module implementation. + * \author Assaf Azulay + * \date 19-Oct-2005 + */ + +/**************************************************************************** + * * + * MODULE: powerSrv * + * PURPOSE: powerSrv Module implementation. * + * * + ****************************************************************************/ + +#define __FILE_ID__ FILE_ID_113 +#include "tidef.h" +#include "osApi.h" +#include "report.h" +#include "timer.h" +#include "PowerSrv.h" +#include "PowerSrv_API.h" +#include "PowerSrvSM.h" +#include "eventMbox_api.h" + + +/***************************************************************************** + ** Defines ** + *****************************************************************************/ + + + +/**************************************************************************************** +** Private Function prototypes ** +****************************************************************************************/ +static void powerSrv802_11PsReport (TI_HANDLE hPowerSrv, char* str , TI_UINT32 strLen); +TI_STATUS powerSrvProcessRequest (TI_HANDLE hPowerSrv, powerSrvMode_e requestMode); +void powerSrvCreatePssRequest (TI_HANDLE hPowerSrv, + powerSrvMode_e requestMode, + powerSrvRequestState_e requestState, + E80211PsMode psMode, + TI_BOOL sendNullDataOnExit, + void * powerSaveCBObject, + powerSaveCmpltCB_t powerSaveCompleteCB, + powerSaveCmdResponseCB_t powerSaveCmdResponseCB); + +/*************************************************************************************** +** Functions ** +****************************************************************************************/ + + + +/**************************************************************************************** + * powerSrv_create * + **************************************************************************************** +DESCRIPTION: Power Server module creation function, called by the MAC Services create in creation phase + performs the following: + - Allocate the Power Server handle + - Creates the Power Server State Machine + +INPUT: - hOs - Handle to OS + + +OUTPUT: + +RETURN: Handle to the Power Server module on success, NULL otherwise +****************************************************************************************/ +TI_HANDLE powerSrv_create(TI_HANDLE hOs) +{ + powerSrv_t * pPowerSrv = NULL; + pPowerSrv = (powerSrv_t*) os_memoryAlloc (hOs, sizeof(powerSrv_t),MemoryNormal); + if ( pPowerSrv == NULL ) + { + WLAN_OS_REPORT(("powerSrv_create - Memory Allocation Error!\n")); + return NULL; + } + + os_memoryZero (hOs, pPowerSrv, sizeof(powerSrv_t)); + + pPowerSrv->hOS = hOs; + + /*creation of the State Machine*/ + pPowerSrv->hPowerSrvSM = powerSrvSM_create(hOs); + if ( pPowerSrv->hPowerSrvSM == NULL ) + { + WLAN_OS_REPORT(("powerSrv_create - Error in create PowerSrvSM module!\n")); + powerSrv_destroy(pPowerSrv); + return NULL; + } + + return pPowerSrv; + +} + + +/**************************************************************************************** + * powerSrv_destroy * + **************************************************************************************** +DESCRIPTION: Power Server module destroy function, c + - delete Power Server allocation + - call the destroy function of the State machine + +INPUT: - hPowerSrv - Handle to the Power Server + + +OUTPUT: + +RETURN: TI_STATUS - TI_OK on success else TI_NOK. +****************************************************************************************/ +TI_STATUS powerSrv_destroy(TI_HANDLE hPowerSrv) +{ + powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv; + + if ( pPowerSrv->hPowerSrvSM != NULL ) + { + powerSrvSM_destroy(pPowerSrv->hPowerSrvSM); + } + + os_memoryFree(pPowerSrv->hOS , pPowerSrv , sizeof(powerSrv_t)); + + return TI_OK; +} + + +/**************************************************************************************** + * powerSrvSM_init * + **************************************************************************************** +DESCRIPTION: Power Server module initialize function, called by the MAC Services in initialization phase + performs the following: + - init the Power server to active state. + - call the init function of the state machine. + +INPUT: - hPowerSrv - handle to the PowerSrv object. + - hReport - handle to the Report object. + - hEventMbox - handle to the Event Mbox object. + - hCmdBld - handle to the Command Builder object. + +OUTPUT: +RETURN: TI_STATUS - TI_OK on success else TI_NOK. +****************************************************************************************/ +TI_STATUS powerSrv_init (TI_HANDLE hPowerSrv, + TI_HANDLE hReport, + TI_HANDLE hEventMbox, + TI_HANDLE hCmdBld, + TI_HANDLE hTimer) +{ + powerSrv_t* pPowerSrv = (powerSrv_t*)hPowerSrv; + + pPowerSrv->hReport = hReport; + pPowerSrv->hEventMbox = hEventMbox; + + /* + init PowerSrv state machine. + */ + powerSrvSM_init (pPowerSrv->hPowerSrvSM, hReport, hCmdBld, hTimer); + + pPowerSrv->currentMode = USER_MODE; + + /*init all request with init values*/ + powerSrvCreatePssRequest(hPowerSrv, + USER_MODE, + HANDLED_REQUEST, + POWER_SAVE_OFF, + TI_FALSE, + NULL, + NULL, + NULL); + powerSrvCreatePssRequest(hPowerSrv, + DRIVER_MODE, + HANDLED_REQUEST, + POWER_SAVE_OFF, + TI_FALSE, + NULL, + NULL, + NULL); + pPowerSrv->userLastRequestMode = (powerSrvMode_e)POWER_SAVE_OFF; + pPowerSrv->pCurrentRequest = & pPowerSrv->userRequest; + + /* + register for Event + */ + + eventMbox_RegisterEvent (hEventMbox, + TWD_OWN_EVENT_PS_REPORT, + (void *)powerSrv802_11PsReport, + hPowerSrv); + + eventMbox_UnMaskEvent (hEventMbox, TWD_OWN_EVENT_PS_REPORT, NULL, NULL); + + TRACE0(pPowerSrv->hReport, REPORT_SEVERITY_INIT, "powerSrv Initialized \n"); + + return TI_OK; +} + +/**************************************************************************************** + * powerSrv_restart * + **************************************************************************************** +DESCRIPTION: Restart the scan SRV module upon recovery. + - init the Power server to active state. + - call the init function of the state machine. + +INPUT: - hPowerSrv - handle to the PowerSrv object. + +OUTPUT: +RETURN: TI_STATUS - TI_OK on success else TI_NOK. +****************************************************************************************/ +TI_STATUS powerSrv_restart( TI_HANDLE hPowerSrv) +{ + powerSrv_t* pPowerSrv = (powerSrv_t*)hPowerSrv; + PowerSrvSM_t *pPowerSrvSM = (PowerSrvSM_t*)pPowerSrv->hPowerSrvSM; + /* + init PowerSrv state machine. + */ + /* + the PowerSrvSM start in active mode (POWER_SRV_STATE_ACTIVE) + the PowerSrvSM::currentState must be sync with the PowerSrv::desiredPowerModeProfile (POWER_MODE_ACTIVE). + */ + pPowerSrvSM->currentState = POWER_SRV_STATE_ACTIVE; + pPowerSrv->currentMode = USER_MODE; + tmr_StopTimer (pPowerSrvSM->hPwrSrvSmTimer); + + /*init all request with init values*/ + powerSrvCreatePssRequest(hPowerSrv, + USER_MODE, + HANDLED_REQUEST, + POWER_SAVE_OFF, + TI_FALSE, + NULL, + NULL, + NULL); + powerSrvCreatePssRequest(hPowerSrv, + DRIVER_MODE, + HANDLED_REQUEST, + POWER_SAVE_OFF, + TI_FALSE, + NULL, + NULL, + NULL); + pPowerSrv->userLastRequestMode = (powerSrvMode_e)POWER_SAVE_OFF; + pPowerSrv->pCurrentRequest = & pPowerSrv->userRequest; + + /* + register for Event + */ + eventMbox_RegisterEvent (pPowerSrv->hEventMbox, + TWD_OWN_EVENT_PS_REPORT, + (void *)powerSrv802_11PsReport, + hPowerSrv); + + eventMbox_UnMaskEvent (pPowerSrv->hEventMbox, TWD_OWN_EVENT_PS_REPORT, NULL, NULL); + + return TI_OK; +} + +/**************************************************************************************** + * powerSrv_config * + **************************************************************************************** +DESCRIPTION: Power Server module configuration function, called by the MAC Services in configure phase + performs the following: + - init the Power server to active state. + - call the init function of the state machine. + +INPUT: - hPowerSrv - handle to the PowerSrv object. + - pPowerSrvInitParams - the Power Server initialize parameters. + +OUTPUT: +RETURN: TI_STATUS - TI_OK on success else TI_NOK. +****************************************************************************************/ +TI_STATUS powerSrv_config( TI_HANDLE hPowerSrv, + TPowerSrvInitParams *pPowerSrvInitParams) +{ + powerSrv_t* pPowerSrv = (powerSrv_t*)hPowerSrv; + + /* + config PowerSrv state machine. + */ + powerSrvSM_config( pPowerSrv->hPowerSrvSM, + pPowerSrvInitParams); + + return TI_OK; +} +/**************************************************************************************** + * powerSrv_SetPsMode * + **************************************************************************************** +DESCRIPTION: This function is a user mode request from the Power Save Server. + it will create a Request from the "USER_REQUEST" and will try to perform the user request for PS/Active. + this will be done in respect of priority to Driver request. + +INPUT: - hPowerSrv - handle to the PowerSrv object. + - psMode - Power save/Active request + - sendNullDataOnExit - + - powerSaveCBObject - handle to the Callback function module. + - powerSaveCompleteCB - Callback function - for success/faild notification. +OUTPUT: +RETURN: TI_STATUS - TI_OK / PENDING / TI_NOK. +****************************************************************************************/ +TI_STATUS powerSrv_SetPsMode( TI_HANDLE hPowerSrv, + E80211PsMode psMode, + TI_BOOL sendNullDataOnExit, + void * powerSaveCBObject, + powerSaveCmpltCB_t powerSaveCompleteCB, + powerSaveCmdResponseCB_t powerSavecmdResponseCB) + +{ + powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv; + TI_STATUS status; +/*creating the request from type - "user"*/ + powerSrvCreatePssRequest(hPowerSrv, + USER_MODE, + NEW_REQUEST, + psMode, + sendNullDataOnExit, + powerSaveCBObject, + powerSaveCompleteCB, + powerSavecmdResponseCB); + +/*the request will be handled if the Power server is not in Driver mode.*/ + if ( pPowerSrv->currentMode==USER_MODE ) + { + status = powerSrvProcessRequest(hPowerSrv,pPowerSrv->userRequest.requestMode); + } + else/*driver mode*/ + { + pPowerSrv->userRequest.requestState = PENDING_REQUEST; + status = POWER_SAVE_802_11_PENDING; + } + return status; + +} + + +/**************************************************************************************** + * powerSrv_ReservePS * + **************************************************************************************** +DESCRIPTION: This function is a driver mode request to set the 802.11 Power Save state and reserve the module. + The module should not be in driver mode when this request is made. + If this function is called when the module is already in driver mode the result is unexpected. + If the request cannot be fulfilled because of currently executing user mode request, + then the function will return PENDING and the powerSaveCompleteCB function will be called when the request is fulfilled. + If the request can be fulfilled immediately and the Power Save state required is the current state + (This is always the case when PSMode = KEEP_CURRENT), + then the module will be reserved and the function will return TI_OK - the callback function will not be called.?? + If the request can be fulfilled immediately and requires a Power Save state transition, + then the return value will be TI_OK and the powerSaveCompleteCB function will be called by the Power Save Server + when the request is complete. + +INPUT: - hPowerSrv - handle to the PowerSrv object. + - psMode - Power save/Active request + - sendNullDataOnExit - + - powerSaveCBObject - handle to the Callback function module. + - powerSaveCompleteCB - Callback function - for success/faild notification. +OUTPUT: +RETURN: TI_STATUS - TI_OK / PENDING / TI_NOK. +****************************************************************************************/ +TI_STATUS powerSrv_ReservePS( TI_HANDLE hPowerSrv, + E80211PsMode psMode, + TI_BOOL sendNullDataOnExit, + void * powerSaveCBObject, + powerSaveCmpltCB_t powerSaveCompleteCB) +{ + powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv; + TI_STATUS status; + + /*creating the request from type - "driver"*/ + if ( psMode == POWER_SAVE_KEEP_CURRENT ) + { + psMode = pPowerSrv->userRequest.psMode; + } + + powerSrvCreatePssRequest(hPowerSrv, + DRIVER_MODE, + NEW_REQUEST, + psMode, + sendNullDataOnExit, + powerSaveCBObject, + powerSaveCompleteCB, + NULL); + /*try to execute the request*/ + status = powerSrvProcessRequest(hPowerSrv,pPowerSrv->driverRequest.requestMode); + return status; + +} + + +/**************************************************************************************** + * powerSrv_ReleasePS * + **************************************************************************************** +DESCRIPTION: This function is used to release a previous driver mode request issued with the ReservPS API. + it creates a Driver request and the server act like it is a normal driver request. + the server will send the request with a simple optimization - if there is a pending or + new user request - the request will be added in the driver request, in this way when the + user request will be executed there will be nothing to do, in the same manner if there + are no user / driver request to execute we will send the last user request in Driver mode. + + + + +INPUT: - hPowerSrv - handle to the PowerSrv object. + - sendNullDataOnExit - + - powerSaveCBObject - handle to the Callback function module. + - powerSaveCompleteCB - Callback function - for success/faild notification. +OUTPUT: +RETURN: TI_STATUS - TI_OK / PENDING / TI_NOK. +****************************************************************************************/ +TI_STATUS powerSrv_ReleasePS( TI_HANDLE hPowerSrv, + TI_BOOL sendNullDataOnExit, + void * powerSaveCBObject, + powerSaveCmpltCB_t powerSaveCompleteCB) +{ + powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv; + TI_STATUS status; + + /*creating the request from type - "driver"*/ + + if (pPowerSrv->driverRequest.requestMode == POWER_SAVE_802_11_PENDING) + { + powerSrvCreatePssRequest(hPowerSrv, + DRIVER_MODE, + HANDLED_REQUEST, + POWER_SAVE_OFF, + TI_FALSE, + NULL, + NULL, + NULL); + return POWER_SAVE_802_11_IS_CURRENT; + } + + /*creating the request from type - "driver"*/ + powerSrvCreatePssRequest(hPowerSrv, + DRIVER_MODE, + NEW_REQUEST, + POWER_SAVE_KEEP_CURRENT, + sendNullDataOnExit, + powerSaveCBObject, + powerSaveCompleteCB, + NULL); + if ( pPowerSrv->userRequest.requestState == NEW_REQUEST || + pPowerSrv->userRequest.requestState == PENDING_REQUEST ) + { + pPowerSrv->driverRequest.psMode = pPowerSrv->userRequest.psMode; + } + else + { + pPowerSrv->driverRequest.psMode = (E80211PsMode)pPowerSrv->userLastRequestMode; + } + + + + status = powerSrvProcessRequest(hPowerSrv,pPowerSrv->driverRequest.requestMode); + /*if the request was not executed we should not change the mode*/ + if (status != POWER_SAVE_802_11_PENDING) + { + pPowerSrv->currentMode = USER_MODE; + } + return status; +} + + + +/**************************************************************************************** + * powerSrv_getPsStatus * + ***************************************************************************************** +DESCRIPTION: This function returns the true state of power. + +INPUT: - hPowerSrv - handle to the PowerSrv object. + +OUTPUT: +RETURN: TI_BOOL - true if the SM is in PS state - false otherwise +****************************************************************************************/ +TI_BOOL powerSrv_getPsStatus(TI_HANDLE hPowerSrv) +{ + powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv; + PowerSrvSMStates_e smState; + smState = powerSrvSM_getCurrentState(pPowerSrv->hPowerSrvSM); + return(smState == POWER_SRV_STATE_PS ); +} + + +/**************************************************************************************** +* powerSrv_SetRateModulation * +***************************************************************************************** +DESCRIPTION: Sets the rate modulation according to the current Radio Mode. + +INPUT: - hPowerSrv - handle to the PowerSrv object. + - dot11mode_e - The current radio mode (A or G) + +OUTPUT: +RETURN: TI_BOOL - true if the SM is in PS state - false otherwise +****************************************************************************************/ +void powerSrv_SetRateModulation(TI_HANDLE hPowerSrv, TI_UINT16 rate) +{ + powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv; + powerSrvSM_setRateModulation(pPowerSrv->hPowerSrvSM,rate); + + return; +} + +/** + * \Gets the rate modulation. + * + * Function Scope \e Public.\n + * Parameters:\n + * 1) TI_HANDLE - handle to the PowerSrvSM object.\n + * 2) dot11mode_e - The current radio mode (A or G) + * Return: None.\n + */ +TI_UINT32 powerSrv_GetRateModulation(TI_HANDLE hPowerSrv) +{ + powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv; + return powerSrvSM_getRateModulation(pPowerSrv->hPowerSrvSM); +} + + + + +/***************************************************************************** + ** Private Function prototypes ** + *****************************************************************************/ + + +/**************************************************************************************** + * powerSrv802_11PsReport * + **************************************************************************************** +DESCRIPTION: This function is the call back for the TWD control when a PS event triggered + This function is responsible for the process "keep alive". + the function handles the event and sends it to the state machine, after sending the events + the function handles the next request with respect to driver request priority. + if a request is already done then we will call the request call back (if exist!). + + + + +INPUT: - hPowerSrv - handle to the PowerSrv object. + - str - Event string + - strLen - string length + +OUTPUT: +RETURN: void. +****************************************************************************************/ +static void powerSrv802_11PsReport(TI_HANDLE hPowerSrv, char* str , TI_UINT32 strLen) +{ + powerSrv_t * pPowerSrv = (powerSrv_t*)hPowerSrv; + TI_UINT8 PowerSaveStatus; + E80211PsMode currentPsMode; + TI_STATUS status = TI_OK; + + /*copy the event*/ + os_memoryCopy(pPowerSrv->hOS, (void *)&PowerSaveStatus, (void *)str, strLen); + + TRACE1( pPowerSrv->hReport, REPORT_SEVERITY_INFORMATION, "PS callback with status: %d\n", PowerSaveStatus); + + /* Handling the event*/ + switch ( (EventsPowerSave_e)PowerSaveStatus ) + { + case ENTER_POWER_SAVE_FAIL: + case EXIT_POWER_SAVE_FAIL: + TRACE0( pPowerSrv->hReport, REPORT_SEVERITY_WARNING, "Power save enter or exit failed!\n"); + powerSrvSM_SMApi(pPowerSrv->hPowerSrvSM,POWER_SRV_EVENT_FAIL); + break; + + case ENTER_POWER_SAVE_SUCCESS: + case EXIT_POWER_SAVE_SUCCESS: + powerSrvSM_SMApi(pPowerSrv->hPowerSrvSM,POWER_SRV_EVENT_SUCCESS); + /*update the last user request if the request was a user request*/ + if ( pPowerSrv->currentMode == USER_MODE ) + { + pPowerSrv->userLastRequestMode= (powerSrvMode_e)pPowerSrv->userRequest.psMode; + } + break; + + default: + TRACE1( pPowerSrv->hReport, REPORT_SEVERITY_ERROR, "Unrecognized status at PS callback %d\n", PowerSaveStatus ); + break; + } + + /*this reflects the true power save state - power save IFF state machine in PS state.*/ + if ( (EventsPowerSave_e)PowerSaveStatus == ENTER_POWER_SAVE_SUCCESS ) + { + currentPsMode = POWER_SAVE_ON; + } + else + { + currentPsMode = POWER_SAVE_OFF; + } + + /*in case of request has been already handled - calling the CB*/ + if ( pPowerSrv->pCurrentRequest->requestState == HANDLED_REQUEST ) + { + if ( pPowerSrv->pCurrentRequest->powerSrvCompleteCB != NULL ) + { + pPowerSrv->pCurrentRequest->powerSrvCompleteCB( pPowerSrv->pCurrentRequest->powerSaveCBObject, + currentPsMode, + (EventsPowerSave_e)PowerSaveStatus); + + } + } + + /*starting again to handle waiting requests */ + /*priority to driver request*/ + if ( pPowerSrv->driverRequest.requestState == NEW_REQUEST || + pPowerSrv->driverRequest.requestState == PENDING_REQUEST ) + { + status = powerSrvProcessRequest(hPowerSrv,pPowerSrv->driverRequest.requestMode); + } + else/*user request*/ + { + if ( pPowerSrv->currentMode==USER_MODE ) + { + if ( pPowerSrv->userRequest.requestState == NEW_REQUEST|| + pPowerSrv->userRequest.requestState == PENDING_REQUEST ) + { + status = powerSrvProcessRequest(hPowerSrv,pPowerSrv->userRequest.requestMode); + } + + } + } + if ( status == POWER_SAVE_802_11_IS_CURRENT )/*in case of already or habdled*/ + { + if ( pPowerSrv->pCurrentRequest->powerSrvCompleteCB != NULL ) + { + pPowerSrv->pCurrentRequest->powerSrvCompleteCB(pPowerSrv->pCurrentRequest->powerSaveCBObject, + pPowerSrv->pCurrentRequest->psMode, + ((pPowerSrv->pCurrentRequest->psMode == POWER_SAVE_ON) ? + ENTER_POWER_SAVE_SUCCESS : + EXIT_POWER_SAVE_SUCCESS)); + } + } + + +} + + +/**************************************************************************************** + * powerSrvProcessRequest * + **************************************************************************************** +DESCRIPTION: This function receive the request before sending it to the state machine, checks if it + possible to be applied and pass it to the state machine. + + + +INPUT: - hPowerSrv - handle to the PowerSrv object. + - requestMode - Driver or User mode + + +OUTPUT: +RETURN: TI_STATUS - TI_OK / PENDING / TI_NOK. +****************************************************************************************/ +TI_STATUS powerSrvProcessRequest (TI_HANDLE hPowerSrv, powerSrvMode_e requestMode) +{ + PowerSrvSMStates_e powerSrvSmState; + powerSrvRequest_t* pPrcessedRequest; + TI_STATUS smApiStatus; + powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv; + + + +/*determine what is the current request*/ + if ( requestMode == DRIVER_MODE ) + { + pPrcessedRequest = &(pPowerSrv->driverRequest); + } + else + { + pPrcessedRequest = &(pPowerSrv->userRequest); + } + +/*in case that the state machine is in a pending state and it is a driver + request we will return Pending and not call the SM. the request will + be processed in the next event - according to the 802_11_Report.*/ + powerSrvSmState = powerSrvSM_getCurrentState(pPowerSrv->hPowerSrvSM); + + if ( (powerSrvSmState == POWER_SRV_STATE_PEND_ACTIVE || + powerSrvSmState == POWER_SRV_STATE_PEND_PS) && + pPowerSrv->pCurrentRequest->requestMode == DRIVER_MODE ) + { + pPrcessedRequest->requestState = PENDING_REQUEST; + return POWER_SAVE_802_11_PENDING; + } + /*Set the correct request to the SM*/ + powerSrvSm_setSmRequest(pPowerSrv->hPowerSrvSM ,pPrcessedRequest); + + /*call the SM with the correct request*/ + + if ( pPrcessedRequest->psMode == POWER_SAVE_ON ) + { + smApiStatus = powerSrvSM_SMApi(pPowerSrv->hPowerSrvSM,POWER_SRV_EVENT_REQUEST_PS); + } + else + { + smApiStatus = powerSrvSM_SMApi(pPowerSrv->hPowerSrvSM,POWER_SRV_EVENT_REQUEST_ACTIVE); + } + + /*if =! pending updating the current request pointer.*/ + if ( pPrcessedRequest->requestState != PENDING_REQUEST ) + { + pPowerSrv->pCurrentRequest = pPrcessedRequest; + pPowerSrv->currentMode = pPowerSrv->pCurrentRequest->requestMode; + } + + + return smApiStatus; +} + + +/**************************************************************************************** + * powerSrvCreatePssRequest * + **************************************************************************************** +DESCRIPTION: This function create a request acording to it's type: + - User + -Driver + + +INPUT: - hPowerSrv - handle to the PowerSrv object. + - requestMode - request type : Driver/User + - psMode - Power save/Active request + - sendNullDataOnExit - + - powerSaveCBObject - handle to the Callback functin module. + - powerSaveCompleteCB - Calback function - for success/faild notification. + +OUTPUT: +RETURN: void. +****************************************************************************************/ +void powerSrvCreatePssRequest (TI_HANDLE hPowerSrv, + powerSrvMode_e requestMode, + powerSrvRequestState_e requestState, + E80211PsMode psMode, + TI_BOOL sendNullDataOnExit, + void * powerSaveCBObject, + powerSaveCmpltCB_t powerSaveCompleteCB, + powerSaveCmdResponseCB_t powerSaveCmdResponseCB) +{ + powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv; + if ( requestMode==USER_MODE ) + { + pPowerSrv->userRequest.requestState = requestState; + pPowerSrv->userRequest.requestMode = requestMode; + pPowerSrv->userRequest.psMode = psMode; + pPowerSrv->userRequest.sendNullDataOnExit = sendNullDataOnExit; + pPowerSrv->userRequest.powerSaveCBObject = powerSaveCBObject; + pPowerSrv->userRequest.powerSrvCompleteCB = powerSaveCompleteCB; + pPowerSrv->userRequest.powerSaveCmdResponseCB = powerSaveCmdResponseCB; + } + else /*driver request*/ + { + pPowerSrv->driverRequest.requestState = requestState; + pPowerSrv->driverRequest.requestMode = requestMode; + pPowerSrv->driverRequest.psMode = psMode; + pPowerSrv->driverRequest.sendNullDataOnExit = sendNullDataOnExit; + pPowerSrv->driverRequest.powerSaveCBObject = powerSaveCBObject; + pPowerSrv->driverRequest.powerSrvCompleteCB = powerSaveCompleteCB; + pPowerSrv->driverRequest.powerSaveCmdResponseCB = NULL; + } +} + + + +/**************************************************************************************** + * powerSrvRegisterFailureEventCB * + **************************************************************************************** +DESCRIPTION: Registers a failure event callback for scan error notifications. + + +INPUT: - hPowerSrv - handle to the PowerSrv object. + - failureEventCB - the failure event callback function.\n + - hFailureEventObj - handle to the object passed to the failure event callback function. + +OUTPUT: +RETURN: void. +****************************************************************************************/ +void powerSrvRegisterFailureEventCB( TI_HANDLE hPowerSrv, + void * failureEventCB, TI_HANDLE hFailureEventObj ) +{ + powerSrv_t *pPowerSrv = (powerSrv_t*)hPowerSrv; + + pPowerSrv->failureEventFunc = (TFailureEventCb)failureEventCB; + pPowerSrv->failureEventObj = hFailureEventObj; + + /* register the failure event CB also with the PS SM */ + powerSrvSM_RegisterFailureEventCB( pPowerSrv->hPowerSrvSM, failureEventCB, hFailureEventObj ); +} +