diff options
Diffstat (limited to 'wilink_6_1/stad/src/AirLink_Managment/SwitchChannel.c')
| -rw-r--r-- | wilink_6_1/stad/src/AirLink_Managment/SwitchChannel.c | 1535 |
1 files changed, 1535 insertions, 0 deletions
diff --git a/wilink_6_1/stad/src/AirLink_Managment/SwitchChannel.c b/wilink_6_1/stad/src/AirLink_Managment/SwitchChannel.c new file mode 100644 index 0000000..0e5739a --- /dev/null +++ b/wilink_6_1/stad/src/AirLink_Managment/SwitchChannel.c @@ -0,0 +1,1535 @@ +/* + * SwitchChannel.c + * + * Copyright(c) 1998 - 2009 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); + } + 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 */ + + + + + + |