--- /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 );
+}
+