| /* |
| * SwitchChannel.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. |
| */ |
| |
| /** \file SwitchChannel.c |
| * \brief SwitchChannel module interface |
| * |
| * \see SwitchChannelApi.h |
| */ |
| |
| /****************************************************************************************************/ |
| /* */ |
| /* MODULE: SwitchChannel.c */ |
| /* PURPOSE: SwitchChannel module interface. */ |
| /* This module perform SwitchChannel (Dynamic Frequency Selection) */ |
| /* according to AP command. The object responsibles for switching channel after*/ |
| /* the requires time and quieting the channel for the required duration */ |
| /* time. */ |
| /****************************************************************************************************/ |
| |
| #define __FILE_ID__ FILE_ID_7 |
| #include "tidef.h" |
| #include "report.h" |
| #include "osApi.h" |
| #include "paramOut.h" |
| #include "SwitchChannelApi.h" |
| #include "DataCtrl_Api.h" |
| #include "regulatoryDomainApi.h" |
| #include "apConn.h" |
| #include "siteMgrApi.h" |
| #include "PowerMgr_API.h" |
| #include "healthMonitor.h" |
| #include "TWDriver.h" |
| #include "DrvMainModules.h" |
| |
| /* allocation vector */ |
| #define SC_INIT_BIT (1) |
| #define SC_SM_INIT_BIT (2) |
| |
| #define SC_SWITCH_CHANNEL_CMD_LEN 3 |
| #define SC_SWITCH_CHANNEL_MODE_NOT_TX_SUS 0 |
| #define SC_SWITCH_CHANNEL_MODE_TX_SUS 1 |
| |
| |
| #define SC_CHANNEL_INVALID TI_FALSE |
| #define SC_CHANNEL_VALID TI_TRUE |
| |
| /* Enumerations */ |
| |
| /** state machine states */ |
| typedef enum |
| { |
| SC_STATE_IDLE = 0, |
| SC_STATE_WAIT_4_CMD = 1, |
| SC_STATE_WAIT_4_SCR = 2, |
| SC_STATE_SC_IN_PROG = 3, |
| SC_STATE_LAST = 4 |
| } switchChannel_smStates; |
| |
| /** State machine events */ |
| typedef enum |
| { |
| SC_EVENT_START = 0, |
| SC_EVENT_STOP = 1, |
| SC_EVENT_SC_CMD = 2, |
| SC_EVENT_SCR_RUN = 3, |
| SC_EVENT_SCR_FAIL = 4, |
| SC_EVENT_SC_CMPLT = 5, |
| SC_EVENT_FW_RESET = 6, |
| SC_EVENT_LAST = 7 |
| } switchChannel_smEvents; |
| |
| |
| #define SC_NUM_STATES SC_STATE_LAST |
| #define SC_NUM_EVENTS SC_EVENT_LAST |
| |
| |
| /* Structures */ |
| typedef struct |
| { |
| |
| /* SwitchChannel parameters that can be configured externally */ |
| TI_BOOL dot11SpectrumManagementRequired; |
| |
| /* Internal SwitchChannel parameters */ |
| TI_UINT8 currentState; |
| dot11_CHANNEL_SWITCH_t curChannelSwitchCmdParams; |
| TI_UINT32 SCRRequestTimestamp; |
| TI_UINT8 currentChannel; |
| TI_BOOL switchChannelStarted; |
| |
| #ifdef TI_DBG |
| /* switchChannelCmd for debug */ |
| dot11_CHANNEL_SWITCH_t debugChannelSwitchCmdParams; |
| TI_UINT8 ignoreCancelSwitchChannelCmd; |
| #endif |
| |
| /* SwitchChannel SM */ |
| fsm_stateMachine_t *pSwitchChannelSm; |
| |
| /* SwitchChannel handles to other objects */ |
| TI_HANDLE hTWD; |
| TI_HANDLE hSiteMgr; |
| TI_HANDLE hSCR; |
| TI_HANDLE hRegulatoryDomain; |
| TI_HANDLE hPowerMngr; |
| TI_HANDLE hApConn; |
| TI_HANDLE hReport; |
| TI_HANDLE hOs; |
| |
| } switchChannel_t; |
| |
| |
| |
| |
| /* External data definitions */ |
| |
| /* Local functions definitions */ |
| |
| /* Global variables */ |
| |
| |
| /********************************************************************************/ |
| /* Internal functions prototypes. */ |
| /********************************************************************************/ |
| |
| |
| /* SM functions */ |
| static TI_STATUS switchChannel_smStartSwitchChannelCmd(void *pData); |
| static TI_STATUS switchChannel_smReqSCR_UpdateCmd(void *pData); |
| static TI_STATUS switchChannel_smSwitchChannelCmplt(void *pData); |
| static TI_STATUS switchChannel_smFwResetWhileSCInProg(void *pData); |
| static TI_STATUS switchChannel_smScrFailWhileWait4Scr(void *pData); |
| static TI_STATUS switchChannel_smNop(void *pData); |
| static TI_STATUS switchChannel_smUnexpected(void *pData); |
| static TI_STATUS switchChannel_smStopWhileWait4Cmd(void *pData); |
| static TI_STATUS switchChannel_smStopWhileWait4Scr(void *pData); |
| static TI_STATUS switchChannel_smStopWhileSwitchChannelInProg(void *pData); |
| static TI_STATUS switchChannel_smStart(void *pData); |
| |
| |
| /* other functions */ |
| static void release_module(switchChannel_t *pSwitchChannel, TI_UINT32 initVec); |
| static TI_STATUS switchChannel_smEvent(TI_UINT8 *currState, TI_UINT8 event, void* data); |
| static void switchChannel_zeroDatabase(switchChannel_t *pSwitchChannel); |
| void switchChannel_SwitchChannelCmdCompleteReturn(TI_HANDLE hSwitchChannel); |
| void switchChannel_scrStatusCB(TI_HANDLE hSwitchChannel, EScrClientRequestStatus requestStatus, |
| EScrResourceId eResource, EScePendReason pendReason ); |
| #ifdef TI_DBG |
| static void switchChannel_recvCmd4Debug(TI_HANDLE hSwitchChannel, dot11_CHANNEL_SWITCH_t *channelSwitch, TI_BOOL BeaconPacket, TI_UINT8 channel); |
| #endif |
| |
| |
| /********************************************************************************/ |
| /* Interface functions Implementation. */ |
| /********************************************************************************/ |
| |
| |
| /************************************************************************ |
| * switchChannel_create * |
| ************************************************************************/ |
| /** |
| * |
| * \b Description: |
| * |
| * This procedure is called by the config manager when the driver is created. |
| * It creates the SwitchChannel object. |
| * |
| * \b ARGS: |
| * |
| * I - hOs - OS context \n |
| * |
| * \b RETURNS: |
| * |
| * Handle to the SwitchChannel object. |
| * |
| * \sa |
| */ |
| TI_HANDLE switchChannel_create(TI_HANDLE hOs) |
| { |
| switchChannel_t *pSwitchChannel = NULL; |
| TI_UINT32 initVec = 0; |
| TI_STATUS status; |
| |
| /* allocating the SwitchChannel object */ |
| pSwitchChannel = os_memoryAlloc(hOs,sizeof(switchChannel_t)); |
| |
| if (pSwitchChannel == NULL) |
| return NULL; |
| |
| initVec |= (1 << SC_INIT_BIT); |
| |
| os_memoryZero(hOs, pSwitchChannel, sizeof(switchChannel_t)); |
| |
| pSwitchChannel->hOs = hOs; |
| |
| status = fsm_Create(hOs, &pSwitchChannel->pSwitchChannelSm, SC_NUM_STATES, SC_NUM_EVENTS); |
| if (status != TI_OK) |
| { |
| release_module(pSwitchChannel, initVec); |
| WLAN_OS_REPORT(("FATAL ERROR: switchChannel_create(): Error Creating pSwitchChannelSm - Aborting\n")); |
| return NULL; |
| } |
| initVec |= (1 << SC_SM_INIT_BIT); |
| |
| return(pSwitchChannel); |
| } |
| |
| /************************************************************************ |
| * switchChannel_init * |
| ************************************************************************/ |
| /** |
| * |
| * \b Description: |
| * |
| * This procedure is called by the DrvMain when the driver is initialized. |
| * It initializes the SwitchChannel object's variables and handlers and creates the SwitchChannel SM. |
| * |
| * \b ARGS: |
| * |
| * I - pStadHandles - The driver modules handles \n |
| * |
| * \b RETURNS: |
| * |
| * void |
| * |
| * \sa |
| */ |
| void switchChannel_init (TStadHandlesList *pStadHandles) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t *)(pStadHandles->hSwitchChannel); |
| |
| /** Roaming State Machine matrix */ |
| fsm_actionCell_t switchChannel_SM[SC_NUM_STATES][SC_NUM_EVENTS] = |
| { |
| /* next state and actions for IDLE state */ |
| { {SC_STATE_WAIT_4_CMD, switchChannel_smStart}, /* START */ |
| {SC_STATE_IDLE, switchChannel_smNop}, /* STOP */ |
| {SC_STATE_IDLE, switchChannel_smNop}, /* SC_CMD */ |
| {SC_STATE_IDLE, switchChannel_smUnexpected}, /* SCR_RUN */ |
| {SC_STATE_IDLE, switchChannel_smUnexpected}, /* SCR_FAIL */ |
| {SC_STATE_IDLE, switchChannel_smUnexpected}, /* SC_CMPLT */ |
| {SC_STATE_IDLE, switchChannel_smUnexpected} /* FW_RESET */ |
| }, |
| |
| /* next state and actions for WAIT_4_CMD state */ |
| { {SC_STATE_WAIT_4_CMD, switchChannel_smNop}, /* START */ |
| {SC_STATE_IDLE, switchChannel_smStopWhileWait4Cmd}, /* STOP */ |
| {SC_STATE_WAIT_4_SCR, switchChannel_smReqSCR_UpdateCmd}, /* SC_CMD */ |
| {SC_STATE_WAIT_4_CMD, switchChannel_smUnexpected}, /* SCR_RUN */ |
| {SC_STATE_WAIT_4_CMD, switchChannel_smUnexpected}, /* SCR_FAIL */ |
| {SC_STATE_WAIT_4_CMD, switchChannel_smUnexpected}, /* SC_CMPLT */ |
| {SC_STATE_WAIT_4_CMD, switchChannel_smUnexpected} /* FW_RESET */ |
| |
| }, |
| |
| /* next state and actions for WAIT_4_SCR state */ |
| { {SC_STATE_WAIT_4_SCR, switchChannel_smUnexpected}, /* START */ |
| {SC_STATE_IDLE, switchChannel_smStopWhileWait4Scr}, /* STOP */ |
| {SC_STATE_WAIT_4_SCR, switchChannel_smNop}, /* SC_CMD */ |
| {SC_STATE_SC_IN_PROG, switchChannel_smStartSwitchChannelCmd}, /* SCR_RUN */ |
| {SC_STATE_WAIT_4_CMD, switchChannel_smScrFailWhileWait4Scr}, /* SCR_FAIL */ |
| {SC_STATE_WAIT_4_SCR, switchChannel_smUnexpected} , /* SC_CMPLT */ |
| {SC_STATE_WAIT_4_CMD, switchChannel_smUnexpected} /* FW_RESET */ |
| |
| }, |
| |
| /* next state and actions for switchChannel_IN_PROG state */ |
| { {SC_STATE_SC_IN_PROG, switchChannel_smUnexpected}, /* START */ |
| {SC_STATE_IDLE, switchChannel_smStopWhileSwitchChannelInProg}, /* STOP */ |
| {SC_STATE_SC_IN_PROG, switchChannel_smNop}, /* SC_CMD */ |
| {SC_STATE_SC_IN_PROG, switchChannel_smUnexpected}, /* SCR_RUN */ |
| {SC_STATE_WAIT_4_CMD, switchChannel_smUnexpected}, /* SCR_FAIL */ |
| {SC_STATE_WAIT_4_CMD, switchChannel_smSwitchChannelCmplt}, /* SC_CMPLT */ |
| {SC_STATE_WAIT_4_CMD, switchChannel_smFwResetWhileSCInProg} /* FW_RESET */ |
| } |
| }; |
| |
| fsm_Config(pSwitchChannel->pSwitchChannelSm, |
| &switchChannel_SM[0][0], |
| SC_NUM_STATES, |
| SC_NUM_EVENTS, |
| switchChannel_smEvent, pSwitchChannel->hOs); |
| |
| /* init handlers */ |
| pSwitchChannel->hTWD = pStadHandles->hTWD; |
| pSwitchChannel->hSiteMgr = pStadHandles->hSiteMgr; |
| pSwitchChannel->hSCR = pStadHandles->hSCR; |
| pSwitchChannel->hRegulatoryDomain = pStadHandles->hRegulatoryDomain; |
| pSwitchChannel->hApConn = pStadHandles->hAPConnection; |
| pSwitchChannel->hReport = pStadHandles->hReport; |
| pSwitchChannel->hOs = pStadHandles->hOs; |
| } |
| |
| |
| TI_STATUS switchChannel_SetDefaults (TI_HANDLE hSwitchChannel, SwitchChannelInitParams_t *SwitchChannelInitParams) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t *)hSwitchChannel; |
| |
| /* init variables */ |
| pSwitchChannel->dot11SpectrumManagementRequired = SwitchChannelInitParams->dot11SpectrumManagementRequired; |
| pSwitchChannel->currentState = SC_STATE_IDLE; |
| pSwitchChannel->currentChannel = 0; |
| pSwitchChannel->switchChannelStarted = TI_FALSE; |
| |
| /* register to SCR */ |
| scr_registerClientCB(pSwitchChannel->hSCR, SCR_CID_SWITCH_CHANNEL, |
| switchChannel_scrStatusCB, pSwitchChannel); |
| |
| /* register to Switch Channel Complete event in HAL */ |
| TWD_RegisterEvent (pSwitchChannel->hTWD, |
| TWD_OWN_EVENT_SWITCH_CHANNEL_CMPLT, |
| (void *)switchChannel_SwitchChannelCmdCompleteReturn, |
| pSwitchChannel); |
| |
| TWD_EnableEvent (pSwitchChannel->hTWD, TWD_OWN_EVENT_SWITCH_CHANNEL_CMPLT); |
| #ifdef TI_DBG |
| /* for debug */ |
| pSwitchChannel->debugChannelSwitchCmdParams.hdr[0] = CHANNEL_SWITCH_ANNOUNCEMENT_IE_ID; |
| pSwitchChannel->debugChannelSwitchCmdParams.hdr[1] = SC_SWITCH_CHANNEL_CMD_LEN; |
| pSwitchChannel->ignoreCancelSwitchChannelCmd = 0; |
| #endif |
| TRACE0(pSwitchChannel->hReport, REPORT_SEVERITY_INIT, ".....SwitchChannel configured successfully\n"); |
| |
| return TI_OK; |
| } |
| |
| |
| /************************************************************************ |
| * switchChannel_stop * |
| ************************************************************************/ |
| /** |
| * |
| * \b Description: |
| * |
| * This procedure is called by the SME when the state is changed from CONNECTED. |
| * It generates a STOP event to the SwitchChannel SM. |
| * |
| * \b ARGS: |
| * |
| * I - hSwitchChannel - SwitchChannel context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise |
| * |
| * \sa |
| */ |
| TI_STATUS switchChannel_stop(TI_HANDLE hSwitchChannel) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t *)hSwitchChannel; |
| |
| pSwitchChannel->switchChannelStarted = TI_FALSE; |
| return (switchChannel_smEvent((TI_UINT8*)&pSwitchChannel->currentState, SC_EVENT_STOP, pSwitchChannel)); |
| |
| } |
| |
| /************************************************************************ |
| * switchChannel_start * |
| ************************************************************************/ |
| /** |
| * |
| * \b Description: |
| * |
| * This procedure is called by the SME when the state is changed to CONNECTED. |
| * It generates a START event to the SwitchChannel SM. |
| * |
| * \b ARGS: |
| * |
| * I - hSwitchChannel - SwitchChannel context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise |
| * |
| * \sa |
| */ |
| TI_STATUS switchChannel_start(TI_HANDLE hSwitchChannel) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t *)hSwitchChannel; |
| pSwitchChannel->switchChannelStarted = TI_TRUE; |
| |
| return (switchChannel_smEvent((TI_UINT8*)&pSwitchChannel->currentState, SC_EVENT_START, pSwitchChannel)); |
| |
| } |
| |
| |
| /************************************************************************ |
| * switchChannel_unload * |
| ************************************************************************/ |
| /** |
| * |
| * \b Description: |
| * |
| * This procedure is called by the config manager when the driver is unloaded. |
| * It frees any memory allocated and timers. |
| * |
| * \b ARGS: |
| * |
| * I - hSwitchChannel - SwitchChannel context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise |
| * |
| * \sa |
| */ |
| TI_STATUS switchChannel_unload(TI_HANDLE hSwitchChannel) |
| { |
| TI_UINT32 initVec; |
| switchChannel_t *pSwitchChannel = (switchChannel_t *)hSwitchChannel; |
| |
| if (pSwitchChannel == NULL) |
| return TI_OK; |
| |
| initVec = 0xff; |
| release_module(pSwitchChannel, initVec); |
| |
| return TI_OK; |
| } |
| |
| |
| /************************************************************************ |
| * switchChannel_recvCmd * |
| ************************************************************************/ |
| /*DESCRIPTION: This function is called by MLME Parser upon receiving of |
| Beacon, Probe Response or Action with Switch Channel command, |
| or beacon/ |
| performs the following: |
| - Initializes the switching channel procedure. |
| - Setting timer to the actual switching time(if needed) |
| |
| INPUT: hSwitchChannel - SwitchChannel handle. |
| switchMode - indicates whether to stop transmission |
| until the scheduled channel switch. |
| newChannelNum - indicates the number of the new channel. |
| durationTime - indicates the time (expressed in ms) until |
| the scheduled channel switch should accure. |
| |
| OUTPUT: None |
| |
| RETURN: TI_OK on success, TI_NOK otherwise |
| |
| ************************************************************************/ |
| |
| void switchChannel_recvCmd(TI_HANDLE hSwitchChannel, dot11_CHANNEL_SWITCH_t *channelSwitch, TI_UINT8 channel) |
| { |
| |
| switchChannel_t *pSwitchChannel = (switchChannel_t *)hSwitchChannel; |
| paramInfo_t param; |
| |
| if (pSwitchChannel==NULL) |
| { |
| return; |
| } |
| |
| param.paramType = REGULATORY_DOMAIN_DFS_CHANNELS_RANGE; |
| regulatoryDomain_getParam(pSwitchChannel->hRegulatoryDomain, ¶m); |
| |
| if (!pSwitchChannel->dot11SpectrumManagementRequired || |
| (channel < param.content.DFS_ChannelRange.minDFS_channelNum) || |
| (channel > param.content.DFS_ChannelRange.maxDFS_channelNum)) |
| { /* Do not parse Switch Channel IE, when SpectrumManagement is disabled, |
| or the channel is non-DFS channel */ |
| return; |
| } |
| #ifdef TI_DBG |
| /* for debug purposes only */ |
| if (pSwitchChannel->ignoreCancelSwitchChannelCmd != 0) |
| { |
| return; |
| } |
| #endif |
| |
| if (channelSwitch == NULL) |
| { /* No SC IE, update regDomain */ |
| param.paramType = REGULATORY_DOMAIN_UPDATE_CHANNEL_VALIDITY; |
| param.content.channel = channel; |
| regulatoryDomain_setParam(pSwitchChannel->hRegulatoryDomain, ¶m); |
| } |
| else |
| { /* SC IE exists */ |
| TRACE3(pSwitchChannel->hReport, REPORT_SEVERITY_INFORMATION, "switchChannel_recvFrame, SwitchChannel cmd was found, channel no=%d, mode=%d, TBTT=%d \n", channelSwitch->channelNumber, channelSwitch->channelSwitchMode, channelSwitch->channelSwitchCount); |
| |
| /* Checking channel number validity */ |
| param.content.channel = channelSwitch->channelNumber; |
| param.paramType = REGULATORY_DOMAIN_IS_CHANNEL_SUPPORTED; |
| regulatoryDomain_getParam(pSwitchChannel->hRegulatoryDomain,¶m); |
| if ( ( !param.content.bIsChannelSupprted ) || |
| (channelSwitch->channelSwitchCount == 0) || |
| (channelSwitch->channelSwitchMode == SC_SWITCH_CHANNEL_MODE_TX_SUS)) |
| { /* Trigger Roaming, if TX mode is disabled, the new channel number is invalid, |
| or the TBTT count is 0 */ |
| TRACE0(pSwitchChannel->hReport, REPORT_SEVERITY_INFORMATION, "report Roaming trigger\n"); |
| if (channelSwitch->channelSwitchMode == SC_SWITCH_CHANNEL_MODE_TX_SUS) |
| { |
| param.paramType = REGULATORY_DOMAIN_SET_CHANNEL_VALIDITY; |
| param.content.channelValidity.channelNum = channel; |
| param.content.channelValidity.channelValidity = TI_FALSE; |
| regulatoryDomain_setParam(pSwitchChannel->hRegulatoryDomain, ¶m); |
| } |
| |
| if (TI_TRUE == pSwitchChannel->switchChannelStarted) |
| { |
| apConn_reportRoamingEvent(pSwitchChannel->hApConn, ROAMING_TRIGGER_SWITCH_CHANNEL, NULL); |
| } |
| |
| } |
| else |
| { /* Invoke Switch Channel command */ |
| /* update the new SCC params */ |
| pSwitchChannel->curChannelSwitchCmdParams.channelNumber = channelSwitch->channelNumber; |
| pSwitchChannel->curChannelSwitchCmdParams.channelSwitchCount = channelSwitch->channelSwitchCount; |
| pSwitchChannel->curChannelSwitchCmdParams.channelSwitchMode = channelSwitch->channelSwitchMode; |
| switchChannel_smEvent((TI_UINT8*)&pSwitchChannel->currentState, SC_EVENT_SC_CMD, pSwitchChannel); |
| } |
| |
| } |
| |
| } |
| |
| |
| /************************************************************************ |
| * switchChannel_powerSaveStatusReturn * |
| ************************************************************************/ |
| /** |
| * |
| * \b Description: |
| * |
| * This procedure is called when power save status is returned |
| * |
| * \b ARGS: |
| * |
| * I/O - hSwitchChannel - SwitchChannel context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| * |
| * \sa |
| */ |
| void switchChannel_SwitchChannelCmdCompleteReturn(TI_HANDLE hSwitchChannel) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t*)hSwitchChannel; |
| |
| if (pSwitchChannel == NULL) |
| { |
| return; |
| } |
| TRACE0(pSwitchChannel->hReport, REPORT_SEVERITY_INFORMATION, "switchChannel_SwitchChannelCmdCompleteReturn \n"); |
| |
| switchChannel_smEvent((TI_UINT8*)&pSwitchChannel->currentState, SC_EVENT_SC_CMPLT, pSwitchChannel); |
| |
| } |
| |
| /************************************************************************ |
| * switchChannel_enableDisableSpectrumMngmt * |
| ************************************************************************/ |
| /** |
| * |
| * \b Description: |
| * |
| * This procedure enables or disables the spectrum management |
| * |
| * \b ARGS: |
| * |
| * I - hSwitchChannel - SwitchChannel context \n |
| * I - enableDisable - TI_TRUE - Enable, TI_FALSE - Disable |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| * |
| * \sa |
| */ |
| void switchChannel_enableDisableSpectrumMngmt(TI_HANDLE hSwitchChannel, TI_BOOL enableDisable) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t*)hSwitchChannel; |
| |
| |
| if (hSwitchChannel == NULL) |
| { |
| return; |
| } |
| TRACE1(pSwitchChannel->hReport, REPORT_SEVERITY_INFORMATION, "switchChannel_enableDisableSpectrumMngmt, enableDisable=%d \n", enableDisable); |
| |
| pSwitchChannel->dot11SpectrumManagementRequired = enableDisable; |
| |
| if (enableDisable) |
| { /* Enable SC, if it was started invoke start event. |
| otherwise, wait for a start event */ |
| if (pSwitchChannel->switchChannelStarted) |
| { |
| switchChannel_smEvent((TI_UINT8*)&pSwitchChannel->currentState, SC_EVENT_START, pSwitchChannel); |
| } |
| } |
| else |
| { /* Disable SC */ |
| switchChannel_smEvent((TI_UINT8*)&pSwitchChannel->currentState, SC_EVENT_STOP, pSwitchChannel); |
| } |
| |
| } |
| |
| |
| |
| /************************************************************************ |
| * SwitchChannel internal functions * |
| ************************************************************************/ |
| |
| /************************************************************************ |
| * switchChannel_smEvent * |
| ************************************************************************/ |
| /** |
| * |
| * \b Description: |
| * |
| * SwitchChannel state machine transition function |
| * |
| * \b ARGS: |
| * |
| * I/O - currentState - current state in the state machine\n |
| * I - event - specific event for the state machine\n |
| * I - pData - Data for state machine action function\n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| * |
| * \sa |
| */ |
| static TI_STATUS switchChannel_smEvent(TI_UINT8 *currState, TI_UINT8 event, void* data) |
| { |
| TI_STATUS status; |
| TI_UINT8 nextState; |
| switchChannel_t *pSwitchChannel = (switchChannel_t*)data; |
| |
| |
| status = fsm_GetNextState(pSwitchChannel->pSwitchChannelSm, *currState, event, &nextState); |
| if (status != TI_OK) |
| { |
| TRACE0(pSwitchChannel->hReport, REPORT_SEVERITY_ERROR, "switchChannel_smEvent, fsm_GetNextState error\n"); |
| return(TI_NOK); |
| } |
| |
| TRACE3(pSwitchChannel->hReport, REPORT_SEVERITY_INFORMATION, "switchChannel_smEvent: <currentState = %d, event = %d> --> nextState = %d\n", *currState, event, nextState); |
| |
| status = fsm_Event(pSwitchChannel->pSwitchChannelSm, currState, event, (void *)pSwitchChannel); |
| |
| if (status != TI_OK) |
| { |
| TRACE0(pSwitchChannel->hReport, REPORT_SEVERITY_ERROR, "switchChannel_smEvent fsm_Event error\n"); |
| TRACE3(pSwitchChannel->hReport, REPORT_SEVERITY_ERROR, "switchChannel_smEvent: <currentState = %d, event = %d> --> nextState = %d\n", *currState, event, nextState); |
| } |
| return status; |
| |
| } |
| |
| |
| /************************************************************************ |
| * switchChannel_smStart * |
| ************************************************************************/ |
| /** |
| * |
| * |
| * \b Description: |
| * |
| * This function is called when the station becomes connected. |
| * update the current channel. |
| * |
| * \b ARGS: |
| * |
| * I - pData - pointer to the SwitchChannel SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| *************************************************************************/ |
| static TI_STATUS switchChannel_smStart(void *pData) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t*)pData; |
| paramInfo_t param; |
| |
| if (pSwitchChannel == NULL) |
| { |
| return TI_NOK; |
| } |
| |
| /* get the current channel number */ |
| param.paramType = SITE_MGR_CURRENT_CHANNEL_PARAM; |
| siteMgr_getParam(pSwitchChannel->hSiteMgr, ¶m); |
| pSwitchChannel->currentChannel = param.content.siteMgrCurrentChannel; |
| |
| TRACE1(pSwitchChannel->hReport, REPORT_SEVERITY_INFORMATION, "switchChannel_smStart, channelNo=%d\n", pSwitchChannel->currentChannel); |
| return TI_OK; |
| |
| } |
| |
| /************************************************************************ |
| * switchChannel_smReqSCR_UpdateCmd * |
| ************************************************************************/ |
| /** |
| * |
| * |
| * \b Description: |
| * |
| * Update the Switch Channel command parameters. |
| * Request SCR and wait for SCR return. |
| * if tx status suspend |
| * update regulatory Domain |
| * update tx |
| * start periodic timer |
| |
| * |
| * \b ARGS: |
| * |
| * I - pData - pointer to the SwitchChannel SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| *************************************************************************/ |
| static TI_STATUS switchChannel_smReqSCR_UpdateCmd(void *pData) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t*)pData; |
| EScrClientRequestStatus scrStatus; |
| EScePendReason scrPendReason; |
| |
| if (pSwitchChannel == NULL) |
| { |
| return TI_NOK; |
| } |
| TRACE3(pSwitchChannel->hReport, REPORT_SEVERITY_INFORMATION, "switchChannel_smReqSCR_UpdateCmd, channelNo=%d, TBTT = %d, Mode = %d\n", pSwitchChannel->curChannelSwitchCmdParams.channelNumber, pSwitchChannel->curChannelSwitchCmdParams.channelSwitchCount, pSwitchChannel->curChannelSwitchCmdParams.channelSwitchMode); |
| |
| |
| /* Save the TS when requesting SCR */ |
| pSwitchChannel->SCRRequestTimestamp = os_timeStampMs(pSwitchChannel->hOs); |
| |
| scrStatus = scr_clientRequest(pSwitchChannel->hSCR, SCR_CID_SWITCH_CHANNEL, |
| SCR_RESOURCE_SERVING_CHANNEL, &scrPendReason); |
| if ((scrStatus != SCR_CRS_RUN) && (scrStatus != SCR_CRS_PEND)) |
| { |
| TRACE1(pSwitchChannel->hReport, REPORT_SEVERITY_ERROR, "switchChannel_smReqSCR_UpdateCmd():Abort the switch channel, request Roaming, scrStatus=%d\n", scrStatus); |
| return (switchChannel_smEvent((TI_UINT8*)&pSwitchChannel->currentState, SC_EVENT_SCR_FAIL, pSwitchChannel)); |
| |
| } |
| if (scrStatus == SCR_CRS_RUN) |
| { |
| switchChannel_scrStatusCB(pSwitchChannel, scrStatus, SCR_RESOURCE_SERVING_CHANNEL, scrPendReason); |
| } |
| else if ((scrPendReason==SCR_PR_OTHER_CLIENT_RUNNING) || |
| (scrPendReason==SCR_PR_DIFFERENT_GROUP_RUNNING) ) |
| { /* No use to wait for the SCR, invoke FAIL */ |
| return (switchChannel_smEvent((TI_UINT8*)&pSwitchChannel->currentState, SC_EVENT_SCR_FAIL, pSwitchChannel)); |
| } |
| /* wait for the SCR callback function to be called */ |
| return TI_OK; |
| |
| } |
| |
| |
| /************************************************************************ |
| * switchChannel_scrStatusCB * |
| ************************************************************************/ |
| /** |
| * |
| * |
| * \b Description: |
| * |
| * This function is called by the SCR when: |
| * the resource is reserved for the SwitchChannel - SCR_CRS_RUN |
| * recovery occurred - SCR_CRS_ABORT |
| * other = ERROR |
| * |
| * \b ARGS: |
| * |
| * I - hSwitchChannel - pointer to the SwitchChannel SM context \n |
| * I - requestStatus - the SCR request status \n |
| * I - eResource - the resource for which the CB is issued \n |
| * I - pendReason - The SCR pend status in case of pend reply \n |
| * |
| * \b RETURNS: |
| * |
| * None. |
| * |
| * |
| *************************************************************************/ |
| void switchChannel_scrStatusCB(TI_HANDLE hSwitchChannel, EScrClientRequestStatus requestStatus, |
| EScrResourceId eResource, EScePendReason pendReason ) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t*)hSwitchChannel; |
| switchChannel_smEvents scEvent; |
| |
| if (pSwitchChannel == NULL) |
| { |
| return; |
| } |
| |
| switch (requestStatus) |
| { |
| case SCR_CRS_RUN: |
| scEvent = SC_EVENT_SCR_RUN; |
| break; |
| case SCR_CRS_FW_RESET: |
| scEvent = SC_EVENT_FW_RESET; |
| break; |
| case SCR_CRS_PEND: |
| scEvent = SC_EVENT_SCR_FAIL; |
| break; |
| case SCR_CRS_ABORT: |
| default: |
| TRACE2(pSwitchChannel->hReport, REPORT_SEVERITY_ERROR, "switchChannel_scrStatusCB scrStatus = %d, pendReason=%d\n", requestStatus, pendReason); |
| scEvent = SC_EVENT_SCR_FAIL; |
| break; |
| } |
| |
| switchChannel_smEvent((TI_UINT8*)&pSwitchChannel->currentState, scEvent, pSwitchChannel); |
| |
| } |
| |
| |
| |
| /************************************************************************ |
| * switchChannel_smStartSwitchChannelCmd * |
| ************************************************************************/ |
| /** |
| * |
| * |
| * \b Description: |
| * |
| * This function is called once SwitchChannel command was received and the SCR |
| * request returned with reason RUN. |
| * In this case perform the following: |
| * Set CMD to FW |
| |
| |
| * |
| * \b ARGS: |
| * |
| * I - pData - pointer to the SwitchChannel SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| *************************************************************************/ |
| static TI_STATUS switchChannel_smStartSwitchChannelCmd(void *pData) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t *)pData; |
| TSwitchChannelParams pSwitchChannelCmd; |
| TI_UINT32 switchChannelTimeDuration; |
| paramInfo_t param; |
| |
| if (pSwitchChannel == NULL) |
| { |
| return TI_NOK; |
| } |
| |
| param.paramType = SITE_MGR_BEACON_INTERVAL_PARAM; |
| siteMgr_getParam(pSwitchChannel->hSiteMgr, ¶m); |
| |
| switchChannelTimeDuration = pSwitchChannel->curChannelSwitchCmdParams.channelSwitchCount * param.content.beaconInterval * 1024 / 1000; |
| if ( (switchChannelTimeDuration!=0) && |
| ((os_timeStampMs(pSwitchChannel->hOs) - pSwitchChannel->SCRRequestTimestamp) >= switchChannelTimeDuration )) |
| { /* There's no time to perfrom the SCC, set the Count to 1 */ |
| pSwitchChannel->curChannelSwitchCmdParams.channelSwitchCount = 1; |
| } |
| |
| apConn_indicateSwitchChannelInProgress(pSwitchChannel->hApConn); |
| |
| pSwitchChannelCmd.channelNumber = pSwitchChannel->curChannelSwitchCmdParams.channelNumber; |
| pSwitchChannelCmd.switchTime = pSwitchChannel->curChannelSwitchCmdParams.channelSwitchCount; |
| pSwitchChannelCmd.txFlag = pSwitchChannel->curChannelSwitchCmdParams.channelSwitchMode; |
| pSwitchChannelCmd.flush = 0; |
| TWD_CmdSwitchChannel (pSwitchChannel->hTWD, &pSwitchChannelCmd); |
| |
| TRACE4(pSwitchChannel->hReport, REPORT_SEVERITY_INFORMATION, "TWD_CmdSwitchChannel:Set the cmd in HAL. Params:\n channelNumber=%d, switchTime=%d, txFlag=%d, flush=%d \n", pSwitchChannelCmd.channelNumber, pSwitchChannelCmd.switchTime, pSwitchChannelCmd.txFlag, pSwitchChannelCmd.flush); |
| |
| return TI_OK; |
| |
| } |
| |
| /************************************************************************ |
| * switchChannel_smFwResetWhileSCInProg * |
| ************************************************************************/ |
| /** |
| * |
| * |
| * \b Description: |
| * |
| * This function is called when Switch Channel command is cancelled. |
| * In this case update TX nad regulatory Domain adn HAL. |
| * Release the SCR and exit PS. |
| * |
| * \b ARGS: |
| * |
| * I - pData - pointer to the SwitchChannel SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| *************************************************************************/ |
| static TI_STATUS switchChannel_smFwResetWhileSCInProg(void *pData) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t *)pData; |
| paramInfo_t param; |
| |
| if (pSwitchChannel == NULL) |
| { |
| return TI_NOK; |
| } |
| TRACE0(pSwitchChannel->hReport, REPORT_SEVERITY_INFORMATION, "switchChannel_smFwResetWhileSCInProg \n"); |
| |
| /* Update new current channel */ |
| param.paramType = SITE_MGR_CURRENT_CHANNEL_PARAM; |
| param.content.siteMgrCurrentChannel = pSwitchChannel->curChannelSwitchCmdParams.channelNumber; |
| siteMgr_setParam(pSwitchChannel->hSiteMgr, ¶m); |
| |
| apConn_indicateSwitchChannelFinished(pSwitchChannel->hApConn); |
| |
| switchChannel_zeroDatabase(pSwitchChannel); |
| |
| /* release the SCR */ |
| scr_clientComplete(pSwitchChannel->hSCR, SCR_CID_SWITCH_CHANNEL, SCR_RESOURCE_SERVING_CHANNEL); |
| |
| return TI_OK; |
| |
| } |
| |
| |
| /************************************************************************ |
| * switchChannel_smSwitchChannelCmplt * |
| ************************************************************************/ |
| /** |
| * |
| * |
| * \b Description: |
| * |
| * This function is called when SwitchChannel command completed in FW. |
| * In this case release SCR and update current channel. |
| * If TX was sus, it will be enabled only after first Beacon is recieved. |
| * Exit PS. |
| * |
| * \b ARGS: |
| * |
| * I - pData - pointer to the SwitchChannel SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| *************************************************************************/ |
| static TI_STATUS switchChannel_smSwitchChannelCmplt(void *pData) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t *)pData; |
| paramInfo_t param; |
| |
| if (pSwitchChannel == NULL) |
| { |
| return TI_NOK; |
| } |
| |
| /* Update new current channel */ |
| param.paramType = SITE_MGR_CURRENT_CHANNEL_PARAM; |
| param.content.siteMgrCurrentChannel = pSwitchChannel->curChannelSwitchCmdParams.channelNumber; |
| siteMgr_setParam(pSwitchChannel->hSiteMgr, ¶m); |
| |
| TRACE1(pSwitchChannel->hReport, REPORT_SEVERITY_INFORMATION, "switchChannel_smSwitchChannelCmplt, new channelNum = %d\n", pSwitchChannel->currentChannel); |
| |
| apConn_indicateSwitchChannelFinished(pSwitchChannel->hApConn); |
| switchChannel_zeroDatabase(pSwitchChannel); |
| |
| /* release the SCR */ |
| scr_clientComplete(pSwitchChannel->hSCR, SCR_CID_SWITCH_CHANNEL, SCR_RESOURCE_SERVING_CHANNEL); |
| |
| return TI_OK; |
| |
| } |
| |
| |
| |
| /************************************************************************ |
| * switchChannel_smScrFailWhileWait4Scr * |
| ************************************************************************/ |
| /** |
| * |
| * |
| * \b Description: |
| * |
| * This function is called when recovery occurred, while waiting for SCR due |
| * to previous switch channel command. |
| * Exit PS |
| * Release SCR. |
| * |
| * \b ARGS: |
| * |
| * I - pData - pointer to the SwitchChannel SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| *************************************************************************/ |
| static TI_STATUS switchChannel_smScrFailWhileWait4Scr(void *pData) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t*)pData; |
| |
| if (pSwitchChannel == NULL) |
| { |
| return TI_NOK; |
| } |
| |
| TRACE0(pSwitchChannel->hReport, REPORT_SEVERITY_INFORMATION, "switchChannel_smScrFailWhileWait4Scr\n"); |
| |
| switchChannel_zeroDatabase(pSwitchChannel); |
| |
| /* release the SCR is not required !!! */ |
| scr_clientComplete(pSwitchChannel->hSCR, SCR_CID_SWITCH_CHANNEL, SCR_RESOURCE_SERVING_CHANNEL); |
| |
| return TI_OK; |
| } |
| |
| /************************************************************************ |
| * switchChannel_smStopWhileWait4Cmd * |
| ************************************************************************/ |
| /** |
| * |
| * |
| * \b Description: |
| * |
| * This function is called when the station becomes Disconnected and the current |
| * state is Wait4Cmd. In this case perfrom: |
| * Stop the timer |
| * Enable TX if it was disabled |
| * Zero the current command parameters |
| * Stop the timer |
| * |
| * \b ARGS: |
| * |
| * I - pData - pointer to the SwitchChannel SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| *************************************************************************/ |
| static TI_STATUS switchChannel_smStopWhileWait4Cmd(void *pData) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t*)pData; |
| |
| if (pSwitchChannel == NULL) |
| { |
| return TI_NOK; |
| } |
| |
| TRACE0(pSwitchChannel->hReport, REPORT_SEVERITY_INFORMATION, "switchChannel_smStopWhileWait4Cmd\n"); |
| |
| switchChannel_zeroDatabase(pSwitchChannel); |
| |
| return TI_OK; |
| } |
| |
| /************************************************************************ |
| * switchChannel_smStopWhileWait4Scr * |
| ************************************************************************/ |
| /** |
| * |
| * |
| * \b Description: |
| * |
| * This function is called when the station becomes Disconnected and the current |
| * state is Wait4Scr. In this case perfrom: |
| * Stop the timer |
| * Enable TX if it was disabled |
| * Zero the current command parameters |
| * Complete SCR |
| * |
| * \b ARGS: |
| * |
| * I - pData - pointer to the SwitchChannel SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| *************************************************************************/ |
| static TI_STATUS switchChannel_smStopWhileWait4Scr(void *pData) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t*)pData; |
| |
| if (pSwitchChannel == NULL) |
| { |
| return TI_NOK; |
| } |
| |
| TRACE0(pSwitchChannel->hReport, REPORT_SEVERITY_INFORMATION, "switchChannel_smStopWhileWait4Scr\n"); |
| |
| |
| switchChannel_zeroDatabase(pSwitchChannel); |
| |
| /* release the SCR */ |
| scr_clientComplete(pSwitchChannel->hSCR, SCR_CID_SWITCH_CHANNEL, SCR_RESOURCE_SERVING_CHANNEL); |
| |
| return TI_OK; |
| } |
| |
| /************************************************************************ |
| * switchChannel_smStopWhileSwitchChannelInProg * |
| ************************************************************************/ |
| /** |
| * |
| * |
| * \b Description: |
| * |
| * This function is called when the station becomes Disconnected and the current |
| * state is SwitchChannelInProg. In this case perfrom: |
| * Stop the timer |
| * Enable TX if it was disabled |
| * Zero the current command parameters |
| * resume self test |
| * Complete SCR |
| * Exit PS |
| * |
| * \b ARGS: |
| * |
| * I - pData - pointer to the SwitchChannel SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| *************************************************************************/ |
| static TI_STATUS switchChannel_smStopWhileSwitchChannelInProg(void *pData) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t*)pData; |
| |
| if (pSwitchChannel == NULL) |
| { |
| return TI_NOK; |
| } |
| |
| TRACE0(pSwitchChannel->hReport, REPORT_SEVERITY_INFORMATION, "switchChannel_smStopWhileSwitchChannelInProg\n"); |
| |
| /* Exit PS */ |
| /*PowerMgr_exitFromDriverMode(pSwitchChannel->hPowerMngr, "SwitchChannel");*/ |
| |
| apConn_indicateSwitchChannelFinished(pSwitchChannel->hApConn); |
| |
| TWD_CmdSwitchChannelCancel (pSwitchChannel->hTWD, pSwitchChannel->currentChannel); |
| switchChannel_zeroDatabase(pSwitchChannel); |
| |
| /* release the SCR */ |
| scr_clientComplete(pSwitchChannel->hSCR, SCR_CID_SWITCH_CHANNEL, SCR_RESOURCE_SERVING_CHANNEL); |
| |
| return TI_OK; |
| } |
| |
| |
| |
| |
| /************************************************************************ |
| * switchChannel_zeroDatabase * |
| ************************************************************************/ |
| /** |
| * |
| * |
| * \b Description: |
| * |
| * This function is called when the SwitchChannel internal database should be zero. |
| * The following parameters are zerod: |
| * SwitchChannelChannelRange - the timestamps and validity state of channels |
| * curChannelSwitchCmdParams - the current switch channel command parameters |
| * |
| * \b ARGS: |
| * |
| * I - pSwitchChannel - pointer to the SwitchChannel SM context \n |
| * I - channelNum - channel number \n |
| * I - timestamp - required timestamp \n |
| * |
| * \b RETURNS: |
| * |
| * None. |
| * |
| * |
| *************************************************************************/ |
| static void switchChannel_zeroDatabase(switchChannel_t *pSwitchChannel) |
| { |
| |
| TRACE0(pSwitchChannel->hReport, REPORT_SEVERITY_INFORMATION, "switchChannel_zeroDatabase\n"); |
| |
| |
| pSwitchChannel->curChannelSwitchCmdParams.channelNumber = 0; |
| pSwitchChannel->curChannelSwitchCmdParams.channelSwitchCount = 0; |
| pSwitchChannel->curChannelSwitchCmdParams.channelSwitchMode = SC_SWITCH_CHANNEL_MODE_NOT_TX_SUS; |
| pSwitchChannel->currentChannel = 0; |
| |
| } |
| |
| /*********************************************************************** |
| * release_module |
| ***********************************************************************/ |
| /* |
| DESCRIPTION: Called by the destroy function or by the create function (on failure) |
| Go over the vector, for each bit that is set, release the corresponding module. |
| |
| INPUT: pSwitchChannel - SwitchChannel pointer. |
| initVec - Vector that contains a bit set for each module thah had been initiualized |
| |
| OUTPUT: |
| |
| RETURN: TI_OK on success, TI_NOK otherwise |
| |
| ************************************************************************/ |
| static void release_module(switchChannel_t *pSwitchChannel, TI_UINT32 initVec) |
| { |
| if (pSwitchChannel == NULL) |
| { |
| return; |
| } |
| if (initVec & (1 << SC_SM_INIT_BIT)) |
| { |
| fsm_Unload(pSwitchChannel->hOs, pSwitchChannel->pSwitchChannelSm); |
| } |
| |
| if (initVec & (1 << SC_INIT_BIT)) |
| { |
| os_memoryFree(pSwitchChannel->hOs, pSwitchChannel, sizeof(switchChannel_t)); |
| } |
| |
| initVec = 0; |
| } |
| |
| |
| /** |
| * |
| * switchChannel_smNop - Do nothing |
| * |
| * \b Description: |
| * |
| * Do nothing in the SM. |
| * |
| * \b ARGS: |
| * |
| * I - pData - pointer to the SwitchChannel SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| */ |
| static TI_STATUS switchChannel_smNop(void *pData) |
| { |
| switchChannel_t *pSwitchChannel; |
| |
| pSwitchChannel = (switchChannel_t*)pData; |
| if (pSwitchChannel == NULL) |
| { |
| return TI_NOK; |
| } |
| TRACE0(pSwitchChannel->hReport, REPORT_SEVERITY_INFORMATION, " switchChannel_smNop\n"); |
| |
| return TI_OK; |
| } |
| |
| /** |
| * |
| * switchChannel_smUnexpected - Unexpected event |
| * |
| * \b Description: |
| * |
| * Unexpected event in the SM. |
| * |
| * \b ARGS: |
| * |
| * I - pData - pointer to the SwitchChannel SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| */ |
| static TI_STATUS switchChannel_smUnexpected(void *pData) |
| { |
| switchChannel_t *pSwitchChannel; |
| |
| pSwitchChannel = (switchChannel_t*)pData; |
| if (pSwitchChannel == NULL) |
| { |
| return TI_NOK; |
| } |
| TRACE1(pSwitchChannel->hReport, REPORT_SEVERITY_ERROR, " switchChannel_smUnexpected, state = %d\n", pSwitchChannel->currentState); |
| |
| return TI_NOK; |
| } |
| |
| /******************************************************************************* |
| *********** Debug functions *********** |
| *******************************************************************************/ |
| #ifdef TI_DBG |
| |
| /************************************************************************ |
| * switchChannel_recvCmd * |
| ************************************************************************/ |
| /*DESCRIPTION: This function is called by MLME Parser upon receiving of |
| Beacon, Probe Response or Action with Switch Channel command, |
| or beacon/ |
| performs the following: |
| - Initializes the switching channel procedure. |
| - Setting timer to the actual switching time(if needed) |
| |
| INPUT: hSwitchChannel - SwitchChannel handle. |
| switchMode - indicates whether to stop transmission |
| until the scheduled channel switch. |
| newChannelNum - indicates the number of the new channel. |
| durationTime - indicates the time (expressed in ms) until |
| the scheduled channel switch should accure. |
| |
| OUTPUT: None |
| |
| RETURN: TI_OK on success, TI_NOK otherwise |
| |
| ************************************************************************/ |
| |
| static void switchChannel_recvCmd4Debug(TI_HANDLE hSwitchChannel, dot11_CHANNEL_SWITCH_t *channelSwitch, TI_BOOL BeaconPacket, TI_UINT8 channel) |
| { |
| |
| switchChannel_t *pSwitchChannel = (switchChannel_t *)hSwitchChannel; |
| paramInfo_t param; |
| |
| if (pSwitchChannel==NULL) |
| { |
| return; |
| } |
| |
| |
| /* The following is for debug purposes only |
| It will be operated when the Switch Channel cmd is opertated from debug CLI */ |
| if (pSwitchChannel->ignoreCancelSwitchChannelCmd != 0) |
| { |
| if (pSwitchChannel->ignoreCancelSwitchChannelCmd == 1) |
| { |
| /* update the new SCC params */ |
| pSwitchChannel->curChannelSwitchCmdParams.channelNumber = channelSwitch->channelNumber; |
| pSwitchChannel->curChannelSwitchCmdParams.channelSwitchCount = channelSwitch->channelSwitchCount; |
| pSwitchChannel->curChannelSwitchCmdParams.channelSwitchMode = channelSwitch->channelSwitchMode; |
| |
| pSwitchChannel->ignoreCancelSwitchChannelCmd = 2; |
| } |
| else if (channelSwitch->channelSwitchCount>0) |
| { |
| channelSwitch->channelSwitchCount --; |
| } |
| else |
| { |
| pSwitchChannel->ignoreCancelSwitchChannelCmd = 0; |
| } |
| |
| |
| /* search in the buffer pointer to the beginning of the |
| Switch Cahnnel Announcement IE according to the IE ID */ |
| |
| /* SC IE exists on the serving channel */ |
| TRACE3(pSwitchChannel->hReport, REPORT_SEVERITY_INFORMATION, "switchChannel_recvFrame, SwitchChannel cmd was found, channel no=%d, mode=%d, TBTT=%d \n", channelSwitch->channelNumber, channelSwitch->channelSwitchMode, channelSwitch->channelSwitchCount); |
| |
| /* Checking channel number validity */ |
| param.content.channel = channelSwitch->channelNumber; |
| param.paramType = REGULATORY_DOMAIN_IS_CHANNEL_SUPPORTED; |
| regulatoryDomain_getParam(pSwitchChannel->hRegulatoryDomain,¶m); |
| if (( !param.content.bIsChannelSupprted ) || |
| (channelSwitch->channelSwitchCount == 0) || |
| (channelSwitch->channelSwitchMode == SC_SWITCH_CHANNEL_MODE_TX_SUS)) |
| { /* Trigger Roaming, if TX mode is disabled, the new channel number is invalid, |
| or the TBTT count is 0 */ |
| apConn_reportRoamingEvent(pSwitchChannel->hApConn, ROAMING_TRIGGER_SWITCH_CHANNEL, NULL); |
| } |
| else |
| { /* Invoke Switch Channel command */ |
| /* update the new SCC params */ |
| pSwitchChannel->curChannelSwitchCmdParams.channelNumber = channelSwitch->channelNumber; |
| pSwitchChannel->curChannelSwitchCmdParams.channelSwitchCount = channelSwitch->channelSwitchCount; |
| pSwitchChannel->curChannelSwitchCmdParams.channelSwitchMode = channelSwitch->channelSwitchMode; |
| switchChannel_smEvent((TI_UINT8*)&pSwitchChannel->currentState, SC_EVENT_SC_CMD, pSwitchChannel); |
| } |
| } |
| |
| } |
| |
| void switchChannelDebug_setCmdParams(TI_HANDLE hSwitchChannel, SC_switchChannelCmdParam_e switchChannelCmdParam, TI_UINT8 param) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t*)hSwitchChannel; |
| |
| if (pSwitchChannel == NULL) |
| { |
| return; |
| } |
| |
| switch (switchChannelCmdParam) |
| { |
| case SC_SWITCH_CHANNEL_NUM: |
| WLAN_OS_REPORT(("SwitchChannelDebug_setSwitchChannelCmdParams, channelNum=%d \n ", param)); |
| pSwitchChannel->debugChannelSwitchCmdParams.channelNumber = param; |
| break; |
| case SC_SWITCH_CHANNEL_TBTT: |
| WLAN_OS_REPORT(("SwitchChannelDebug_setSwitchChannelCmdParams, channelSwitchCount=%d \n ", param)); |
| pSwitchChannel->debugChannelSwitchCmdParams.channelSwitchCount = param; |
| break; |
| case SC_SWITCH_CHANNEL_MODE: |
| WLAN_OS_REPORT(("SwitchChannelDebug_setSwitchChannelCmdParams, channelSwitchMode=%d \n ", param)); |
| pSwitchChannel->debugChannelSwitchCmdParams.channelSwitchMode = param; |
| break; |
| default: |
| WLAN_OS_REPORT(("ERROR: SwitchChannelDebug_setSwitchChannelCmdParams, wrong switchChannelCmdParam=%d \n ", |
| switchChannelCmdParam)); |
| break; |
| } |
| |
| } |
| void switchChannelDebug_SwitchChannelCmdTest(TI_HANDLE hSwitchChannel, TI_BOOL BeaconPacket) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t*)hSwitchChannel; |
| |
| if (pSwitchChannel == NULL) |
| { |
| return; |
| } |
| |
| WLAN_OS_REPORT(("SwitchChannelDebug_SwitchChannelCmdTest, BeaconPacket=%d \n cmd params: channelNumber=%d, channelSwitchCount=%d, channelSwitchMode=%d \n", |
| BeaconPacket, |
| pSwitchChannel->debugChannelSwitchCmdParams.channelNumber, |
| pSwitchChannel->debugChannelSwitchCmdParams.channelSwitchCount, |
| pSwitchChannel->debugChannelSwitchCmdParams.channelSwitchMode)); |
| |
| |
| pSwitchChannel->ignoreCancelSwitchChannelCmd= 1; |
| switchChannel_recvCmd4Debug(hSwitchChannel, &pSwitchChannel->debugChannelSwitchCmdParams, BeaconPacket, pSwitchChannel->currentChannel); |
| } |
| |
| void switchChannelDebug_CancelSwitchChannelCmdTest(TI_HANDLE hSwitchChannel, TI_BOOL BeaconPacket) |
| { |
| |
| switchChannel_t *pSwitchChannel = (switchChannel_t*)hSwitchChannel; |
| |
| if (pSwitchChannel == NULL) |
| { |
| return; |
| } |
| |
| WLAN_OS_REPORT(("SwitchChannelDebug_SwitchChannelCmdTest, BeaconPacket=%d \n",BeaconPacket)); |
| |
| pSwitchChannel->ignoreCancelSwitchChannelCmd= 0; |
| switchChannel_recvCmd4Debug(hSwitchChannel, NULL, BeaconPacket, pSwitchChannel->currentChannel); |
| } |
| |
| |
| void switchChannelDebug_printStatus(TI_HANDLE hSwitchChannel) |
| { |
| switchChannel_t *pSwitchChannel = (switchChannel_t*)hSwitchChannel; |
| |
| if (pSwitchChannel == NULL) |
| { |
| return; |
| } |
| |
| WLAN_OS_REPORT(("SwitchChannel debug params are: channelNumber=%d, channelSwitchCount=%d , channelSwitchMode=%d \n", |
| pSwitchChannel->debugChannelSwitchCmdParams.channelNumber, |
| pSwitchChannel->debugChannelSwitchCmdParams.channelSwitchCount, |
| pSwitchChannel->debugChannelSwitchCmdParams.channelSwitchMode)); |
| |
| WLAN_OS_REPORT(("SwitchChannel state=%d, currentChannel=%d \n", pSwitchChannel->currentState, pSwitchChannel->currentChannel)); |
| |
| |
| } |
| |
| void switchChannelDebug_setChannelValidity(TI_HANDLE hSwitchChannel, TI_UINT8 channelNum, TI_BOOL validity) |
| { |
| paramInfo_t param; |
| |
| switchChannel_t *pSwitchChannel = (switchChannel_t*)hSwitchChannel; |
| |
| if (pSwitchChannel == NULL) |
| { |
| return; |
| } |
| |
| param.paramType = REGULATORY_DOMAIN_SET_CHANNEL_VALIDITY; |
| param.content.channelValidity.channelNum = channelNum; |
| param.content.channelValidity.channelValidity = validity; |
| regulatoryDomain_setParam(pSwitchChannel->hRegulatoryDomain, ¶m); |
| |
| } |
| |
| #endif /* TI_DBG */ |
| |
| |
| |
| |
| |
| |
