| /* |
| * measurementMgr.c |
| * |
| * Copyright(c) 1998 - 2010 Texas Instruments. All rights reserved. |
| * All rights reserved. |
| * |
| * 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. |
| */ |
| |
| |
| /***************************************************************************/ |
| /* */ |
| /* MODULE: measurementMgr.c */ |
| /* PURPOSE: measurement Manager module file */ |
| /* */ |
| /***************************************************************************/ |
| |
| |
| |
| |
| #define __FILE_ID__ FILE_ID_1 |
| #include "measurementMgr.h" |
| #include "regulatoryDomainApi.h" |
| #include "healthMonitor.h" |
| #include "DrvMainModules.h" |
| #include "siteMgrApi.h" |
| #include "TrafficMonitorAPI.h" |
| #include "smeApi.h" |
| #include "sme.h" |
| #ifdef XCC_MODULE_INCLUDED |
| #include "XCCTSMngr.h" |
| #endif |
| #include "TWDriver.h" |
| |
| /* default measurement parameters */ |
| #define MEASUREMENT_CAPABILITIES_NONE 0x00 |
| #define MEASUREMENT_CAPABILITIES_DOT11H 0x01 |
| #define MEASUREMENT_CAPABILITIES_XCC_RM 0x02 |
| |
| |
| #define MEASUREMENT_BEACON_INTERVAL_IN_MICRO_SEC 1024 |
| #define MEASUREMENT_MSEC_IN_MICRO 1000 |
| |
| |
| |
| |
| /********************************************************************************/ |
| /* Internal functions prototypes. */ |
| /********************************************************************************/ |
| |
| static void measurementMgr_releaseModule(measurementMgr_t *pMeasurementMgr); |
| |
| static TI_BOOL measurementMgr_isTrafficIntensityHigherThanThreshold(measurementMgr_t * pMeasurementMgr); |
| |
| static TI_BOOL measurementMgr_isRequestValid(TI_HANDLE hMeasurementMgr, MeasurementRequest_t *pRequestArr[], TI_UINT8 numOfRequest); |
| |
| static TI_BOOL measurementMgrSM_measureInProgress(TI_HANDLE hMeasurementMgr); |
| |
| |
| |
| |
| |
| /********************************************************************************/ |
| /* Interface functions Implementation. */ |
| /********************************************************************************/ |
| |
| |
| /** |
| * Creates the Measurement Manager moodule. |
| * |
| * @param hOs A handle to the OS object. |
| * |
| * @date 16-Dec-2005 |
| */ |
| TI_HANDLE measurementMgr_create(TI_HANDLE hOs) |
| { |
| measurementMgr_t * pMeasurementMgr = NULL; |
| TI_STATUS status; |
| |
| /* allocating the MeasurementMgr object */ |
| pMeasurementMgr = os_memoryAlloc(hOs, sizeof(measurementMgr_t)); |
| |
| if (pMeasurementMgr == NULL) |
| return NULL; |
| |
| os_memoryZero(hOs, pMeasurementMgr, sizeof(measurementMgr_t)); |
| pMeasurementMgr->hOs = hOs; |
| |
| /* creating the Measurement SM */ |
| status = fsm_Create(pMeasurementMgr->hOs, &(pMeasurementMgr->pMeasurementMgrSm), |
| MEASUREMENTMGR_NUM_STATES , MEASUREMENTMGR_NUM_EVENTS); |
| if(status != TI_OK) |
| { |
| measurementMgr_releaseModule(pMeasurementMgr); |
| return NULL; |
| } |
| |
| /* creating the sub modules of measurement module */ |
| |
| /* creating Request Handler sub module */ |
| if( (pMeasurementMgr->hRequestH = requestHandler_create(hOs)) == NULL) |
| { |
| measurementMgr_releaseModule(pMeasurementMgr); |
| return NULL; |
| } |
| |
| return(pMeasurementMgr); |
| } |
| |
| |
| |
| |
| |
| /** |
| * Configures the Measurement Manager module. |
| * |
| * @param pStadHandles Handles to other modules the Measurement Manager needs. |
| * |
| * @date 16-Dec-2005 |
| */ |
| void measurementMgr_init (TStadHandlesList *pStadHandles) |
| { |
| measurementMgr_t *pMeasurementMgr = (measurementMgr_t *)(pStadHandles->hMeasurementMgr); |
| paramInfo_t param; |
| |
| /* Init Handlers */ |
| pMeasurementMgr->hRegulatoryDomain = pStadHandles->hRegulatoryDomain; |
| pMeasurementMgr->hXCCMngr = pStadHandles->hXCCMngr; |
| pMeasurementMgr->hSiteMgr = pStadHandles->hSiteMgr; |
| pMeasurementMgr->hTWD = pStadHandles->hTWD; |
| pMeasurementMgr->hMlme = pStadHandles->hMlmeSm; |
| pMeasurementMgr->hTrafficMonitor = pStadHandles->hTrafficMon; |
| pMeasurementMgr->hReport = pStadHandles->hReport; |
| pMeasurementMgr->hOs = pStadHandles->hOs; |
| pMeasurementMgr->hScr = pStadHandles->hSCR; |
| pMeasurementMgr->hApConn = pStadHandles->hAPConnection; |
| pMeasurementMgr->hTxCtrl = pStadHandles->hTxCtrl; |
| pMeasurementMgr->hTimer = pStadHandles->hTimer; |
| pMeasurementMgr->hSme = pStadHandles->hSme; |
| |
| /* initialize variables to default values */ |
| pMeasurementMgr->Enabled = TI_TRUE; |
| pMeasurementMgr->Connected = TI_FALSE; |
| pMeasurementMgr->Capabilities = MEASUREMENT_CAPABILITIES_NONE; |
| pMeasurementMgr->Mode = MSR_MODE_NONE; |
| |
| /* Getting management capability status */ |
| param.paramType = REGULATORY_DOMAIN_MANAGEMENT_CAPABILITY_ENABLED_PARAM; |
| regulatoryDomain_getParam (pMeasurementMgr->hRegulatoryDomain, ¶m); |
| if (param.content.spectrumManagementEnabled) |
| { |
| pMeasurementMgr->Capabilities |= MEASUREMENT_CAPABILITIES_DOT11H; |
| } |
| |
| /* Init Functions */ |
| pMeasurementMgr->parserFrameReq = NULL; |
| pMeasurementMgr->isTypeValid = NULL; |
| pMeasurementMgr->buildReport = NULL; |
| pMeasurementMgr->buildRejectReport = NULL; |
| pMeasurementMgr->sendReportAndCleanObj = NULL; |
| |
| /* initialize variables */ |
| pMeasurementMgr->currentState = MEASUREMENTMGR_STATE_IDLE; |
| pMeasurementMgr->isModuleRegistered = TI_FALSE; |
| pMeasurementMgr->currentFrameType = MSR_FRAME_TYPE_NO_ACTIVE; |
| pMeasurementMgr->measuredChannelID = 0; |
| pMeasurementMgr->currentNumOfRequestsInParallel = 0; |
| pMeasurementMgr->bMeasurementScanExecuted = TI_FALSE; |
| |
| /* config sub modules */ |
| RequestHandler_config(pMeasurementMgr->hRequestH, pStadHandles->hReport, pStadHandles->hOs); |
| |
| /* Register to the SCR module */ |
| scr_registerClientCB(pMeasurementMgr->hScr, SCR_CID_XCC_MEASURE, measurementMgr_scrResponseCB, (TI_HANDLE)pMeasurementMgr); |
| |
| measurementMgrSM_config ((TI_HANDLE)pMeasurementMgr); |
| |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INIT , ": Measurement Manager configured successfully\n"); |
| } |
| |
| |
| TI_STATUS measurementMgr_SetDefaults (TI_HANDLE hMeasurementMgr, measurementInitParams_t * pMeasurementInitParams) |
| { |
| measurementMgr_t * pMeasurementMgr = (measurementMgr_t *) hMeasurementMgr; |
| #ifdef XCC_MODULE_INCLUDED |
| TI_UINT32 currAC; |
| #endif |
| |
| pMeasurementMgr->trafficIntensityThreshold = pMeasurementInitParams->trafficIntensityThreshold; |
| pMeasurementMgr->maxDurationOnNonServingChannel = pMeasurementInitParams->maxDurationOnNonServingChannel; |
| |
| /* allocating the measurement Activation Delay timer */ |
| pMeasurementMgr->hActivationDelayTimer = tmr_CreateTimer (pMeasurementMgr->hTimer); |
| if (pMeasurementMgr->hActivationDelayTimer == NULL) |
| { |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_ERROR, "measurementMgr_SetDefaults(): Failed to create hActivationDelayTimer!\n"); |
| return TI_NOK; |
| } |
| |
| #ifdef XCC_MODULE_INCLUDED |
| /* allocating the per AC TS Metrics report timers */ |
| for (currAC = 0; currAC < MAX_NUM_OF_AC; currAC++) |
| { |
| pMeasurementMgr->isTsMetricsEnabled[currAC] = TI_FALSE; |
| |
| pMeasurementMgr->hTsMetricsReportTimer[currAC] = tmr_CreateTimer (pMeasurementMgr->hTimer); |
| if (pMeasurementMgr->hTsMetricsReportTimer[currAC] == NULL) |
| { |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_ERROR, "measurementMgr_SetDefaults(): Failed to create hTsMetricsReportTimer!\n"); |
| return TI_NOK; |
| } |
| } |
| |
| /* Check in the Registry if the station supports XCC RM */ |
| if (pMeasurementInitParams->XCCEnabled == XCC_MODE_ENABLED) |
| { |
| pMeasurementMgr->Capabilities |= MEASUREMENT_CAPABILITIES_XCC_RM; |
| } |
| #endif |
| |
| return TI_OK; |
| } |
| |
| |
| |
| |
| |
| /** |
| * Sets the specified Measurement Manager parameter. |
| * |
| * @param hMeasurementMgr A handle to the Measurement Manager module. |
| * @param pParam The parameter to set. |
| * |
| * @date 16-Dec-2005 |
| */ |
| TI_STATUS measurementMgr_setParam(TI_HANDLE hMeasurementMgr, paramInfo_t * pParam) |
| { |
| measurementMgr_t * pMeasurementMgr = (measurementMgr_t *) hMeasurementMgr; |
| |
| switch (pParam->paramType) |
| { |
| case MEASUREMENT_ENABLE_DISABLE_PARAM: |
| { |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": MEASUREMENT_ENABLE_DISABLE_PARAM <- %d\n", pParam->content.measurementEnableDisableStatus); |
| |
| if (pParam->content.measurementEnableDisableStatus) |
| { |
| measurementMgr_enable(pMeasurementMgr); |
| } |
| else |
| { |
| measurementMgr_disable(pMeasurementMgr); |
| } |
| |
| break; |
| } |
| |
| case MEASUREMENT_TRAFFIC_THRESHOLD_PARAM: |
| { |
| if ((pParam->content.measurementTrafficThreshold >= MEASUREMENT_TRAFFIC_THRSHLD_MIN) && |
| (pParam->content.measurementTrafficThreshold <= MEASUREMENT_TRAFFIC_THRSHLD_MAX)) |
| { |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": MEASUREMENT_TRAFFIC_THRESHOLD_PARAM <- %d\n", pParam->content.measurementTrafficThreshold); |
| |
| pMeasurementMgr->trafficIntensityThreshold = pParam->content.measurementTrafficThreshold; |
| } |
| else |
| { |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_ERROR, ": Invalid value for MEASUREMENT_TRAFFIC_THRESHOLD_PARAM (%d)\n", pParam->content.measurementTrafficThreshold); |
| } |
| |
| break; |
| } |
| |
| |
| case MEASUREMENT_MAX_DURATION_PARAM: |
| { |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": MEASUREMENT_MAX_DURATION_PARAM <- %d\n", pParam->content.measurementMaxDuration); |
| |
| pMeasurementMgr->maxDurationOnNonServingChannel = pParam->content.measurementMaxDuration; |
| |
| break; |
| } |
| |
| |
| default: |
| { |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_ERROR, ": Specified parameter is not supported (%d)\n", pParam->paramType); |
| |
| return PARAM_NOT_SUPPORTED; |
| } |
| |
| } |
| |
| return TI_OK; |
| } |
| |
| |
| |
| |
| |
| /** |
| * Gets the specified parameter from the Measurement Manager. |
| * |
| * @param hMeasurementMgr A handle to the Measurement Manager module. |
| * @param pParam The parameter to get. |
| * |
| * @date 16-Dec-2005 |
| */ |
| TI_STATUS measurementMgr_getParam(TI_HANDLE hMeasurementMgr, paramInfo_t * pParam) |
| { |
| measurementMgr_t * pMeasurementMgr = (measurementMgr_t *) hMeasurementMgr; |
| |
| switch(pParam->paramType) |
| { |
| |
| case MEASUREMENT_GET_STATUS_PARAM: |
| { |
| WLAN_OS_REPORT(("%s: \n\n", __FUNCTION__)); |
| WLAN_OS_REPORT(("MeasurementMgr Status Report:\n\n")); |
| |
| WLAN_OS_REPORT(("Current State: %d\n\n", pMeasurementMgr->currentState)); |
| |
| WLAN_OS_REPORT(("Connected: %d\n", pMeasurementMgr->Connected)); |
| WLAN_OS_REPORT(("Enabled: %d\n\n", pMeasurementMgr->Enabled)); |
| |
| WLAN_OS_REPORT(("Mode: %d\n", pMeasurementMgr->Mode)); |
| WLAN_OS_REPORT(("Capabilities: %d\n\n", pMeasurementMgr->Capabilities)); |
| |
| WLAN_OS_REPORT(("current Frame Type: %d\n", pMeasurementMgr->currentFrameType)); |
| WLAN_OS_REPORT(("Measured Channel: %d\n", pMeasurementMgr->measuredChannelID)); |
| WLAN_OS_REPORT(("Serving Channel: %d\n", pMeasurementMgr->servingChannelID)); |
| WLAN_OS_REPORT(("Traffic Intensity Threshold: %d\n", pMeasurementMgr->trafficIntensityThreshold)); |
| WLAN_OS_REPORT(("Max Duration on Nonserving Channel: %d\n", pMeasurementMgr->maxDurationOnNonServingChannel)); |
| |
| break; |
| } |
| |
| |
| default: |
| { |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_ERROR, ": Specified parameter is not supported (%d)\n", pParam->paramType); |
| |
| return PARAM_NOT_SUPPORTED; |
| } |
| |
| } |
| |
| return TI_OK; |
| } |
| |
| |
| |
| |
| |
| |
| /** |
| * Signals the Measurement Manager that the STA is connected. |
| * |
| * @param hMeasurementMgr A handle to the Measurement Manager module. |
| * |
| * @date 16-Dec-2005 |
| */ |
| TI_STATUS measurementMgr_connected(TI_HANDLE hMeasurementMgr) |
| { |
| measurementMgr_t * pMeasurementMgr = (measurementMgr_t *) hMeasurementMgr; |
| |
| /* checking if measurement is enabled */ |
| if (pMeasurementMgr->Mode == MSR_MODE_NONE) |
| return TI_OK; |
| |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": MeasurementMgr set to connected.\n"); |
| |
| return measurementMgrSM_event((TI_UINT8 *) &(pMeasurementMgr->currentState), |
| MEASUREMENTMGR_EVENT_CONNECTED, pMeasurementMgr); |
| } |
| |
| |
| |
| |
| |
| /** |
| * Signals the Measurement Manager that the STA is disconnected. |
| * |
| * @param hMeasurementMgr A handle to the Measurement Manager module. |
| * |
| * @date 16-Dec-2005 |
| */ |
| TI_STATUS measurementMgr_disconnected(TI_HANDLE hMeasurementMgr) |
| { |
| measurementMgr_t * pMeasurementMgr = (measurementMgr_t *) hMeasurementMgr; |
| |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": MeasurementMgr set to disconnected.\n"); |
| |
| return measurementMgrSM_event((TI_UINT8 *) &(pMeasurementMgr->currentState), |
| MEASUREMENTMGR_EVENT_DISCONNECTED, pMeasurementMgr); |
| } |
| |
| |
| |
| |
| /** |
| * Enables the Measurement Manager module. |
| * |
| * @date 10-Jan-2006 |
| */ |
| TI_STATUS measurementMgr_enable(TI_HANDLE hMeasurementMgr) |
| { |
| measurementMgr_t * pMeasurementMgr = (measurementMgr_t *) hMeasurementMgr; |
| |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": MeasurementMgr set to enabled.\n"); |
| |
| return measurementMgrSM_event((TI_UINT8 *) &(pMeasurementMgr->currentState), |
| MEASUREMENTMGR_EVENT_ENABLE, pMeasurementMgr); |
| } |
| |
| |
| |
| |
| |
| /** |
| * Disables the Measurement Manager module. |
| * |
| * @date 10-Jan-2006 |
| */ |
| TI_STATUS measurementMgr_disable(TI_HANDLE hMeasurementMgr) |
| { |
| measurementMgr_t * pMeasurementMgr = (measurementMgr_t *) hMeasurementMgr; |
| |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": MeasurementMgr set to disabled.\n"); |
| |
| return measurementMgrSM_event((TI_UINT8 *) &(pMeasurementMgr->currentState), |
| MEASUREMENTMGR_EVENT_DISABLE, pMeasurementMgr); |
| } |
| |
| |
| |
| |
| |
| /** |
| * Destroys the Measurement Manager module. |
| * |
| * @param hMeasurementMgr A handle to the Measurement Manager module. |
| * |
| * @date 16-Dec-2005 |
| */ |
| TI_STATUS measurementMgr_destroy(TI_HANDLE hMeasurementMgr) |
| { |
| measurementMgr_t *pMeasurementMgr = (measurementMgr_t *) hMeasurementMgr; |
| |
| if (pMeasurementMgr == NULL) |
| return TI_OK; |
| |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": MeasurementMgr is being destroyed\n"); |
| |
| measurementMgr_releaseModule (pMeasurementMgr); |
| |
| return TI_OK; |
| } |
| |
| |
| |
| |
| |
| |
| /** |
| * Sets the Measurement Mode. |
| * |
| * @param hMeasurementMgr A handle to the Measurement Manager module. |
| * @param capabilities The AP capabilities. |
| * @param pIeBuffer Pointer to the list of IEs. |
| * @param length Length of the IE list. |
| * |
| * @date 16-Dec-2005 |
| */ |
| TI_STATUS measurementMgr_setMeasurementMode(TI_HANDLE hMeasurementMgr, TI_UINT16 capabilities, |
| TI_UINT8 * pIeBuffer, TI_UINT16 length) |
| { |
| measurementMgr_t * pMeasurementMgr = (measurementMgr_t *) hMeasurementMgr; |
| |
| /* |
| * 11h Measurement is not supported in the current version. |
| */ |
| /* if( (pMeasurementMgr->Capabilities & MEASUREMENT_CAPABILITIES_DOT11H) && |
| (capabilities & DOT11_SPECTRUM_MANAGEMENT) ) |
| { |
| pMeasurementMgr->Mode = MSR_MODE_SPECTRUM_MANAGEMENT; |
| } |
| else |
| { |
| */ |
| #ifdef XCC_MODULE_INCLUDED |
| |
| if(pMeasurementMgr->Capabilities & MEASUREMENT_CAPABILITIES_XCC_RM) |
| { |
| pMeasurementMgr->Mode = MSR_MODE_XCC; |
| } |
| else |
| #endif |
| { |
| pMeasurementMgr->Mode = MSR_MODE_NONE; |
| } |
| |
| |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": MeasurementMgr mode changed to: %d\n", pMeasurementMgr->Mode); |
| |
| return TI_OK; |
| } |
| |
| |
| |
| |
| |
| |
| /** |
| * Called when a frame with type measurement request is received. |
| * |
| * @param hMeasurementMgr A handle to the Measurement Manager module. |
| * @param frameType The frame type. |
| * @param dataLen The length of the frame. |
| * @param pData A pointer to the frame's content. |
| * |
| * @date 16-Dec-2005 |
| */ |
| TI_STATUS measurementMgr_receiveFrameRequest(TI_HANDLE hMeasurementMgr, |
| EMeasurementFrameType frameType, |
| TI_INT32 dataLen, |
| TI_UINT8 * pData) |
| { |
| measurementMgr_t * pMeasurementMgr = (measurementMgr_t *) hMeasurementMgr; |
| |
| TMeasurementFrameRequest * frame = &(pMeasurementMgr->newFrameRequest); |
| TI_UINT16 currentFrameToken; |
| |
| /* checking if measurement is enabled */ |
| if (pMeasurementMgr->Mode == MSR_MODE_NONE) |
| return TI_NOK; |
| |
| /* ignore broadcast/multicast request if unicast request is active */ |
| if (frameType != MSR_FRAME_TYPE_UNICAST && pMeasurementMgr->currentFrameType == MSR_FRAME_TYPE_UNICAST) |
| { |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Broadcast/Multicast measurement frame has been ignored\n"); |
| |
| return TI_NOK; |
| } |
| |
| /* ignore broadcast request if multicast request is active */ |
| if (frameType == MSR_FRAME_TYPE_BROADCAST && pMeasurementMgr->currentFrameType == MSR_FRAME_TYPE_MULTICAST) |
| { |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Broadcast measurement frame has been ignored\n"); |
| |
| return TI_NOK; |
| } |
| |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Measurement frame received\n"); |
| |
| /* Parsing the Frame Request Header */ |
| pMeasurementMgr->parserFrameReq(hMeasurementMgr, pData, dataLen, |
| frame); |
| |
| frame->frameType = frameType; |
| |
| /* checking if the received token frame is the same as the one that is being processed */ |
| if ((requestHandler_getFrameToken(pMeasurementMgr->hRequestH, ¤tFrameToken) == TI_OK) |
| && (currentFrameToken == frame->hdr->dialogToken)) |
| { |
| os_memoryZero(pMeasurementMgr->hOs, &pMeasurementMgr->newFrameRequest, |
| sizeof(TMeasurementFrameRequest)); |
| |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Measurement frame token %d is identical to current frame token - ignoring frame\n", currentFrameToken); |
| |
| return TI_NOK; |
| } |
| |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Measurement frame token is %d\n", frame->hdr->dialogToken); |
| |
| /* Frame is Received for processing */ |
| return measurementMgrSM_event((TI_UINT8 *) &(pMeasurementMgr->currentState), |
| MEASUREMENTMGR_EVENT_FRAME_RECV, pMeasurementMgr); |
| } |
| |
| |
| |
| |
| |
| /** |
| * Activates the next measurement request. |
| * |
| * @param hMeasurementMgr A handle to the Measurement Manager module. |
| * |
| * @date 16-Dec-2005 |
| */ |
| TI_STATUS measurementMgr_activateNextRequest(TI_HANDLE hMeasurementMgr) |
| { |
| measurementMgr_t * pMeasurementMgr = (measurementMgr_t *) hMeasurementMgr; |
| requestHandler_t * pRequestH = (requestHandler_t *) pMeasurementMgr->hRequestH; |
| MeasurementRequest_t * pRequestArr[MAX_NUM_REQ]; |
| TI_UINT8 numOfRequestsInParallel = 0; |
| TI_BOOL valid; |
| TI_UINT8 index; |
| |
| /* Keep note of the time we started processing the request. this will be used */ |
| /* to give the measurementSRV a time frame to perform the measurement operation */ |
| pMeasurementMgr->currentRequestStartTime = os_timeStampMs(pMeasurementMgr->hOs); |
| |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Timer started at %d, we have 20ms to begin measurement...\n", pMeasurementMgr->currentRequestStartTime); |
| |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Looking for a valid request\n"); |
| |
| do |
| { |
| TI_STATUS status; |
| |
| if (numOfRequestsInParallel != 0) |
| { |
| TRACE4(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Changing activeRequestID from %d to %d, and numOfWaitingRequests from %d to %d.\n", pRequestH->activeRequestID, pRequestH->activeRequestID + numOfRequestsInParallel, pRequestH->numOfWaitingRequests, pRequestH->numOfWaitingRequests - numOfRequestsInParallel); |
| } |
| |
| pRequestH->activeRequestID += numOfRequestsInParallel; |
| pRequestH->numOfWaitingRequests -= numOfRequestsInParallel; |
| |
| for (index = 0; index < MAX_NUM_REQ; index++) |
| { |
| pRequestArr[index] = NULL; |
| } |
| numOfRequestsInParallel = 0; |
| |
| /* Getting the next request/requests from the request handler */ |
| status = requestHandler_getNextReq(pMeasurementMgr->hRequestH, TI_FALSE, pRequestArr, |
| &numOfRequestsInParallel); |
| |
| /* Checking if there are no waiting requests */ |
| if (status != TI_OK) |
| { |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": There are no waiting requests in the queue\n"); |
| |
| return measurementMgrSM_event((TI_UINT8 *) &(pMeasurementMgr->currentState), |
| MEASUREMENTMGR_EVENT_SEND_REPORT, pMeasurementMgr); |
| } |
| |
| /* Checking validity of request/s */ |
| valid = measurementMgr_isRequestValid(pMeasurementMgr, pRequestArr, |
| numOfRequestsInParallel); |
| |
| /* Checking if the current request is Beacon Table */ |
| if( (numOfRequestsInParallel == 1) && |
| (pRequestArr[0]->Type == MSR_TYPE_BEACON_MEASUREMENT) && |
| (pRequestArr[0]->ScanMode == MSR_SCAN_MODE_BEACON_TABLE) ) |
| { |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Received Beacon Table request, building a report for it and continuing\n"); |
| |
| pMeasurementMgr->buildReport(hMeasurementMgr, *(pRequestArr[0]), NULL); |
| valid = TI_FALSE; /* In order to get the next request/s*/ |
| } |
| |
| } while (valid == TI_FALSE); |
| |
| |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Request(s) for activation:\n"); |
| |
| for (index = 0; index < numOfRequestsInParallel; index++) |
| { |
| TRACE6(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": \n\nRequest #%d:\n Type: %d\n Measured Channel: %d (Serving Channel: %d)\n Scan Mode: %d\n Duration: %d\n\n", index+1, pRequestArr[index]->Type, pRequestArr[index]->channelNumber, pMeasurementMgr->servingChannelID, pRequestArr[index]->ScanMode, pRequestArr[index]->DurationTime); |
| } |
| |
| /* Ignore requests if traffic intensity is high */ |
| if (measurementMgr_isTrafficIntensityHigherThanThreshold(pMeasurementMgr) == TI_TRUE) |
| { |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Traffic intensity too high, giving up...\n"); |
| |
| measurementMgr_rejectPendingRequests(pMeasurementMgr, MSR_REJECT_TRAFFIC_INTENSITY_TOO_HIGH); |
| |
| return measurementMgrSM_event((TI_UINT8 *) &(pMeasurementMgr->currentState), |
| MEASUREMENTMGR_EVENT_SEND_REPORT, pMeasurementMgr); |
| } |
| |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Request is Valid, about to start\n"); |
| |
| pMeasurementMgr->measuredChannelID = pRequestArr[0]->channelNumber; |
| |
| /* Request resource from the SCR */ |
| return measurementMgrSM_event((TI_UINT8 *) &(pMeasurementMgr->currentState), |
| MEASUREMENTMGR_EVENT_REQUEST_SCR, pMeasurementMgr); |
| } |
| |
| |
| |
| void measurementMgr_rejectPendingRequests(TI_HANDLE hMeasurementMgr, EMeasurementRejectReason rejectReason) |
| { |
| measurementMgr_t * pMeasurementMgr = (measurementMgr_t *) hMeasurementMgr; |
| requestHandler_t * pRequestH = (requestHandler_t *) pMeasurementMgr->hRequestH; |
| MeasurementRequest_t * pRequestArr[MAX_NUM_REQ]; |
| TI_UINT8 numOfRequestsInParallel; |
| |
| /* reject all pending measurement requests */ |
| while (requestHandler_getNextReq(pMeasurementMgr->hRequestH, TI_TRUE, |
| pRequestArr, &numOfRequestsInParallel) == TI_OK) |
| { |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Rejecting pending request (activeRequestID = %d)...\n", pRequestH->activeRequestID); |
| |
| pMeasurementMgr->buildRejectReport(pMeasurementMgr, pRequestArr, |
| numOfRequestsInParallel, rejectReason); |
| |
| pRequestH->activeRequestID += numOfRequestsInParallel; |
| } |
| } |
| |
| |
| |
| |
| |
| /********************************************************************************/ |
| /* Callback functions Implementation. */ |
| /********************************************************************************/ |
| |
| |
| /** |
| * The callback called by the MeasurementSRV module when then |
| * measurement operation has ended. |
| * |
| * @param clientObj A handle to the Measurement Manager module. |
| * @param msrReply An array of replies sent by the MeasurementSRV module, |
| * where each reply contains the result of a single measurement request. |
| * |
| * @date 01-Jan-2006 |
| */ |
| void measurementMgr_MeasurementCompleteCB(TI_HANDLE clientObj, TMeasurementReply * msrReply) |
| { |
| measurementMgr_t *pMeasurementMgr = (measurementMgr_t *) clientObj; |
| TI_UINT8 index; |
| |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Building reports for measurement requests\n"); |
| |
| /* build a report for each measurement request/reply pair */ |
| for (index = 0; index < msrReply->numberOfTypes; index++) |
| { |
| pMeasurementMgr->buildReport(pMeasurementMgr, *(pMeasurementMgr->currentRequest[index]), &msrReply->msrTypes[index]); |
| } |
| |
| measurementMgrSM_event((TI_UINT8 *) &(pMeasurementMgr->currentState), |
| MEASUREMENTMGR_EVENT_COMPLETE, pMeasurementMgr); |
| } |
| |
| |
| /** |
| * The callback called when the SCR responds to the SCR request. |
| * |
| * @param hClient A handle to the Measurement Manager module. |
| * @param requestStatus The request's status |
| * @param eResource The resource for which the CB is issued |
| * @param pendReason The reason of a PEND status. |
| * |
| * @date 01-Jan-2006 |
| */ |
| void measurementMgr_scrResponseCB(TI_HANDLE hClient, EScrClientRequestStatus requestStatus, |
| EScrResourceId eResource, EScePendReason pendReason ) |
| { |
| measurementMgr_t * pMeasurementMgr = (measurementMgr_t *) hClient; |
| measurementMgrSM_Events event; |
| |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": SCR callback entered\n"); |
| |
| /* If the SM is in a state where it waits for the CB, status of RUN */ |
| /* results in the SM asking the measurementSRV to start measurement; */ |
| /* otherwise we got an ABORT or a PEND reason worse than the one we */ |
| /* got when calling the SCR, so the SM aborts the measurement */ |
| if (pMeasurementMgr->currentState == MEASUREMENTMGR_STATE_WAITING_FOR_SCR) |
| { |
| if (requestStatus == SCR_CRS_RUN) |
| { |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Received SCR status RUN, running...\n"); |
| |
| event = MEASUREMENTMGR_EVENT_SCR_RUN; |
| } |
| else |
| { |
| if (requestStatus == SCR_CRS_PEND) |
| { |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Received SCR status PEND with reason %d, aborting...\n", pendReason); |
| } |
| else |
| { |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Received SCR status ABORT/FW_RESET, aborting...\n"); |
| } |
| |
| event = MEASUREMENTMGR_EVENT_ABORT; |
| } |
| } |
| else |
| { |
| /* This can only occur if FW reset occurs or when higher priority client is running. */ |
| |
| if (requestStatus == SCR_CRS_FW_RESET) |
| { |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Received SCR status FW_RESET\n"); |
| |
| event = MEASUREMENTMGR_EVENT_FW_RESET; |
| } |
| else |
| { |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": MeasurementMgrSM current state is %d (which isn't WAITING_FOR_SCR), aborting...\n", pMeasurementMgr->currentState); |
| |
| event = MEASUREMENTMGR_EVENT_ABORT; |
| } |
| } |
| |
| measurementMgrSM_event((TI_UINT8 *) &(pMeasurementMgr->currentState), |
| event, pMeasurementMgr); |
| } |
| |
| |
| |
| |
| |
| |
| /** |
| * The callback called by the MLME. |
| * |
| * @param hMeasurementMgr A handle to the Measurement Manager module. |
| * |
| * @date 01-Jan-2006 |
| */ |
| void measurementMgr_mlmeResultCB(TI_HANDLE hMeasurementMgr, TMacAddr * bssid, mlmeFrameInfo_t * frameInfo, |
| TRxAttr * pRxAttr, TI_UINT8 * buffer, TI_UINT16 bufferLength) |
| { |
| measurementMgr_t * pMeasurementMgr = (measurementMgr_t *) hMeasurementMgr; |
| TScanFrameInfo tScanFrameInfo; |
| |
| if (measurementMgrSM_measureInProgress(pMeasurementMgr) == TI_FALSE) |
| { |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION , "measurementMgr_mlmeResultCB: measurement not in progress, return\n"); |
| return; |
| } |
| |
| |
| /* erroneous frames are notifed to the measurmenet manager to update counter |
| (add counter sometimes in the future) Look at: scanCncn_ScanCompleteNotificationCB and |
| scanCncn_MlmeResultCB */ |
| if (NULL == bssid) |
| { |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION , "measurementMgr_mlmeResultCB: received an empty frame notification from MLME\n"); |
| return; |
| } |
| |
| if (pMeasurementMgr == NULL || pRxAttr == NULL) |
| { |
| if(pMeasurementMgr != NULL) |
| { |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_ERROR, ": MLME callback called with NULL object\n"); |
| } |
| return; |
| } |
| |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": MLME callback entered\n"); |
| |
| /* build the scan frame info object */ |
| tScanFrameInfo.bssId = bssid; |
| tScanFrameInfo.band = (ERadioBand)pRxAttr->band; |
| tScanFrameInfo.channel = pRxAttr->channel; |
| tScanFrameInfo.parsedIEs = frameInfo; |
| tScanFrameInfo.rate = pRxAttr->Rate; |
| tScanFrameInfo.rssi = pRxAttr->Rssi; |
| tScanFrameInfo.snr = pRxAttr->SNR; |
| tScanFrameInfo.staTSF = pRxAttr->TimeStamp; |
| tScanFrameInfo.buffer = buffer; |
| tScanFrameInfo.bufferLength = bufferLength; |
| |
| /* update the driver (SME) result table */ |
| sme_MeansurementScanResult (pMeasurementMgr->hSme, SCAN_CRS_RECEIVED_FRAME, &tScanFrameInfo); |
| |
| TRACE8(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": MLME Frame: Subtype = %d, MAC = %x-%x-%x-%x-%x-%x, RSSI = %d\n", frameInfo->subType, (*bssid)[0], (*bssid)[1], (*bssid)[2], (*bssid)[3], (*bssid)[4], (*bssid)[5], pRxAttr->Rssi); |
| } |
| |
| |
| /********************************************************************************/ |
| /* Internal functions Implementation. */ |
| /********************************************************************************/ |
| |
| |
| /** |
| * Releases the module's allocated objects according to the given init vector. |
| * |
| * @param pMeasurementMgr A handle to the Measurement Manager module. |
| * @param initVec The init vector with a bit set for each allocated object. |
| * |
| * @date 01-Jan-2006 |
| */ |
| static void measurementMgr_releaseModule (measurementMgr_t * pMeasurementMgr) |
| { |
| #ifdef XCC_MODULE_INCLUDED |
| TI_UINT32 currAC; |
| #endif |
| |
| if (pMeasurementMgr->hActivationDelayTimer) |
| { |
| tmr_DestroyTimer (pMeasurementMgr->hActivationDelayTimer); |
| } |
| |
| #ifdef XCC_MODULE_INCLUDED |
| for (currAC = 0; currAC < MAX_NUM_OF_AC; currAC++) |
| { |
| if (pMeasurementMgr->hTsMetricsReportTimer[currAC]) |
| { |
| tmr_DestroyTimer (pMeasurementMgr->hTsMetricsReportTimer[currAC]); |
| } |
| } |
| #endif |
| |
| if (pMeasurementMgr->pMeasurementMgrSm) |
| { |
| fsm_Unload(pMeasurementMgr->hOs, pMeasurementMgr->pMeasurementMgrSm); |
| } |
| |
| if (pMeasurementMgr->hRequestH) |
| { |
| requestHandler_destroy(pMeasurementMgr->hRequestH); |
| } |
| |
| os_memoryFree(pMeasurementMgr->hOs, pMeasurementMgr, sizeof(measurementMgr_t)); |
| } |
| |
| |
| |
| /** |
| * Checks whether the traffic intensity, i.e. number of packets per seconds, is higher |
| * than the preconfigured threshold. |
| * |
| * @param pMeasurementMgr A handle to the Measurement Manager module. |
| * |
| * @return True iff the traffic intensity is high |
| * |
| * @date 01-Jan-2006 |
| */ |
| static TI_BOOL measurementMgr_isTrafficIntensityHigherThanThreshold(measurementMgr_t * pMeasurementMgr) |
| { |
| TI_BOOL trafficIntensityHigh = TI_FALSE; |
| int pcksPerSec; |
| |
| pcksPerSec = TrafficMonitor_GetFrameBandwidth(pMeasurementMgr->hTrafficMonitor); |
| |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": pcksPerSec = %d\n", pcksPerSec); |
| |
| if (pcksPerSec >= pMeasurementMgr->trafficIntensityThreshold) |
| trafficIntensityHigh = TI_TRUE; |
| |
| return trafficIntensityHigh; |
| } |
| |
| |
| |
| |
| /** |
| * Checks whether the given measurement request is valid. |
| * |
| * @param hMeasurementMgr A handle to the Measurement Manager module. |
| * @param pRequestArr The measurement request. |
| * @param numOfRequest Number of type requests |
| * |
| * @return True iff the request is valid |
| * |
| * @date 01-Jan-2006 |
| */ |
| static TI_BOOL measurementMgr_isRequestValid(TI_HANDLE hMeasurementMgr, MeasurementRequest_t *pRequestArr[], |
| TI_UINT8 numOfRequest) |
| { |
| measurementMgr_t * pMeasurementMgr = (measurementMgr_t *) hMeasurementMgr; |
| TI_UINT8 requestIndex; |
| paramInfo_t param; |
| |
| /* Checking validity of the measured channel number */ |
| param.content.channel = pRequestArr[0]->channelNumber; |
| param.paramType = REGULATORY_DOMAIN_IS_CHANNEL_SUPPORTED; |
| regulatoryDomain_getParam(pMeasurementMgr->hRegulatoryDomain, ¶m); |
| if ( !param.content.bIsChannelSupprted ) |
| { |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Request rejected due to invalid channel\n"); |
| |
| if (pMeasurementMgr->currentFrameType == MSR_FRAME_TYPE_UNICAST) |
| pMeasurementMgr->buildRejectReport(pMeasurementMgr, pRequestArr, numOfRequest, |
| MSR_REJECT_INVALID_CHANNEL); |
| |
| return TI_FALSE; |
| } |
| else |
| { |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Request channel is Valid\n"); |
| } |
| |
| TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Starting to check each request:\n"); |
| |
| /* Check Validity of each request */ |
| for (requestIndex = 0; requestIndex < numOfRequest; requestIndex++) |
| { |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Checking request #%d:\n", requestIndex+1); |
| |
| /* Checking validity of the Request Type */ |
| if (pMeasurementMgr->isTypeValid(hMeasurementMgr, pRequestArr[requestIndex]->Type, |
| pRequestArr[requestIndex]->ScanMode) == TI_FALSE) |
| { |
| TRACE2(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Request rejected due to invalid measurement type of request #%d (type = %d)\n", requestIndex+1, pRequestArr[requestIndex]->Type); |
| |
| if(pMeasurementMgr->currentFrameType == MSR_FRAME_TYPE_UNICAST) |
| pMeasurementMgr->buildRejectReport(pMeasurementMgr, pRequestArr, numOfRequest, |
| MSR_REJECT_INVALID_MEASUREMENT_TYPE); |
| |
| return TI_FALSE; |
| } |
| else |
| { |
| TRACE2(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Measurement type of request #%d is supported (type = %d)\n", requestIndex+1, pRequestArr[requestIndex]->Type); |
| } |
| |
| /* For measurement types different than Beacon Table */ |
| if ((pRequestArr[requestIndex]->Type != MSR_TYPE_BEACON_MEASUREMENT) || |
| (pRequestArr[requestIndex]->ScanMode != MSR_SCAN_MODE_BEACON_TABLE)) |
| { |
| /* Checking Measurement request's duration only when request is on a non-serving channel */ |
| if (pMeasurementMgr->servingChannelID != pRequestArr[requestIndex]->channelNumber) |
| { |
| TI_UINT8 dtimPeriod; |
| TI_UINT32 beaconInterval; |
| TI_UINT32 dtimDuration; |
| |
| |
| /* Checking duration doesn't exceed given max duration */ |
| if (pRequestArr[requestIndex]->DurationTime > pMeasurementMgr->maxDurationOnNonServingChannel) |
| { |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Request #%d rejected because duration exceeds maximum duration\n", requestIndex+1); |
| |
| TRACE2(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Duration = %d, MaxDurationOnNonServingChannel = %d\n", pRequestArr[requestIndex]->DurationTime, pMeasurementMgr->maxDurationOnNonServingChannel); |
| |
| if (pMeasurementMgr->currentFrameType == MSR_FRAME_TYPE_UNICAST) |
| pMeasurementMgr->buildRejectReport(pMeasurementMgr, pRequestArr, numOfRequest, |
| MSR_REJECT_DURATION_EXCEED_MAX_DURATION); |
| |
| return TI_FALSE; |
| } |
| else |
| { |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Duration of request #%d doesn't exceed max duration\n", requestIndex+1); |
| } |
| |
| |
| /* Checking DTIM */ |
| |
| /* Getting the DTIM count */ |
| param.paramType = SITE_MGR_DTIM_PERIOD_PARAM; |
| siteMgr_getParam(pMeasurementMgr->hSiteMgr, ¶m); |
| dtimPeriod = param.content.siteMgrDtimPeriod; |
| |
| /* Getting the beacon Interval */ |
| param.paramType = SITE_MGR_BEACON_INTERVAL_PARAM; |
| siteMgr_getParam(pMeasurementMgr->hSiteMgr, ¶m); |
| beaconInterval = param.content.beaconInterval; |
| |
| dtimDuration = beaconInterval * MEASUREMENT_BEACON_INTERVAL_IN_MICRO_SEC/MEASUREMENT_MSEC_IN_MICRO*dtimPeriod; |
| if (pRequestArr[requestIndex]->DurationTime > dtimDuration) |
| { |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_WARNING, ": Request rejected due to DTIM overlap of request #%d\n", requestIndex+1); |
| |
| TRACE2(pMeasurementMgr->hReport, REPORT_SEVERITY_WARNING, ": Duration = %d, DTIM Duration = %d\n", pRequestArr[requestIndex]->DurationTime, dtimDuration); |
| |
| if (pMeasurementMgr->currentFrameType == MSR_FRAME_TYPE_UNICAST) |
| pMeasurementMgr->buildRejectReport(pMeasurementMgr, pRequestArr, numOfRequest, |
| MSR_REJECT_DTIM_OVERLAP); |
| |
| return TI_FALSE; |
| } |
| else |
| { |
| TRACE1(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": DTIM of request #%d doesn't overlap\n", requestIndex+1); |
| } |
| } |
| } |
| } |
| |
| return TI_TRUE; |
| } |
| |
| static TI_BOOL measurementMgrSM_measureInProgress(TI_HANDLE hMeasurementMgr) |
| { |
| measurementMgr_t * pMeasurementMgr = (measurementMgr_t *)hMeasurementMgr; |
| |
| if (pMeasurementMgr->currentState == MEASUREMENTMGR_STATE_MEASURING) |
| return TI_TRUE; |
| |
| else |
| return TI_FALSE; |
| } |
| |
| |
