VOID SyncStateMachineInit(
IN PRTMP_ADAPTER pAd,
IN STATE_MACHINE *Sm,
OUT STATE_MACHINE_FUNC Trans[])
{
StateMachineInit(Sm, Trans, MAX_SYNC_STATE, MAX_SYNC_MSG, (STATE_MACHINE_FUNC)Drop, SYNC_IDLE, SYNC_MACHINE_BASE);
StateMachineSetAction(Sm, SYNC_IDLE, MT2_MLME_SCAN_REQ, (STATE_MACHINE_FUNC)MlmeScanReqAction);
StateMachineSetAction(Sm, SYNC_IDLE, MT2_MLME_JOIN_REQ, (STATE_MACHINE_FUNC)MlmeJoinReqAction);
StateMachineSetAction(Sm, SYNC_IDLE, MT2_MLME_START_REQ, (STATE_MACHINE_FUNC)MlmeStartReqAction);
StateMachineSetAction(Sm, SYNC_IDLE, MT2_PEER_BEACON, (STATE_MACHINE_FUNC)PeerBeacon);
StateMachineSetAction(Sm, SYNC_IDLE, MT2_PEER_PROBE_REQ, (STATE_MACHINE_FUNC)PeerProbeReqAction);
StateMachineSetAction(Sm, JOIN_WAIT_BEACON, MT2_MLME_SCAN_REQ, (STATE_MACHINE_FUNC)InvalidStateWhenScan);
StateMachineSetAction(Sm, JOIN_WAIT_BEACON, MT2_MLME_JOIN_REQ, (STATE_MACHINE_FUNC)InvalidStateWhenJoin);
StateMachineSetAction(Sm, JOIN_WAIT_BEACON, MT2_MLME_START_REQ, (STATE_MACHINE_FUNC)InvalidStateWhenStart);
StateMachineSetAction(Sm, JOIN_WAIT_BEACON, MT2_PEER_BEACON, (STATE_MACHINE_FUNC)PeerBeaconAtJoinAction);
StateMachineSetAction(Sm, JOIN_WAIT_BEACON, MT2_BEACON_TIMEOUT, (STATE_MACHINE_FUNC)BeaconTimeoutAtJoinAction);
StateMachineSetAction(Sm, SCAN_LISTEN, MT2_MLME_SCAN_REQ, (STATE_MACHINE_FUNC)InvalidStateWhenScan);
StateMachineSetAction(Sm, SCAN_LISTEN, MT2_MLME_JOIN_REQ, (STATE_MACHINE_FUNC)InvalidStateWhenJoin);
StateMachineSetAction(Sm, SCAN_LISTEN, MT2_MLME_START_REQ, (STATE_MACHINE_FUNC)InvalidStateWhenStart);
StateMachineSetAction(Sm, SCAN_LISTEN, MT2_PEER_BEACON, (STATE_MACHINE_FUNC)PeerBeaconAtScanAction);
StateMachineSetAction(Sm, SCAN_LISTEN, MT2_PEER_PROBE_RSP, (STATE_MACHINE_FUNC)PeerBeaconAtScanAction);
StateMachineSetAction(Sm, SCAN_LISTEN, MT2_SCAN_TIMEOUT, (STATE_MACHINE_FUNC)ScanTimeoutAction);
RTMPInitTimer(pAd, &pAd->MlmeAux.BeaconTimer, GET_TIMER_FUNCTION(BeaconTimeout), pAd, FALSE);
RTMPInitTimer(pAd, &pAd->MlmeAux.ScanTimer, GET_TIMER_FUNCTION(ScanTimeout), pAd, FALSE);
}
VOID ApCliAuthStateMachineInit(
IN PRTMP_ADAPTER pAd,
IN STATE_MACHINE *Sm,
OUT STATE_MACHINE_FUNC Trans[])
{
UCHAR i;
#ifdef MAC_REPEATER_SUPPORT
UCHAR j;
PREPEATER_CLIENT_ENTRY pReptCliEntry = NULL;
#endif /* MAC_REPEATER_SUPPORT */
StateMachineInit(Sm, (STATE_MACHINE_FUNC*)Trans,
APCLI_MAX_AUTH_STATE, APCLI_MAX_AUTH_MSG,
(STATE_MACHINE_FUNC)Drop, APCLI_AUTH_REQ_IDLE,
APCLI_AUTH_MACHINE_BASE);
/* the first column */
StateMachineSetAction(Sm, APCLI_AUTH_REQ_IDLE, APCLI_MT2_MLME_AUTH_REQ, (STATE_MACHINE_FUNC)ApCliMlmeAuthReqAction);
StateMachineSetAction(Sm, APCLI_AUTH_REQ_IDLE, APCLI_MT2_PEER_DEAUTH, (STATE_MACHINE_FUNC)ApCliPeerDeauthAction);
StateMachineSetAction(Sm, APCLI_AUTH_REQ_IDLE, APCLI_MT2_MLME_DEAUTH_REQ, (STATE_MACHINE_FUNC)ApCliMlmeDeauthReqAction);
/* the second column */
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ2, APCLI_MT2_MLME_AUTH_REQ, (STATE_MACHINE_FUNC)ApCliInvalidStateWhenAuth);
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ2, APCLI_MT2_PEER_AUTH_EVEN, (STATE_MACHINE_FUNC)ApCliPeerAuthRspAtSeq2Action);
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ2, APCLI_MT2_PEER_DEAUTH, (STATE_MACHINE_FUNC)ApCliPeerDeauthAction);
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ2, APCLI_MT2_AUTH_TIMEOUT, (STATE_MACHINE_FUNC)ApCliAuthTimeoutAction);
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ2, APCLI_MT2_MLME_DEAUTH_REQ, (STATE_MACHINE_FUNC)ApCliMlmeDeauthReqAction);
/* the third column */
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ4, APCLI_MT2_MLME_AUTH_REQ, (STATE_MACHINE_FUNC)ApCliInvalidStateWhenAuth);
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ4, APCLI_MT2_PEER_AUTH_EVEN, (STATE_MACHINE_FUNC)ApCliPeerAuthRspAtSeq4Action);
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ4, APCLI_MT2_PEER_DEAUTH, (STATE_MACHINE_FUNC)ApCliPeerDeauthAction);
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ4, APCLI_MT2_AUTH_TIMEOUT, (STATE_MACHINE_FUNC)ApCliAuthTimeoutAction);
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ4, APCLI_MT2_MLME_DEAUTH_REQ, (STATE_MACHINE_FUNC)ApCliMlmeDeauthReqAction);
for (i=0; i < MAX_APCLI_NUM; i++)
{
pAd->ApCfg.ApCliTab[i].AuthCurrState = APCLI_AUTH_REQ_IDLE;
/* timer init */
RTMPInitTimer(pAd, &pAd->ApCfg.ApCliTab[i].ApCliMlmeAux.ApCliAuthTimer, GET_TIMER_FUNCTION(ApCliAuthTimeout), pAd, FALSE);
#ifdef MAC_REPEATER_SUPPORT
for (j = 0; j < MAX_EXT_MAC_ADDR_SIZE; j++)
{
pReptCliEntry = &pAd->ApCfg.ApCliTab[i].RepeaterCli[j];
pReptCliEntry->pAd = pAd;
pReptCliEntry->MatchApCliIdx = i;
pReptCliEntry->MatchLinkIdx = j;
pReptCliEntry->AuthCurrState = APCLI_AUTH_REQ_IDLE;
/* timer init */
RTMPInitTimer(pAd, &pReptCliEntry->ApCliAuthTimer, GET_TIMER_FUNCTION(ApCliAuthTimeoutExt), pReptCliEntry, FALSE);
}
#endif /* MAC_REPEATER_SUPPORT */
}
return;
}
/*
==========================================================================
Description:
association state machine init, including state transition and timer init
Parameters:
S - pointer to the association state machine
Note:
The state machine looks like the following
==========================================================================
*/
VOID ApCliAssocStateMachineInit(
IN PRTMP_ADAPTER pAd,
IN STATE_MACHINE *S,
OUT STATE_MACHINE_FUNC Trans[])
{
UCHAR i;
#ifdef MAC_REPEATER_SUPPORT
UCHAR j;
PREPEATER_CLIENT_ENTRY pReptCliEntry = NULL;
#endif /* MAC_REPEATER_SUPPORT */
StateMachineInit(S, (STATE_MACHINE_FUNC*)Trans,
APCLI_MAX_ASSOC_STATE, APCLI_MAX_ASSOC_MSG,
(STATE_MACHINE_FUNC)Drop, APCLI_ASSOC_IDLE,
APCLI_ASSOC_MACHINE_BASE);
/* first column */
StateMachineSetAction(S, APCLI_ASSOC_IDLE, APCLI_MT2_MLME_ASSOC_REQ, (STATE_MACHINE_FUNC)ApCliMlmeAssocReqAction);
StateMachineSetAction(S, APCLI_ASSOC_IDLE, APCLI_MT2_MLME_DISASSOC_REQ, (STATE_MACHINE_FUNC)ApCliMlmeDisassocReqAction);
StateMachineSetAction(S, APCLI_ASSOC_IDLE, APCLI_MT2_PEER_DISASSOC_REQ, (STATE_MACHINE_FUNC)ApCliPeerDisassocAction);
/* second column */
StateMachineSetAction(S, APCLI_ASSOC_WAIT_RSP, APCLI_MT2_MLME_ASSOC_REQ, (STATE_MACHINE_FUNC)ApCliInvalidStateWhenAssoc);
StateMachineSetAction(S, APCLI_ASSOC_WAIT_RSP, APCLI_MT2_MLME_DISASSOC_REQ, (STATE_MACHINE_FUNC)ApCliInvalidStateWhenDisassociate);
StateMachineSetAction(S, APCLI_ASSOC_WAIT_RSP, APCLI_MT2_PEER_DISASSOC_REQ, (STATE_MACHINE_FUNC)ApCliPeerDisassocAction);
StateMachineSetAction(S, APCLI_ASSOC_WAIT_RSP, APCLI_MT2_PEER_ASSOC_RSP, (STATE_MACHINE_FUNC)ApCliPeerAssocRspAction);
StateMachineSetAction(S, APCLI_ASSOC_WAIT_RSP, APCLI_MT2_ASSOC_TIMEOUT, (STATE_MACHINE_FUNC)ApCliAssocTimeoutAction);
for (i=0; i < MAX_APCLI_NUM; i++)
{
pAd->ApCfg.ApCliTab[i].AssocCurrState = APCLI_ASSOC_IDLE;
/* timer init */
RTMPInitTimer(pAd, &pAd->ApCfg.ApCliTab[i].ApCliMlmeAux.ApCliAssocTimer,
GET_TIMER_FUNCTION(ApCliAssocTimeout), pAd, FALSE);
RTMPInitTimer(pAd, &pAd->ApCfg.ApCliTab[i].ApCliMlmeAux.WpaDisassocAndBlockAssocTimer,
GET_TIMER_FUNCTION(ApCliWpaDisassocApAndBlockAssoc), pAd, FALSE);
#ifdef MAC_REPEATER_SUPPORT
for (j = 0; j < MAX_EXT_MAC_ADDR_SIZE; j++)
{
pReptCliEntry = &pAd->ApCfg.ApCliTab[i].RepeaterCli[j];
pReptCliEntry->pAd = pAd;
pReptCliEntry->MatchApCliIdx = i;
pReptCliEntry->MatchLinkIdx = j;
pReptCliEntry->AssocCurrState = APCLI_ASSOC_IDLE;
/* timer init */
RTMPInitTimer(pAd, &pReptCliEntry->ApCliAssocTimer, GET_TIMER_FUNCTION(ApCliAssocTimeoutExt), pReptCliEntry, FALSE);
}
#endif /* MAC_REPEATER_SUPPORT */
}
return;
}
VOID BBUPollingModeInit(IN RTMP_ADAPTER *pAd){
NdisAllocateSpinLock(&pAd->Pollingmode.PollingModeLock);//for polling mode
RTMPInitTimer(pAd, &pAd->Pollingmode.PollingModeDetect, GET_TIMER_FUNCTION(PeriodicPollingModeDetect), pAd, FALSE);
pAd->Pollingmode.PollingModeDetectRunning = FALSE;
}
/*
==========================================================================
Description:
ft state machine init, including state transition and timer init
Parameters:
Sm - pointer to the dls state machine
Note:
The state machine looks like this
FT_IDLE
MT2_MLME_FT_REQUEST MlmeDlsReqAction
MT2_PEER_DLS_REQUEST PeerDlsReqAction
MT2_PEER_DLS_RESPONSE PeerDlsRspAction
MT2_MLME_DLS_TEARDOWN MlmeTearDownAction
MT2_PEER_DLS_TEARDOWN PeerTearDownAction
IRQL = PASSIVE_LEVEL
==========================================================================
*/
void FT_OTD_StateMachineInit(
IN PRTMP_ADAPTER pAd,
IN STATE_MACHINE *Sm,
OUT STATE_MACHINE_FUNC Trans[])
{
StateMachineInit(Sm, Trans, FT_OTD_MAX_STATE, FT_OTD_MAX_MSG,
(STATE_MACHINE_FUNC) Drop, FT_OTD_IDLE,
FT_OTD_MACHINE_BASE);
/* the first column */
StateMachineSetAction(Sm, FT_OTD_IDLE, FT_OTD_MT2_MLME_REQ,
(STATE_MACHINE_FUNC) FT_OTD_ReqAction);
StateMachineSetAction(Sm, FT_OTD_WAIT_SEQ2, FT_OTD_MT2_MLME_REQ,
(STATE_MACHINE_FUNC) FT_OTD_InvalidStateWhenFt);
StateMachineSetAction(Sm, FT_OTD_WAIT_SEQ2, FT_OTD_MT2_PEER_EVEN,
(STATE_MACHINE_FUNC) FT_OTD_PeerRspAtSeq2Action);
StateMachineSetAction(Sm, FT_OTD_WAIT_SEQ2, FT_OTD_MT2_TIMEOUT,
(STATE_MACHINE_FUNC) FT_OTD_TimeoutAction);
StateMachineSetAction(Sm, FT_OTD_WAIT_SEQ4, FT_OTD_MT2_MLME_REQ,
(STATE_MACHINE_FUNC) FT_OTD_InvalidStateWhenFt);
StateMachineSetAction(Sm, FT_OTD_WAIT_SEQ4, FT_OTD_MT2_PEER_EVEN,
(STATE_MACHINE_FUNC) FT_OTD_PeerAckAtSeq4Action);
StateMachineSetAction(Sm, FT_OTD_WAIT_SEQ4, FT_OTD_MT2_TIMEOUT,
(STATE_MACHINE_FUNC) FT_OTD_TimeoutAction);
RTMPInitTimer(pAd, &pAd->MlmeAux.FtOtdActTimer,
GET_TIMER_FUNCTION(FT_OTD_TimeoutAction), pAd, FALSE);
}
/*
==========================================================================
Description:
The sync state machine,
Parameters:
Sm - pointer to the state machine
Note:
the state machine looks like the following
==========================================================================
*/
VOID ApCliSyncStateMachineInit(
IN PRTMP_ADAPTER pAd,
IN STATE_MACHINE *Sm,
OUT STATE_MACHINE_FUNC Trans[])
{
UCHAR i;
StateMachineInit(Sm, (STATE_MACHINE_FUNC*)Trans,
APCLI_MAX_SYNC_STATE, APCLI_MAX_SYNC_MSG,
(STATE_MACHINE_FUNC)Drop, APCLI_SYNC_IDLE,
APCLI_SYNC_MACHINE_BASE);
/* column 1 */
StateMachineSetAction(Sm, APCLI_SYNC_IDLE, APCLI_MT2_MLME_PROBE_REQ, (STATE_MACHINE_FUNC)ApCliMlmeProbeReqAction);
/*column 2 */
StateMachineSetAction(Sm, APCLI_JOIN_WAIT_PROBE_RSP, APCLI_MT2_MLME_PROBE_REQ, (STATE_MACHINE_FUNC)ApCliInvalidStateWhenJoin);
StateMachineSetAction(Sm, APCLI_JOIN_WAIT_PROBE_RSP, APCLI_MT2_PEER_PROBE_RSP, (STATE_MACHINE_FUNC)ApCliPeerProbeRspAtJoinAction);
StateMachineSetAction(Sm, APCLI_JOIN_WAIT_PROBE_RSP, APCLI_MT2_PROBE_TIMEOUT, (STATE_MACHINE_FUNC)ApCliProbeTimeoutAtJoinAction);
for (i = 0; i < MAX_APCLI_NUM; i++)
{
/* timer init */
RTMPInitTimer(pAd, &pAd->ApCfg.ApCliTab[i].ApCliMlmeAux.ProbeTimer, GET_TIMER_FUNCTION(ApCliProbeTimeout), pAd, FALSE);
pAd->ApCfg.ApCliTab[i].SyncCurrState = APCLI_SYNC_IDLE;
}
return;
}
/*
==========================================================================
Description:
association state machine init, including state transition and timer init
Parameters:
S - pointer to the association state machine
Note:
The state machine looks like the following
==========================================================================
*/
VOID ApCliAssocStateMachineInit(
IN PRTMP_ADAPTER pAd,
IN STATE_MACHINE *S,
OUT STATE_MACHINE_FUNC Trans[])
{
UCHAR i;
StateMachineInit(S, (STATE_MACHINE_FUNC*)Trans,
APCLI_MAX_ASSOC_STATE, APCLI_MAX_ASSOC_MSG,
(STATE_MACHINE_FUNC)Drop, APCLI_ASSOC_IDLE,
APCLI_ASSOC_MACHINE_BASE);
/* first column */
StateMachineSetAction(S, APCLI_ASSOC_IDLE, APCLI_MT2_MLME_ASSOC_REQ, (STATE_MACHINE_FUNC)ApCliMlmeAssocReqAction);
StateMachineSetAction(S, APCLI_ASSOC_IDLE, APCLI_MT2_MLME_DISASSOC_REQ, (STATE_MACHINE_FUNC)ApCliMlmeDisassocReqAction);
StateMachineSetAction(S, APCLI_ASSOC_IDLE, APCLI_MT2_PEER_DISASSOC_REQ, (STATE_MACHINE_FUNC)ApCliPeerDisassocAction);
/* second column */
StateMachineSetAction(S, APCLI_ASSOC_WAIT_RSP, APCLI_MT2_MLME_ASSOC_REQ, (STATE_MACHINE_FUNC)ApCliInvalidStateWhenAssoc);
StateMachineSetAction(S, APCLI_ASSOC_WAIT_RSP, APCLI_MT2_MLME_DISASSOC_REQ, (STATE_MACHINE_FUNC)ApCliInvalidStateWhenDisassociate);
StateMachineSetAction(S, APCLI_ASSOC_WAIT_RSP, APCLI_MT2_PEER_DISASSOC_REQ, (STATE_MACHINE_FUNC)ApCliPeerDisassocAction);
StateMachineSetAction(S, APCLI_ASSOC_WAIT_RSP, APCLI_MT2_PEER_ASSOC_RSP, (STATE_MACHINE_FUNC)ApCliPeerAssocRspAction);
StateMachineSetAction(S, APCLI_ASSOC_WAIT_RSP, APCLI_MT2_ASSOC_TIMEOUT, (STATE_MACHINE_FUNC)ApCliAssocTimeoutAction);
/* timer init */
RTMPInitTimer(pAd, &pAd->ApCliMlmeAux.ApCliAssocTimer, GET_TIMER_FUNCTION(ApCliAssocTimeout), pAd, FALSE);
for (i=0; i < MAX_APCLI_NUM; i++)
pAd->ApCfg.ApCliTab[i].AssocCurrState = APCLI_ASSOC_IDLE;
return;
}
void AuthStateMachineInit(
IN PRTMP_ADAPTER pAd,
IN STATE_MACHINE *Sm,
OUT STATE_MACHINE_FUNC Trans[])
{
StateMachineInit(Sm, Trans, MAX_AUTH_STATE, MAX_AUTH_MSG,
(STATE_MACHINE_FUNC) Drop, AUTH_REQ_IDLE,
AUTH_MACHINE_BASE);
/* the first column */
StateMachineSetAction(Sm, AUTH_REQ_IDLE, MT2_MLME_AUTH_REQ,
(STATE_MACHINE_FUNC) MlmeAuthReqAction);
/* the second column */
StateMachineSetAction(Sm, AUTH_WAIT_SEQ2, MT2_MLME_AUTH_REQ,
(STATE_MACHINE_FUNC) InvalidStateWhenAuth);
StateMachineSetAction(Sm, AUTH_WAIT_SEQ2, MT2_PEER_AUTH_EVEN,
(STATE_MACHINE_FUNC) PeerAuthRspAtSeq2Action);
StateMachineSetAction(Sm, AUTH_WAIT_SEQ2, MT2_AUTH_TIMEOUT,
(STATE_MACHINE_FUNC) AuthTimeoutAction);
/* the third column */
StateMachineSetAction(Sm, AUTH_WAIT_SEQ4, MT2_MLME_AUTH_REQ,
(STATE_MACHINE_FUNC) InvalidStateWhenAuth);
StateMachineSetAction(Sm, AUTH_WAIT_SEQ4, MT2_PEER_AUTH_EVEN,
(STATE_MACHINE_FUNC) PeerAuthRspAtSeq4Action);
StateMachineSetAction(Sm, AUTH_WAIT_SEQ4, MT2_AUTH_TIMEOUT,
(STATE_MACHINE_FUNC) AuthTimeoutAction);
RTMPInitTimer(pAd, &pAd->MlmeAux.AuthTimer,
GET_TIMER_FUNCTION(AuthTimeout), pAd, FALSE);
}
/*
==========================================================================
Description:
The sync state machine,
Parameters:
Sm - pointer to the state machine
Note:
the state machine looks like the following
AP_SYNC_IDLE
APMT2_PEER_PROBE_REQ peer_probe_req_action
==========================================================================
*/
VOID APSyncStateMachineInit(
IN PRTMP_ADAPTER pAd,
IN STATE_MACHINE *Sm,
OUT STATE_MACHINE_FUNC Trans[])
{
StateMachineInit(Sm, (STATE_MACHINE_FUNC *)Trans, AP_MAX_SYNC_STATE, AP_MAX_SYNC_MSG, (STATE_MACHINE_FUNC)Drop, AP_SYNC_IDLE, AP_SYNC_MACHINE_BASE);
StateMachineSetAction(Sm, AP_SYNC_IDLE, APMT2_PEER_PROBE_REQ, (STATE_MACHINE_FUNC)APPeerProbeReqAction);
StateMachineSetAction(Sm, AP_SYNC_IDLE, APMT2_PEER_BEACON, (STATE_MACHINE_FUNC)APPeerBeaconAction);
#ifdef AP_SCAN_SUPPORT
StateMachineSetAction(Sm, AP_SYNC_IDLE, APMT2_MLME_SCAN_REQ, (STATE_MACHINE_FUNC)APMlmeScanReqAction);
#ifdef CON_WPS
StateMachineSetAction(Sm, AP_SYNC_IDLE, APMT2_MLME_SCAN_COMPLETE, (STATE_MACHINE_FUNC)APMlmeScanCompleteAction);
#endif /* CON_WPS */
/* scan_listen state */
StateMachineSetAction(Sm, AP_SCAN_LISTEN, APMT2_MLME_SCAN_REQ, (STATE_MACHINE_FUNC)APInvalidStateWhenScan);
StateMachineSetAction(Sm, AP_SCAN_LISTEN, APMT2_PEER_BEACON, (STATE_MACHINE_FUNC)APPeerBeaconAtScanAction);
StateMachineSetAction(Sm, AP_SCAN_LISTEN, APMT2_PEER_PROBE_RSP, (STATE_MACHINE_FUNC)APPeerBeaconAtScanAction);
StateMachineSetAction(Sm, AP_SCAN_LISTEN, APMT2_SCAN_TIMEOUT, (STATE_MACHINE_FUNC)APScanTimeoutAction);
StateMachineSetAction(Sm, AP_SCAN_LISTEN, APMT2_MLME_SCAN_CNCL, (STATE_MACHINE_FUNC)APScanCnclAction);
/* resume scanning for fast-roaming */
StateMachineSetAction(Sm, AP_SCAN_PENDING, APMT2_MLME_SCAN_REQ, (STATE_MACHINE_FUNC)APMlmeScanReqAction);
StateMachineSetAction(Sm, AP_SCAN_PENDING, APMT2_PEER_BEACON, (STATE_MACHINE_FUNC)APPeerBeaconAtScanAction);
StateMachineSetAction(Sm, AP_SCAN_PENDING, APMT2_PEER_PROBE_RSP, (STATE_MACHINE_FUNC)APPeerBeaconAtScanAction);
RTMPInitTimer(pAd, &pAd->MlmeAux.APScanTimer, GET_TIMER_FUNCTION(APScanTimeout), pAd, FALSE);
#endif /* AP_SCAN_SUPPORT */
}
/*
==========================================================================
Description:
The sync state machine,
Parameters:
Sm - pointer to the state machine
Note:
the state machine looks like the following
==========================================================================
*/
VOID ApCliSyncStateMachineInit(
IN PRTMP_ADAPTER pAd,
IN STATE_MACHINE *Sm,
OUT STATE_MACHINE_FUNC Trans[])
{
UCHAR i;
#ifdef APCLI_CONNECTION_TRIAL
PAPCLI_STRUCT pApCliEntry;
#endif /*APCLI_CONNECTION_TRIAL*/
StateMachineInit(Sm, (STATE_MACHINE_FUNC*)Trans,
APCLI_MAX_SYNC_STATE, APCLI_MAX_SYNC_MSG,
(STATE_MACHINE_FUNC)Drop, APCLI_SYNC_IDLE,
APCLI_SYNC_MACHINE_BASE);
/* column 1 */
StateMachineSetAction(Sm, APCLI_SYNC_IDLE, APCLI_MT2_MLME_PROBE_REQ, (STATE_MACHINE_FUNC)ApCliMlmeProbeReqAction);
StateMachineSetAction(Sm, APCLI_SYNC_IDLE, APCLI_MT2_MLME_SCAN_REQ, (STATE_MACHINE_FUNC)ApCliMlmeScanReqAction);
#ifdef SMART_MESH_MONITOR
StateMachineSetAction(Sm, APCLI_SYNC_IDLE, APCLI_MT2_PEER_PROBE_RSP, (STATE_MACHINE_FUNC)ApCliPeerProbeRspAtScanReqAction);
#endif /* SMART_MESH_MONITOR */
/*column 2 */
StateMachineSetAction(Sm, APCLI_JOIN_WAIT_PROBE_RSP, APCLI_MT2_MLME_PROBE_REQ, (STATE_MACHINE_FUNC)ApCliInvalidStateWhenJoin);
StateMachineSetAction(Sm, APCLI_JOIN_WAIT_PROBE_RSP, APCLI_MT2_PEER_PROBE_RSP, (STATE_MACHINE_FUNC)ApCliPeerProbeRspAtJoinAction);
StateMachineSetAction(Sm, APCLI_JOIN_WAIT_PROBE_RSP, APCLI_MT2_PROBE_TIMEOUT, (STATE_MACHINE_FUNC)ApCliProbeTimeoutAtJoinAction);
StateMachineSetAction(Sm, APCLI_JOIN_WAIT_PROBE_RSP, APCLI_MT2_PEER_BEACON, (STATE_MACHINE_FUNC)ApCliPeerProbeRspAtJoinAction);
for (i = 0; i < MAX_APCLI_NUM; i++)
{
/* timer init */
#ifdef APCLI_CONNECTION_TRIAL
pApCliEntry = &pAd->ApCfg.ApCliTab[i];
#endif /*APCLI_CONNECTION_TRIAL*/
#ifdef APCLI_CONNECTION_TRIAL
RTMPInitTimer(pAd, &pAd->ApCfg.ApCliTab[i].MlmeAux.ProbeTimer, GET_TIMER_FUNCTION(ApCliProbeTimeout), (PVOID)pApCliEntry, FALSE);
#else
RTMPInitTimer(pAd, &pAd->ApCfg.ApCliTab[i].MlmeAux.ProbeTimer, GET_TIMER_FUNCTION(ApCliProbeTimeout), pAd, FALSE);
#endif /* APCLI_CONNECTION_TRIAL */
pAd->ApCfg.ApCliTab[i].SyncCurrState = APCLI_SYNC_IDLE;
}
return;
}
/*
==========================================================================
Description:
association state machine init, including state transition and timer init
Parameters:
S - pointer to the association state machine
Note:
The state machine looks like the following
ASSOC_IDLE ASSOC_WAIT_RSP REASSOC_WAIT_RSP DISASSOC_WAIT_RSP
MT2_MLME_ASSOC_REQ mlme_assoc_req_action invalid_state_when_assoc invalid_state_when_assoc invalid_state_when_assoc
MT2_MLME_REASSOC_REQ mlme_reassoc_req_action invalid_state_when_reassoc invalid_state_when_reassoc invalid_state_when_reassoc
MT2_MLME_DISASSOC_REQ mlme_disassoc_req_action mlme_disassoc_req_action mlme_disassoc_req_action mlme_disassoc_req_action
MT2_PEER_DISASSOC_REQ peer_disassoc_action peer_disassoc_action peer_disassoc_action peer_disassoc_action
MT2_PEER_ASSOC_REQ drop drop drop drop
MT2_PEER_ASSOC_RSP drop peer_assoc_rsp_action drop drop
MT2_PEER_REASSOC_REQ drop drop drop drop
MT2_PEER_REASSOC_RSP drop drop peer_reassoc_rsp_action drop
MT2_CLS3ERR cls3err_action cls3err_action cls3err_action cls3err_action
MT2_ASSOC_TIMEOUT timer_nop assoc_timeout_action timer_nop timer_nop
MT2_REASSOC_TIMEOUT timer_nop timer_nop reassoc_timeout_action timer_nop
MT2_DISASSOC_TIMEOUT timer_nop timer_nop timer_nop disassoc_timeout_action
==========================================================================
*/
VOID AssocStateMachineInit(
IN PRTMP_ADAPTER pAd,
IN STATE_MACHINE *S,
OUT STATE_MACHINE_FUNC Trans[])
{
StateMachineInit(S, (STATE_MACHINE_FUNC*)Trans, MAX_ASSOC_STATE, MAX_ASSOC_MSG, (STATE_MACHINE_FUNC)Drop, ASSOC_IDLE, ASSOC_MACHINE_BASE);
// first column
StateMachineSetAction(S, ASSOC_IDLE, MT2_MLME_ASSOC_REQ, (STATE_MACHINE_FUNC)MlmeAssocReqAction);
StateMachineSetAction(S, ASSOC_IDLE, MT2_MLME_REASSOC_REQ, (STATE_MACHINE_FUNC)MlmeReassocReqAction);
StateMachineSetAction(S, ASSOC_IDLE, MT2_MLME_DISASSOC_REQ, (STATE_MACHINE_FUNC)MlmeDisassocReqAction);
StateMachineSetAction(S, ASSOC_IDLE, MT2_PEER_DISASSOC_REQ, (STATE_MACHINE_FUNC)PeerDisassocAction);
// second column
StateMachineSetAction(S, ASSOC_WAIT_RSP, MT2_MLME_ASSOC_REQ, (STATE_MACHINE_FUNC)InvalidStateWhenAssoc);
StateMachineSetAction(S, ASSOC_WAIT_RSP, MT2_MLME_REASSOC_REQ, (STATE_MACHINE_FUNC)InvalidStateWhenReassoc);
StateMachineSetAction(S, ASSOC_WAIT_RSP, MT2_MLME_DISASSOC_REQ, (STATE_MACHINE_FUNC)InvalidStateWhenDisassociate);
StateMachineSetAction(S, ASSOC_WAIT_RSP, MT2_PEER_DISASSOC_REQ, (STATE_MACHINE_FUNC)PeerDisassocAction);
StateMachineSetAction(S, ASSOC_WAIT_RSP, MT2_PEER_ASSOC_RSP, (STATE_MACHINE_FUNC)PeerAssocRspAction);
StateMachineSetAction(S, ASSOC_WAIT_RSP, MT2_ASSOC_TIMEOUT, (STATE_MACHINE_FUNC)AssocTimeoutAction);
// third column
StateMachineSetAction(S, REASSOC_WAIT_RSP, MT2_MLME_ASSOC_REQ, (STATE_MACHINE_FUNC)InvalidStateWhenAssoc);
StateMachineSetAction(S, REASSOC_WAIT_RSP, MT2_MLME_REASSOC_REQ, (STATE_MACHINE_FUNC)InvalidStateWhenReassoc);
StateMachineSetAction(S, REASSOC_WAIT_RSP, MT2_MLME_DISASSOC_REQ, (STATE_MACHINE_FUNC)InvalidStateWhenDisassociate);
StateMachineSetAction(S, REASSOC_WAIT_RSP, MT2_PEER_DISASSOC_REQ, (STATE_MACHINE_FUNC)PeerDisassocAction);
StateMachineSetAction(S, REASSOC_WAIT_RSP, MT2_PEER_REASSOC_RSP, (STATE_MACHINE_FUNC)PeerReassocRspAction);
StateMachineSetAction(S, REASSOC_WAIT_RSP, MT2_REASSOC_TIMEOUT, (STATE_MACHINE_FUNC)ReassocTimeoutAction);
// fourth column
StateMachineSetAction(S, DISASSOC_WAIT_RSP, MT2_MLME_ASSOC_REQ, (STATE_MACHINE_FUNC)InvalidStateWhenAssoc);
StateMachineSetAction(S, DISASSOC_WAIT_RSP, MT2_MLME_REASSOC_REQ, (STATE_MACHINE_FUNC)InvalidStateWhenReassoc);
StateMachineSetAction(S, DISASSOC_WAIT_RSP, MT2_MLME_DISASSOC_REQ, (STATE_MACHINE_FUNC)InvalidStateWhenDisassociate);
StateMachineSetAction(S, DISASSOC_WAIT_RSP, MT2_PEER_DISASSOC_REQ, (STATE_MACHINE_FUNC)PeerDisassocAction);
StateMachineSetAction(S, DISASSOC_WAIT_RSP, MT2_DISASSOC_TIMEOUT, (STATE_MACHINE_FUNC)DisassocTimeoutAction);
// timer init
RTMPInitTimer(pAd, &pAd->MlmeAux.AssocTimer, GET_TIMER_FUNCTION(AssocTimeout), pAd, FALSE);
RTMPInitTimer(pAd, &pAd->MlmeAux.ReassocTimer, GET_TIMER_FUNCTION(ReassocTimeout), pAd, FALSE);
RTMPInitTimer(pAd, &pAd->MlmeAux.DisassocTimer, GET_TIMER_FUNCTION(DisassocTimeout), pAd, FALSE);
}
/*
==========================================================================
Description:
The mesh control state machine,
Parameters:
Sm - pointer to the state machine
Note:
the state machine looks like the following
==========================================================================
*/
VOID MeshCtrlStateMachineInit(
IN PRTMP_ADAPTER pAd,
IN STATE_MACHINE *Sm,
OUT STATE_MACHINE_FUNC Trans[])
{
StateMachineInit(Sm, (STATE_MACHINE_FUNC*)Trans, (ULONG)MESH_CTRL_MAX_STATES,
(ULONG)MESH_CTRL_MAX_EVENTS, (STATE_MACHINE_FUNC)Drop, MESH_CTRL_IDLE, MESH_CTRL_IDLE);
/* MESH_CTRL_IDLE state */
StateMachineSetAction(Sm, MESH_CTRL_IDLE, MESH_CTRL_JOIN, (STATE_MACHINE_FUNC)MeshCtrlJoinAction);
/* MESH_CTRL_DISCOVERY state */
StateMachineSetAction(Sm, MESH_CTRL_DISCOVERY, MESH_CTRL_DISCONNECT, (STATE_MACHINE_FUNC)MeshCtrlDisconnectAtDicoveryAction);
StateMachineSetAction(Sm, MESH_CTRL_DISCOVERY, APMT2_MLME_SCAN_FINISH, (STATE_MACHINE_FUNC)MeshCtrlFinishDiscoveryAction);
StateMachineSetAction(Sm, MESH_CTRL_DISCOVERY, APMT2_MLME_SCAN_ABORT, (STATE_MACHINE_FUNC)MeshCtrlDiscoveryAbortAction);
/* MESH_CTRL_ACTIVATED state */
StateMachineSetAction(Sm, MESH_CTRL_ACTIVATED, MESH_CTRL_PLD, (STATE_MACHINE_FUNC)MeshCtrlPeriodPLDAction);
StateMachineSetAction(Sm, MESH_CTRL_ACTIVATED, MESH_CTRL_DISCONNECT, (STATE_MACHINE_FUNC)MeshCtrlDisconnectAtActivatedAction);
StateMachineSetAction(Sm, MESH_CTRL_ACTIVATED, MESH_CTRL_UCG_EVT, (STATE_MACHINE_FUNC)MeshCtrlUcgWhenActivated);
StateMachineSetAction(Sm, MESH_CTRL_ACTIVATED, MESH_PEER_UCG_EVT, (STATE_MACHINE_FUNC)MeshPeerUcgWhenActivated);
/* MESH_CTRL_UCG state */
StateMachineSetAction(Sm, MESH_CTRL_UCG, MESH_CTRL_DISCONNECT, (STATE_MACHINE_FUNC)MeshCtrlDisconnectAtUCGAction);
StateMachineSetAction(Sm, MESH_CTRL_UCG, MESH_PEER_UCG_EVT, (STATE_MACHINE_FUNC)MeshPeerUcgWhenUcg);
StateMachineSetAction(Sm, MESH_CTRL_UCG, MESH_CTRL_MCS_TIMEOUT, (STATE_MACHINE_FUNC)MeshCtrlMcsTimeoutAction);
/* init all Mesh ctrl state. */
pAd->MeshTab.CtrlCurrentState = MESH_CTRL_IDLE;
/* init all timer relative to mesh ctrl sm. */
RTMPInitTimer(pAd, &pAd->MeshTab.PldTimer, GET_TIMER_FUNCTION(MeshPldTimeout), pAd, FALSE);
RTMPInitTimer(pAd, &pAd->MeshTab.McsTimer, GET_TIMER_FUNCTION(MeshMcsTimeout), pAd, FALSE);
return;
}
VOID RRM_CfgInit(
IN PRTMP_ADAPTER pAd)
{
INT loop;
PRRM_CONFIG pRrmCfg;
for (loop = 0; loop < MAX_MBSSID_NUM(pAd); loop++)
{
pRrmCfg = &pAd->ApCfg.MBSSID[loop].RrmCfg;
pRrmCfg->QuietCB.QuietPeriod = RRM_DEFAULT_QUIET_PERIOD;
pRrmCfg->QuietCB.QuietDuration = RRM_DEFAULT_QUIET_DURATION;
pRrmCfg->QuietCB.QuietOffset = RRM_DEFAULT_QUIET_OFFSET;
RTMPInitTimer(pAd, &pRrmCfg->QuietCB.QuietOffsetTimer, GET_TIMER_FUNCTION(RRM_QuietOffsetTimeout), pAd, FALSE);
RTMPInitTimer(pAd, &pRrmCfg->QuietCB.QuietTimer, GET_TIMER_FUNCTION(RRM_QuietTimeout), pAd, FALSE);
pRrmCfg->QuietCB.QuietState = RRM_QUIET_IDLE;
pRrmCfg->QuietCB.CurAid = 1;
pRrmCfg->bDot11kRRMEnable = TRUE;
pRrmCfg->bDot11kRRMNeighborRepTSFEnable = FALSE;
}
return;
}
void FT_OTA_AuthStateMachineInit(
IN PRTMP_ADAPTER pAd,
IN STATE_MACHINE *Sm,
OUT STATE_MACHINE_FUNC Trans[])
{
StateMachineInit(Sm, Trans, FT_OTA_MAX_AUTH_STATE, FT_OTA_MAX_AUTH_MSG, (STATE_MACHINE_FUNC)Drop, FT_OTA_AUTH_REQ_IDLE, FT_OTA_AUTH_MACHINE_BASE);
/* the first column */
StateMachineSetAction(Sm, FT_OTA_AUTH_REQ_IDLE, FT_OTA_MT2_MLME_AUTH_REQ, (STATE_MACHINE_FUNC)FT_OTA_MlmeAuthReqAction);
/* the second column */
StateMachineSetAction(Sm, FT_OTA_AUTH_WAIT_RESP, FT_OTA_MT2_MLME_AUTH_REQ, (STATE_MACHINE_FUNC)FT_OTA_InvalidStateWhenAuth);
StateMachineSetAction(Sm, FT_OTA_AUTH_WAIT_RESP, FT_OTA_MT2_PEER_AUTH_EVEN, (STATE_MACHINE_FUNC)FT_OTA_PeerAuthRspAction);
/* the third column */
StateMachineSetAction(Sm, FT_OTA_AUTH_WAIT_ACK, FT_OTA_MT2_MLME_AUTH_REQ, (STATE_MACHINE_FUNC)FT_OTA_InvalidStateWhenAuth);
StateMachineSetAction(Sm, FT_OTA_AUTH_WAIT_ACK, FT_OTA_MT2_PEER_AUTH_EVEN, (STATE_MACHINE_FUNC)FT_OTA_PeerAuthAckAction);
RTMPInitTimer(pAd, &pAd->MlmeAux.FtOtaAuthTimer, GET_TIMER_FUNCTION(FT_OTA_AuthTimeout), pAd, FALSE);
}
VOID ApCliAuthStateMachineInit(
IN PRTMP_ADAPTER pAd,
IN STATE_MACHINE *Sm,
OUT STATE_MACHINE_FUNC Trans[])
{
UCHAR i;
StateMachineInit(Sm, (STATE_MACHINE_FUNC*)Trans,
APCLI_MAX_AUTH_STATE, APCLI_MAX_AUTH_MSG,
(STATE_MACHINE_FUNC)Drop, APCLI_AUTH_REQ_IDLE,
APCLI_AUTH_MACHINE_BASE);
/* the first column */
StateMachineSetAction(Sm, APCLI_AUTH_REQ_IDLE, APCLI_MT2_MLME_AUTH_REQ, (STATE_MACHINE_FUNC)ApCliMlmeAuthReqAction);
StateMachineSetAction(Sm, APCLI_AUTH_REQ_IDLE, APCLI_MT2_PEER_DEAUTH, (STATE_MACHINE_FUNC)ApCliPeerDeauthAction);
StateMachineSetAction(Sm, APCLI_AUTH_REQ_IDLE, APCLI_MT2_MLME_DEAUTH_REQ, (STATE_MACHINE_FUNC)ApCliMlmeDeauthReqAction);
/* the second column */
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ2, APCLI_MT2_MLME_AUTH_REQ, (STATE_MACHINE_FUNC)ApCliInvalidStateWhenAuth);
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ2, APCLI_MT2_PEER_AUTH_EVEN, (STATE_MACHINE_FUNC)ApCliPeerAuthRspAtSeq2Action);
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ2, APCLI_MT2_PEER_DEAUTH, (STATE_MACHINE_FUNC)ApCliPeerDeauthAction);
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ2, APCLI_MT2_AUTH_TIMEOUT, (STATE_MACHINE_FUNC)ApCliAuthTimeoutAction);
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ2, APCLI_MT2_MLME_DEAUTH_REQ, (STATE_MACHINE_FUNC)ApCliMlmeDeauthReqAction);
/* the third column */
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ4, APCLI_MT2_MLME_AUTH_REQ, (STATE_MACHINE_FUNC)ApCliInvalidStateWhenAuth);
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ4, APCLI_MT2_PEER_AUTH_EVEN, (STATE_MACHINE_FUNC)ApCliPeerAuthRspAtSeq4Action);
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ4, APCLI_MT2_PEER_DEAUTH, (STATE_MACHINE_FUNC)ApCliPeerDeauthAction);
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ4, APCLI_MT2_AUTH_TIMEOUT, (STATE_MACHINE_FUNC)ApCliAuthTimeoutAction);
StateMachineSetAction(Sm, APCLI_AUTH_WAIT_SEQ4, APCLI_MT2_MLME_DEAUTH_REQ, (STATE_MACHINE_FUNC)ApCliMlmeDeauthReqAction);
for (i=0; i < MAX_APCLI_NUM; i++)
{
pAd->ApCfg.ApCliTab[i].AuthCurrState = APCLI_AUTH_REQ_IDLE;
/* timer init */
RTMPInitTimer(pAd, &pAd->ApCfg.ApCliTab[i].ApCliMlmeAux.ApCliAuthTimer, GET_TIMER_FUNCTION(ApCliAuthTimeout), pAd, FALSE);
}
return;
}
/*
==========================================================================
Description:
The sync state machine,
Parameters:
Sm - pointer to the state machine
Note:
the state machine looks like the following
AP_SYNC_IDLE
APMT2_PEER_PROBE_REQ peer_probe_req_action
==========================================================================
*/
VOID APSyncStateMachineInit(
IN PRTMP_ADAPTER pAd,
IN STATE_MACHINE *Sm,
OUT STATE_MACHINE_FUNC Trans[])
{
StateMachineInit(Sm, (STATE_MACHINE_FUNC *)Trans, AP_MAX_SYNC_STATE, AP_MAX_SYNC_MSG, (STATE_MACHINE_FUNC)Drop, AP_SYNC_IDLE, AP_SYNC_MACHINE_BASE);
StateMachineSetAction(Sm, AP_SYNC_IDLE, APMT2_PEER_PROBE_REQ, (STATE_MACHINE_FUNC)APPeerProbeReqAction);
StateMachineSetAction(Sm, AP_SYNC_IDLE, APMT2_PEER_BEACON, (STATE_MACHINE_FUNC)APPeerBeaconAction);
#ifdef AP_SCAN_SUPPORT
StateMachineSetAction(Sm, AP_SYNC_IDLE, APMT2_MLME_SCAN_REQ, (STATE_MACHINE_FUNC)APMlmeScanReqAction);
// scan_listen state
StateMachineSetAction(Sm, AP_SCAN_LISTEN, APMT2_MLME_SCAN_REQ, (STATE_MACHINE_FUNC)APInvalidStateWhenScan);
StateMachineSetAction(Sm, AP_SCAN_LISTEN, APMT2_PEER_BEACON, (STATE_MACHINE_FUNC)APPeerBeaconAtScanAction);
StateMachineSetAction(Sm, AP_SCAN_LISTEN, APMT2_PEER_PROBE_RSP, (STATE_MACHINE_FUNC)APPeerBeaconAtScanAction);
StateMachineSetAction(Sm, AP_SCAN_LISTEN, APMT2_SCAN_TIMEOUT, (STATE_MACHINE_FUNC)APScanTimeoutAction);
StateMachineSetAction(Sm, AP_SCAN_LISTEN, APMT2_MLME_SCAN_CNCL, (STATE_MACHINE_FUNC)APScanCnclAction);
RTMPInitTimer(pAd, &pAd->MlmeAux.ScanTimer, GET_TIMER_FUNCTION(APScanTimeout), pAd, FALSE);
#endif // AP_SCAN_SUPPORT //
}
MAC_TABLE_ENTRY *MacTableInsertEntry(
IN RTMP_ADAPTER *pAd,
IN UCHAR *pAddr,
IN struct wifi_dev *wdev,
IN UINT32 ent_type,
IN UCHAR OpMode,
IN BOOLEAN CleanAll)
{
UCHAR HashIdx;
int i, FirstWcid;
MAC_TABLE_ENTRY *pEntry = NULL, *pCurrEntry;
if (pAd->MacTab.Size >= MAX_LEN_OF_MAC_TABLE)
return NULL;
FirstWcid = 1;
/* allocate one MAC entry*/
NdisAcquireSpinLock(&pAd->MacTabLock);
for (i = FirstWcid; i< MAX_LEN_OF_MAC_TABLE; i++) /* skip entry#0 so that "entry index == AID" for fast lookup*/
{
/* pick up the first available vacancy*/
if (IS_ENTRY_NONE(&pAd->MacTab.Content[i]))
{
pEntry = &pAd->MacTab.Content[i];
mac_entry_reset(pAd, pEntry, CleanAll);
/* ENTRY PREEMPTION: initialize the entry */
pEntry->wdev = wdev;
pEntry->wcid = i;
pEntry->func_tb_idx = wdev->func_idx;
pEntry->bIAmBadAtheros = FALSE;
pEntry->pAd = pAd;
pEntry->CMTimerRunning = FALSE;
COPY_MAC_ADDR(pEntry->Addr, pAddr);
pEntry->Sst = SST_NOT_AUTH;
pEntry->AuthState = AS_NOT_AUTH;
pEntry->Aid = (USHORT)i;
pEntry->CapabilityInfo = 0;
pEntry->AssocDeadLine = MAC_TABLE_ASSOC_TIMEOUT;
pEntry->PsMode = PWR_ACTIVE;
pEntry->NoDataIdleCount = 0;
pEntry->ContinueTxFailCnt = 0;
#ifdef WDS_SUPPORT
pEntry->LockEntryTx = FALSE;
#endif /* WDS_SUPPORT */
pEntry->TimeStamp_toTxRing = 0;
// TODO: shiang-usw, remove upper setting becasue we need to migrate to tr_entry!
pAd->MacTab.tr_entry[i].PsMode = PWR_ACTIVE;
pAd->MacTab.tr_entry[i].NoDataIdleCount = 0;
pAd->MacTab.tr_entry[i].ContinueTxFailCnt = 0;
pAd->MacTab.tr_entry[i].LockEntryTx = FALSE;
pAd->MacTab.tr_entry[i].TimeStamp_toTxRing = 0;
pAd->MacTab.tr_entry[i].PsDeQWaitCnt = 0;
pEntry->EnqueueEapolStartTimerRunning = EAPOL_START_DISABLE;
pEntry->GTKState = REKEY_NEGOTIATING;
pEntry->PairwiseKey.KeyLen = 0;
pEntry->PairwiseKey.CipherAlg = CIPHER_NONE;
pEntry->PMKID_CacheIdx = ENTRY_NOT_FOUND;
pEntry->RSNIE_Len = 0;
NdisZeroMemory(pEntry->R_Counter, sizeof(pEntry->R_Counter));
pEntry->ReTryCounter = PEER_MSG1_RETRY_TIMER_CTR;
do
{
#ifdef CONFIG_AP_SUPPORT
#ifdef APCLI_SUPPORT
if (ent_type == ENTRY_APCLI)
{
SET_ENTRY_APCLI(pEntry);
//SET_ENTRY_AP(pEntry);//Carter, why set entry to APCLI then set to AP????
COPY_MAC_ADDR(pEntry->bssid, pAddr);
pEntry->AuthMode = pAd->ApCfg.ApCliTab[pEntry->func_tb_idx].wdev.AuthMode;
pEntry->WepStatus = pAd->ApCfg.ApCliTab[pEntry->func_tb_idx].wdev.WepStatus;
if (pEntry->AuthMode < Ndis802_11AuthModeWPA)
{
pEntry->WpaState = AS_NOTUSE;
pEntry->PrivacyFilter = Ndis802_11PrivFilterAcceptAll;
}
else
{
pEntry->WpaState = AS_PTKSTART;
pEntry->PrivacyFilter = Ndis802_11PrivFilter8021xWEP;
}
break;
}
#endif /* APCLI_SUPPORT */
#ifdef WDS_SUPPORT
if (ent_type == ENTRY_WDS)
{
SET_ENTRY_WDS(pEntry);
COPY_MAC_ADDR(pEntry->bssid, pAd->ApCfg.MBSSID[MAIN_MBSSID].wdev.bssid);
pEntry->AuthMode = Ndis802_11AuthModeOpen;
pEntry->WepStatus = Ndis802_11EncryptionDisabled;
break;
}
#endif /* WDS_SUPPORT */
#endif /* CONFIG_AP_SUPPORT */
#ifdef CONFIG_AP_SUPPORT
if (ent_type == ENTRY_CLIENT)
{ /* be a regular-entry*/
if ((pEntry->func_tb_idx < pAd->ApCfg.BssidNum) &&
(pEntry->func_tb_idx < MAX_MBSSID_NUM(pAd)) &&
((pEntry->func_tb_idx < HW_BEACON_MAX_NUM)) &&
(pAd->ApCfg.MBSSID[pEntry->func_tb_idx].MaxStaNum != 0) &&
(pAd->ApCfg.MBSSID[pEntry->func_tb_idx].StaCount >= pAd->ApCfg.MBSSID[pEntry->func_tb_idx].MaxStaNum))
{
DBGPRINT(RT_DEBUG_WARN, ("%s: The connection table is full in ra%d.\n", __FUNCTION__, pEntry->func_tb_idx));
NdisReleaseSpinLock(&pAd->MacTabLock);
return NULL;
}
ASSERT((wdev == &pAd->ApCfg.MBSSID[pEntry->func_tb_idx].wdev));
SET_ENTRY_CLIENT(pEntry);
pEntry->pMbss = &pAd->ApCfg.MBSSID[pEntry->func_tb_idx];
MBSS_MR_APIDX_SANITY_CHECK(pAd, pEntry->func_tb_idx);
COPY_MAC_ADDR(pEntry->bssid, wdev->bssid);
pEntry->AuthMode = wdev->AuthMode;
pEntry->WepStatus = wdev->WepStatus;
pEntry->GroupKeyWepStatus = wdev->GroupKeyWepStatus;
if (pEntry->AuthMode < Ndis802_11AuthModeWPA)
pEntry->WpaState = AS_NOTUSE;
else
pEntry->WpaState = AS_INITIALIZE;
pEntry->PrivacyFilter = Ndis802_11PrivFilterAcceptAll;
pEntry->StaIdleTimeout = pAd->ApCfg.StaIdleTimeout;
pAd->ApCfg.MBSSID[pEntry->func_tb_idx].StaCount++;
pAd->ApCfg.EntryClientCount++;
break;
}
#endif /* CONFIG_AP_SUPPORT */
} while (FALSE);
tr_tb_set_entry(pAd, i, pEntry);
RTMPInitTimer(pAd, &pEntry->EnqueueStartForPSKTimer, GET_TIMER_FUNCTION(EnqueueStartForPSKExec), pEntry, FALSE);
#ifdef CONFIG_AP_SUPPORT
{
if (IS_ENTRY_CLIENT(pEntry)) /* Only Client entry need the retry timer.*/
{
RTMPInitTimer(pAd, &pEntry->RetryTimer, GET_TIMER_FUNCTION(WPARetryExec), pEntry, FALSE);
#ifdef DOT11W_PMF_SUPPORT
RTMPInitTimer(pAd, &pEntry->SAQueryTimer, GET_TIMER_FUNCTION(PMF_SAQueryTimeOut), pEntry, FALSE);
RTMPInitTimer(pAd, &pEntry->SAQueryConfirmTimer, GET_TIMER_FUNCTION(PMF_SAQueryConfirmTimeOut), pEntry, FALSE);
#endif /* DOT11W_PMF_SUPPORT */
}
#ifdef APCLI_SUPPORT
if (IS_ENTRY_APCLI(pEntry))
RTMPInitTimer(pAd, &pEntry->RetryTimer, GET_TIMER_FUNCTION(WPARetryExec), pEntry, FALSE);
#endif /* APCLI_SUPPORT */
}
#endif /* CONFIG_AP_SUPPORT */
#ifdef STREAM_MODE_SUPPORT
/* Enable Stream mode for first three entries in MAC table */
#endif /* STREAM_MODE_SUPPORT */
#ifdef UAPSD_SUPPORT
/* Ralink WDS doesn't support any power saving.*/
if (IS_ENTRY_CLIENT(pEntry)
)
{
/* init U-APSD enhancement related parameters */
UAPSD_MR_ENTRY_INIT(pEntry);
}
#endif /* UAPSD_SUPPORT */
pAd->MacTab.Size ++;
/* Set the security mode of this entry as OPEN-NONE in ASIC */
RTMP_REMOVE_PAIRWISE_KEY_ENTRY(pAd, (UCHAR)i);
#ifdef MT_MAC
if (pAd->chipCap.hif_type == HIF_MT)
MT_ADDREMOVE_KEY(pAd, 1, pEntry->apidx, 0, pEntry->wcid, PAIRWISEKEYTABLE, &pEntry->PairwiseKey, pEntry->Addr);
#endif
/* Add this entry into ASIC RX WCID search table */
RTMP_STA_ENTRY_ADD(pAd, pEntry);
#ifdef CONFIG_AP_SUPPORT
IF_DEV_CONFIG_OPMODE_ON_AP(pAd)
{
#ifdef WSC_AP_SUPPORT
pEntry->bWscCapable = FALSE;
pEntry->Receive_EapolStart_EapRspId = 0;
#endif /* WSC_AP_SUPPORT */
}
#endif /* CONFIG_AP_SUPPORT */
DBGPRINT(RT_DEBUG_TRACE, ("%s(): alloc entry #%d, Total= %d\n",
__FUNCTION__, i, pAd->MacTab.Size));
break;
}
}
BOOLEAN BARecSessionAdd(struct rt_rtmp_adapter *pAd,
struct rt_mac_table_entry *pEntry, struct rt_frame_addba_req * pFrame)
{
struct rt_ba_rec_entry *pBAEntry = NULL;
BOOLEAN Status = TRUE;
BOOLEAN Cancelled;
u16 Idx;
u8 TID;
u8 BAWinSize;
/*u32 Value; */
/*u32 offset; */
ASSERT(pEntry);
/* find TID */
TID = pFrame->BaParm.TID;
BAWinSize =
min(((u8)pFrame->BaParm.BufSize),
(u8)pAd->CommonCfg.BACapability.field.RxBAWinLimit);
/* Intel patch */
if (BAWinSize == 0) {
BAWinSize = 64;
}
Idx = pEntry->BARecWcidArray[TID];
if (Idx == 0) {
pBAEntry = BATableAllocRecEntry(pAd, &Idx);
} else {
pBAEntry = &pAd->BATable.BARecEntry[Idx];
/* flush all pending reordering mpdus */
ba_refresh_reordering_mpdus(pAd, pBAEntry);
}
DBGPRINT(RT_DEBUG_TRACE,
("%s(%ld): Idx = %d, BAWinSize(req %d) = %d\n", __func__,
pAd->BATable.numAsRecipient, Idx, pFrame->BaParm.BufSize,
BAWinSize));
/* Start fill in parameters. */
if (pBAEntry != NULL) {
ASSERT(pBAEntry->list.qlen == 0);
pBAEntry->REC_BA_Status = Recipient_HandleRes;
pBAEntry->BAWinSize = BAWinSize;
pBAEntry->Wcid = pEntry->Aid;
pBAEntry->TID = TID;
pBAEntry->TimeOutValue = pFrame->TimeOutValue;
pBAEntry->REC_BA_Status = Recipient_Accept;
/* initial sequence number */
pBAEntry->LastIndSeq = RESET_RCV_SEQ; /*pFrame->BaStartSeq.field.StartSeq; */
DBGPRINT(RT_DEBUG_OFF,
("Start Seq = %08x\n",
pFrame->BaStartSeq.field.StartSeq));
if (pEntry->RXBAbitmap & (1 << TID)) {
RTMPCancelTimer(&pBAEntry->RECBATimer, &Cancelled);
} else {
RTMPInitTimer(pAd, &pBAEntry->RECBATimer,
GET_TIMER_FUNCTION
(BARecSessionIdleTimeout), pBAEntry,
TRUE);
}
/* Set Bitmap flag. */
pEntry->RXBAbitmap |= (1 << TID);
pEntry->BARecWcidArray[TID] = Idx;
pEntry->BADeclineBitmap &= ~(1 << TID);
/* Set BA session mask in WCID table. */
RTMP_ADD_BA_SESSION_TO_ASIC(pAd, pEntry->Aid, TID);
DBGPRINT(RT_DEBUG_TRACE,
("MACEntry[%d]RXBAbitmap = 0x%x. BARecWcidArray=%d\n",
pEntry->Aid, pEntry->RXBAbitmap,
pEntry->BARecWcidArray[TID]));
} else {
Status = FALSE;
DBGPRINT(RT_DEBUG_TRACE,
("Can't Accept ADDBA for %pM TID = %d\n",
pEntry->Addr, TID));
}
return (Status);
}
// Called when host sets LED mode.
// Called in interrupt level
void SetLinkStatus(IN PRTMP_ADAPTER pAd)
{
BlinkFor8sTimer = 0;
switch(LinkStatus)
{
case 0x00: // Radio off
CurrentLedCfg.field.LedGMode = LedParameter.LedAgCfg.field.LedGMode_RadioOff;
CurrentLedCfg.field.LedAMode = LedParameter.LedAgCfg.field.LedAMode_RadioOff;
CurrentLedCfg.field.LedActMode = LedParameter.LedActCfg.field.LedActMode_RadioOff;
CurrentLedCfg.field.LedActModeNoTx = LedParameter.LedActCfg.field.LedActModeNoTx_RadioOff;
CurrentLedCfg.field.LedGPolarity = LedParameter.LedPolarityCfg.field.LedGPolarity_RadioOff;
CurrentLedCfg.field.LedAPolarity = LedParameter.LedPolarityCfg.field.LedAPolarity_RadioOff;
CurrentLedCfg.field.LedActPolarity = LedParameter.LedPolarityCfg.field.LedActPolarity_RadioOff;
break;
case 0x20: // Radio on but not link up
CurrentLedCfg.field.LedGMode = LedParameter.LedAgCfg.field.LedGMode_RadioOnLinkDown;
CurrentLedCfg.field.LedAMode = LedParameter.LedAgCfg.field.LedAMode_RadioOnLinkDown;
CurrentLedCfg.field.LedActMode = LedParameter.LedActCfg.field.LedActMode_RadioOnLinkDown;
CurrentLedCfg.field.LedActModeNoTx = LedParameter.LedActCfg.field.LedActModeNoTx_RadioOnLinkDown;
CurrentLedCfg.field.LedGPolarity = LedParameter.LedPolarityCfg.field.LedGPolarity_RadioOnLinkDown;
CurrentLedCfg.field.LedAPolarity = LedParameter.LedPolarityCfg.field.LedAPolarity_RadioOnLinkDown;
CurrentLedCfg.field.LedActPolarity = LedParameter.LedPolarityCfg.field.LedActPolarity_RadioOnLinkDown;
break;
case 0x60: // Radio on and link to G
CurrentLedCfg.field.LedGMode = LedParameter.LedAgCfg.field.LedGMode_RadioOnLinkG;
CurrentLedCfg.field.LedAMode = LedParameter.LedAgCfg.field.LedAMode_RadioOnLinkG;
CurrentLedCfg.field.LedActMode = LedParameter.LedActCfg.field.LedActMode_RadioOnLinkG;
CurrentLedCfg.field.LedActModeNoTx = LedParameter.LedActCfg.field.LedActModeNoTx_RadioOnLinkG;
CurrentLedCfg.field.LedGPolarity = LedParameter.LedPolarityCfg.field.LedGPolarity_RadioOnLinkG;
CurrentLedCfg.field.LedAPolarity = LedParameter.LedPolarityCfg.field.LedAPolarity_RadioOnLinkG;
CurrentLedCfg.field.LedActPolarity = LedParameter.LedPolarityCfg.field.LedActPolarity_RadioOnLinkG;
break;
case 0xa0: // Radio on and link to A
CurrentLedCfg.field.LedGMode = LedParameter.LedAgCfg.field.LedGMode_RadioOnLinkA;
CurrentLedCfg.field.LedAMode = LedParameter.LedAgCfg.field.LedAMode_RadioOnLinkA;
CurrentLedCfg.field.LedActMode = LedParameter.LedActCfg.field.LedActMode_RadioOnLinkA;
CurrentLedCfg.field.LedActModeNoTx = LedParameter.LedActCfg.field.LedActModeNoTx_RadioOnLinkA;
CurrentLedCfg.field.LedGPolarity = LedParameter.LedPolarityCfg.field.LedGPolarity_RadioOnLinkA;
CurrentLedCfg.field.LedAPolarity = LedParameter.LedPolarityCfg.field.LedAPolarity_RadioOnLinkA;
CurrentLedCfg.field.LedActPolarity = LedParameter.LedPolarityCfg.field.LedActPolarity_RadioOnLinkA;
break;
case 0x10: // WPS
if(LedParameter.LedMode == 0x04)
{
CurrentLedCfg.field.LedActPolarity = 0;
CurrentLedCfg.field.LedActMode = 1; // Force ACT to solid on/off
CurrentLedCfg.field.LedActMode = 0; // Force ACT to solid on/off
}
if(LedParameter.LedMode == 0x05)
{
CurrentLedCfg.field.LedActPolarity = 1;
CurrentLedCfg.field.LedActMode = 1; // Force ACT to solid on/off
CurrentLedCfg.field.LedActMode = 0; // Force ACT to solid on/off
}
break;
case 0x08:
if (LedParameter.LedMode == 2)
BlinkFor8sTimer = (8000 / LED_CHECK_INTERVAL);
break;
}
if(CheckTimerEbl==0)
{
memset(&LedCheckTimer, 0, sizeof(RALINK_TIMER_STRUCT));
RTMPInitTimer(pAd, &LedCheckTimer, GET_TIMER_FUNCTION(LedCtrlMain), pAd, TRUE);
RTMPSetTimer(&LedCheckTimer, LED_CHECK_INTERVAL);
CheckTimerEbl=1;
}
}
int RtmpAsicSendCommandToSwMcu(
IN RTMP_ADAPTER *pAd,
IN UCHAR Command,
IN UCHAR Token,
IN UCHAR Arg0,
IN UCHAR Arg1)
{
BBP_CSR_CFG_STRUC BbpCsr, BbpCsr2;
int j, k;
UINT16 Temp;
#ifdef LED_CONTROL_SUPPORT
PSWMCU_LED_CONTROL pSWMCULedCntl = &pAd->LedCntl.SWMCULedCntl;
#endif // LED_CONTROL_SUPPORT //
switch(Command)
{
case 0x80:
RTMP_IO_READ32(pAd, H2M_BBP_AGENT, &BbpCsr.word);
if ((BbpCsr.field.Busy != 1) || (BbpCsr.field.BBP_RW_MODE != 1))
DBGPRINT(RT_DEBUG_ERROR, ("error read write BBP 1\n"));
for (j=0; j<MAX_BUSY_COUNT; j++)
{
RTMP_IO_READ32(pAd, BBP_CSR_CFG, &BbpCsr2.word);
if (BbpCsr2.field.Busy == BUSY)
{
continue;
}
BbpCsr2.word = BbpCsr.word;
RTMP_IO_WRITE32(pAd, BBP_CSR_CFG, BbpCsr2.word);
if (BbpCsr.field.fRead == 1)
{
// read
for (k=0; k<MAX_BUSY_COUNT; k++)
{
RTMP_IO_READ32(pAd, BBP_CSR_CFG, &BbpCsr2.word);
if (BbpCsr2.field.Busy == IDLE)
break;
}
if (k == MAX_BUSY_COUNT)
DBGPRINT(RT_DEBUG_ERROR, ("error read write BBP 2\n"));
if ((BbpCsr2.field.Busy == IDLE) && (BbpCsr2.field.RegNum == BbpCsr.field.RegNum))
{
BbpCsr.field.Value = BbpCsr2.field.Value;
BbpCsr.field.Busy = IDLE;
RTMP_IO_WRITE32(pAd, H2M_BBP_AGENT, BbpCsr.word);
break;
}
}
else
{
//write
BbpCsr.field.Busy = IDLE;
RTMP_IO_WRITE32(pAd, H2M_BBP_AGENT, BbpCsr.word);
pAd->BbpWriteLatch[BbpCsr.field.RegNum] = BbpCsr2.field.Value;
break;
}
}
if (j == MAX_BUSY_COUNT)
{
DBGPRINT(RT_DEBUG_ERROR, ("error read write BBP 3\n"));
if (BbpCsr.field.Busy != IDLE)
{
BbpCsr.field.Busy = IDLE;
RTMP_IO_WRITE32(pAd, H2M_BBP_AGENT, BbpCsr.word);
}
}
break;
case 0x30:
break;
case 0x31:
break;
#ifdef LED_CONTROL_SUPPORT
#ifdef CONFIG_WIFI_LED_SHARE
case MCU_SET_WPS_LED_MODE:
pSWMCULedCntl->LedParameter.LedMode = Arg0;
pSWMCULedCntl->LinkStatus = Arg1;
SetWPSLinkStatus(pAd);
break;
#endif // CONFIG_WIFI_LED_SHARE //
case MCU_SET_LED_MODE:
pSWMCULedCntl->LedParameter.LedMode = Arg0;
pSWMCULedCntl->LinkStatus = Arg1;
SetLedLinkStatus(pAd);
break;
case MCU_SET_LED_GPIO_SIGNAL_CFG:
pSWMCULedCntl->GPIOPolarity = Arg1;
pSWMCULedCntl->SignalStrength = Arg0;
break;
case MCU_SET_LED_AG_CFG:
Temp = ((UINT16)Arg1 << 8) | (UINT16)Arg0;
NdisMoveMemory(&pSWMCULedCntl->LedParameter.LedAgCfg, &Temp, 2);
break;
case MCU_SET_LED_ACT_CFG:
Temp = ((UINT16)Arg1 << 8) | (UINT16)Arg0;
NdisMoveMemory(&pSWMCULedCntl->LedParameter.LedActCfg, &Temp, 2);
break;
case MCU_SET_LED_POLARITY:
Temp = ((UINT16)Arg1 << 8) | (UINT16)Arg0;
NdisMoveMemory(&pSWMCULedCntl->LedParameter.LedPolarityCfg, &Temp, 2);
break;
#endif // LED_CONTROL_SUPPORT //
// 2880-SW-MCU
#ifdef CONFIG_AP_SUPPORT
#ifdef DFS_SUPPORT
case 0x60:
if (Arg0 == 0 && Arg1 == 0)
{
ULONG Value;
pAd->CommonCfg.McuRadarCmd &= ~(RADAR_DETECTION);
if (pAd->CommonCfg.McuRadarCmd == DETECTION_STOP)
{
DBGPRINT(RT_DEBUG_TRACE, ("AsicSendCommandToMcu 0x60 ==> stop detection\n"));
#ifdef RTMP_RBUS_SUPPORT
unregister_tmr_service();
#else
BOOLEAN Cancelled;
RTMPCancelTimer(&pAd->CommonCfg.CSWatchDogTimer, &Cancelled);
#endif // RTMP_RBUS_SUPPORT //
RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
Value |= 0x04;
RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
}
}
else
{
if (!(pAd->CommonCfg.McuRadarCmd & RADAR_DETECTION))
{
pAd->CommonCfg.McuRadarPeriod = Arg0;
pAd->CommonCfg.McuRadarDetectPeriod = Arg1 & 0x1f;
pAd->CommonCfg.McuRadarCtsProtect = (Arg1 & 0x60) >> 5;
pAd->CommonCfg.McuRadarState = WAIT_CTS_BEING_SENT;
pAd->CommonCfg.McuRadarTick = pAd->CommonCfg.McuRadarPeriod;
pAd->CommonCfg.McuRadarDetectCount = 0;
RTMPPrepareRDCTSFrame(pAd, pAd->CurrentAddress, (pAd->CommonCfg.McuRadarDetectPeriod * 1000 + 100), pAd->CommonCfg.RtsRate, HW_DFS_CTS_BASE, IFS_SIFS);
if (pAd->CommonCfg.McuRadarCmd == DETECTION_STOP)
{
pAd->CommonCfg.McuRadarCmd |= RADAR_DETECTION;
pAd->CommonCfg.McuRadarProtection = 0;
#ifdef RTMP_RBUS_SUPPORT
request_tmr_service(1, &TimerCB, pAd);
#else
RTMPInitTimer(pAd, &pAd->CommonCfg.CSWatchDogTimer, GET_TIMER_FUNCTION(TimerCB), pAd, TRUE);
RTMPSetTimer(&pAd->CommonCfg.DFSWatchDogTimer, NEW_DFS_WATCH_DOG_TIME);
#endif // DFS_ARCH_TEAM //
}
else
pAd->CommonCfg.McuRadarCmd |= RADAR_DETECTION;
#ifdef RTMP_RBUS_SUPPORT
request_tmr_service(1, &TimerCB, pAd);
#else
RTMPInitTimer(pAd, &pAd->CommonCfg.CSWatchDogTimer, GET_TIMER_FUNCTION(TimerCB), pAd, TRUE);
RTMPSetTimer(&pAd->CommonCfg.DFSWatchDogTimer, NEW_DFS_WATCH_DOG_TIME);
#endif // DFS_ARCH_TEAM //
}
else
{
pAd->CommonCfg.McuRadarPeriod = Arg0;
pAd->CommonCfg.McuRadarDetectPeriod = Arg1 & 0x1f;
pAd->CommonCfg.McuRadarCtsProtect = (Arg1 & 0x60) >> 5;
RTMPPrepareRDCTSFrame(pAd, pAd->CurrentAddress, (pAd->CommonCfg.McuRadarDetectPeriod * 1000 + 100), pAd->CommonCfg.RtsRate, HW_DFS_CTS_BASE, IFS_SIFS);
}
}
INT CFG80211DRV_IoctlHandle(
IN VOID *pAdSrc,
IN RTMP_IOCTL_INPUT_STRUCT *wrq,
IN INT cmd,
IN USHORT subcmd,
IN VOID *pData,
IN ULONG Data)
{
PRTMP_ADAPTER pAd = (PRTMP_ADAPTER)pAdSrc;
switch(cmd)
{
case CMD_RTPRIV_IOCTL_80211_START:
case CMD_RTPRIV_IOCTL_80211_END:
/* nothing to do */
break;
case CMD_RTPRIV_IOCTL_80211_CB_GET:
*(VOID **)pData = (VOID *)(pAd->pCfg80211_CB);
break;
case CMD_RTPRIV_IOCTL_80211_CB_SET:
pAd->pCfg80211_CB = pData;
break;
case CMD_RTPRIV_IOCTL_80211_CHAN_SET:
if (CFG80211DRV_OpsSetChannel(pAd, pData) != TRUE)
return NDIS_STATUS_FAILURE;
break;
case CMD_RTPRIV_IOCTL_80211_VIF_CHG:
if (CFG80211DRV_OpsChgVirtualInf(pAd, pData, Data) != TRUE)
return NDIS_STATUS_FAILURE;
break;
case CMD_RTPRIV_IOCTL_80211_SCAN:
CFG80211DRV_OpsScan(pAd);
break;
case CMD_RTPRIV_IOCTL_80211_IBSS_JOIN:
CFG80211DRV_OpsJoinIbss(pAd, pData);
break;
case CMD_RTPRIV_IOCTL_80211_STA_LEAVE:
CFG80211DRV_OpsLeave(pAd);
break;
case CMD_RTPRIV_IOCTL_80211_STA_GET:
if (CFG80211DRV_StaGet(pAd, pData) != TRUE)
return NDIS_STATUS_FAILURE;
break;
case CMD_RTPRIV_IOCTL_80211_KEY_ADD:
CFG80211DRV_KeyAdd(pAd, pData);
break;
case CMD_RTPRIV_IOCTL_80211_KEY_DEFAULT_SET:
break;
case CMD_RTPRIV_IOCTL_80211_CONNECT_TO:
CFG80211DRV_Connect(pAd, pData);
break;
#ifdef RFKILL_HW_SUPPORT
case CMD_RTPRIV_IOCTL_80211_RFKILL:
{
UINT32 data = 0;
BOOLEAN active;
/* Read GPIO pin2 as Hardware controlled radio state */
RTMP_IO_READ32(pAd, GPIO_CTRL_CFG, &data);
active = !!(data & 0x04);
if (!active)
{
RTMPSetLED(pAd, LED_RADIO_OFF);
*(UINT8 *)pData = 0;
}
else
*(UINT8 *)pData = 1;
}
break;
#endif /* RFKILL_HW_SUPPORT */
case CMD_RTPRIV_IOCTL_80211_REG_NOTIFY_TO:
CFG80211DRV_RegNotify(pAd, pData);
break;
case CMD_RTPRIV_IOCTL_80211_UNREGISTER:
CFG80211_UnRegister(pAd, pData);
break;
case CMD_RTPRIV_IOCTL_80211_BANDINFO_GET:
{
CFG80211_BAND *pBandInfo = (CFG80211_BAND *)pData;
CFG80211_BANDINFO_FILL(pAd, pBandInfo);
}
break;
case CMD_RTPRIV_IOCTL_80211_SURVEY_GET:
CFG80211DRV_SurveyGet(pAd, pData);
break;
case CMD_RTPRIV_IOCTL_80211_EXTRA_IES_SET:
CFG80211DRV_OpsExtraIesSet(pAd);
break;
case CMD_RTPRIV_IOCTL_80211_REMAIN_ON_CHAN_SET:
CFG80211DRV_OpsRemainOnChannel(pAd, pData, Data);
break;
case CMD_RTPRIV_IOCTL_80211_CANCEL_REMAIN_ON_CHAN_SET:
CFG80211DRV_OpsCancelRemainOnChannel(pAd, Data);
break;
case CMD_RTPRIV_IOCTL_80211_MGMT_FRAME_REG:
if (Data)
pAd->Cfg80211ProbeReqCount++;
else
{
pAd->Cfg80211ProbeReqCount--;
}
if (pAd->Cfg80211ProbeReqCount > 0)
pAd->Cfg80211RegisterProbeReqFrame = TRUE;
else
pAd->Cfg80211RegisterProbeReqFrame = FALSE;
DBGPRINT(RT_DEBUG_ERROR, ("pAd->Cfg80211RegisterProbeReqFrame=%d[%d]\n",pAd->Cfg80211RegisterProbeReqFrame, pAd->Cfg80211ProbeReqCount));
break;
case CMD_RTPRIV_IOCTL_80211_ACTION_FRAME_REG:
if (Data)
pAd->Cfg80211ActionCount++;
else
pAd->Cfg80211ActionCount--;
if (pAd->Cfg80211ActionCount > 0)
pAd->Cfg80211RegisterActionFrame = TRUE;
else
pAd->Cfg80211RegisterActionFrame = FALSE;
DBGPRINT(RT_DEBUG_TRACE, ("pAd->Cfg80211RegisterActionFrame=%d [%d]\n",pAd->Cfg80211RegisterActionFrame, pAd->Cfg80211ActionCount));
break;
case CMD_RTPRIV_IOCTL_80211_CHANNEL_LOCK:
//pAd->CommonCfg.CentralChannel = Data;
//DBGPRINT(RT_DEBUG_TRACE, ("CMD_RTPRIV_IOCTL_80211_CHANNEL_LOCK %d\n", Data));
if (pAd->CommonCfg.Channel != Data)
{
pAd->CommonCfg.Channel= Data;
AsicSwitchChannel(pAd, pAd->CommonCfg.Channel, FALSE);
AsicLockChannel(pAd, pAd->CommonCfg.Channel);
}
break;
case CMD_RTPRIV_IOCTL_80211_MGMT_FRAME_SEND:
/* send a managment frame */
pAd->TxStatusInUsed = TRUE;
pAd->TxStatusSeq = pAd->Sequence;
if (pData != NULL)
{
#ifdef WFD_SUPPORT
if (pAd->StaCfg.WfdCfg.bSuppInsertWfdIe)
{
PP2P_PUBLIC_FRAME pFrame = (PP2P_PUBLIC_FRAME)pData;
ULONG WfdIeLen = 0, WfdIeBitmap = 0;
switch (pFrame->p80211Header.FC.SubType)
{
case SUBTYPE_BEACON:
case SUBTYPE_PROBE_REQ:
case SUBTYPE_ASSOC_REQ:
case SUBTYPE_REASSOC_REQ:
WfdIeBitmap = (0x1 << SUBID_WFD_DEVICE_INFO) | (0x1 << SUBID_WFD_ASSOCIATED_BSSID) |
(0x1 << SUBID_WFD_COUPLED_SINK_INFO);
break;
case SUBTYPE_ASSOC_RSP:
case SUBTYPE_REASSOC_RSP:
WfdIeBitmap = (0x1 << SUBID_WFD_DEVICE_INFO) | (0x1 << SUBID_WFD_ASSOCIATED_BSSID) |
(0x1 << SUBID_WFD_COUPLED_SINK_INFO) | (0x1 << SUBID_WFD_SESSION_INFO);
break;
case SUBTYPE_PROBE_RSP:
WfdIeBitmap = (0x1 << SUBID_WFD_DEVICE_INFO) | (0x1 << SUBID_WFD_ASSOCIATED_BSSID) |
(0x1 << SUBID_WFD_COUPLED_SINK_INFO) | (0x1 << SUBID_WFD_SESSION_INFO);
break;
case SUBTYPE_ACTION:
if ((pFrame->Category == CATEGORY_PUBLIC) &&
(pFrame->Action == ACTION_WIFI_DIRECT))
{
switch (pFrame->Subtype)
{
case GO_NEGOCIATION_REQ:
case GO_NEGOCIATION_RSP:
case GO_NEGOCIATION_CONFIRM:
case P2P_PROVISION_REQ:
WfdIeBitmap = (0x1 << SUBID_WFD_DEVICE_INFO) | (0x1 << SUBID_WFD_ASSOCIATED_BSSID) |
(0x1 << SUBID_WFD_COUPLED_SINK_INFO);
break;
case P2P_INVITE_REQ:
case P2P_INVITE_RSP:
case P2P_PROVISION_RSP:
WfdIeBitmap = (0x1 << SUBID_WFD_DEVICE_INFO) | (0x1 << SUBID_WFD_ASSOCIATED_BSSID) |
(0x1 << SUBID_WFD_COUPLED_SINK_INFO) | (0x1 << SUBID_WFD_SESSION_INFO);
break;
}
}
break;
}
if (WfdIeBitmap > 0)
{
PUCHAR pOutBuffer;
NDIS_STATUS NStatus;
NStatus = MlmeAllocateMemory(pAd, &pOutBuffer); /* Get an unused nonpaged memory */
if (NStatus != NDIS_STATUS_SUCCESS)
DBGPRINT(RT_DEBUG_ERROR, ("%s: Allocate memory fail!!!\n", __FUNCTION__));
else
{
memcpy(pOutBuffer, pData, Data);
WfdMakeWfdIE(pAd, WfdIeBitmap, pOutBuffer + Data, &WfdIeLen);
Data += WfdIeLen;
if (pAd->pTxStatusBuf != NULL)
os_free_mem(NULL, pAd->pTxStatusBuf);
os_alloc_mem(NULL, (UCHAR **)&pAd->pTxStatusBuf, Data);
if (pAd->pTxStatusBuf != NULL)
{
NdisCopyMemory(pAd->pTxStatusBuf, pOutBuffer, Data);
pAd->TxStatusBufLen = Data;
}
else
{
DBGPRINT(RT_DEBUG_TRACE, ("YF_TX_STATUS: MEM ALLOC ERROR\n"));
MlmeFreeMemory(pAd, pOutBuffer);
return NDIS_STATUS_FAILURE;
}
MiniportMMRequest(pAd, 0, pOutBuffer, Data);
}
}
}
else
#endif /* WFD_SUPPORT */
{
if (pAd->pTxStatusBuf != NULL)
os_free_mem(NULL, pAd->pTxStatusBuf);
os_alloc_mem(NULL, (UCHAR **)&pAd->pTxStatusBuf, Data);
if (pAd->pTxStatusBuf != NULL)
{
NdisCopyMemory(pAd->pTxStatusBuf, pData, Data);
pAd->TxStatusBufLen = Data;
}
else
{
DBGPRINT(RT_DEBUG_TRACE, ("YF_TX_STATUS: MEM ALLOC ERROR\n"));
return NDIS_STATUS_FAILURE;
}
// pAd->pTxStatusBuf
// pAd->TxStatusBufLen = Data
//DBGPRINT(RT_DEBUG_TRACE, ("YF_TX_STATUS: send %d\n", pAd->TxStatusSeq));
MiniportMMRequest(pAd, 0, pData, Data);
//DBGPRINT(RT_DEBUG_TRACE, ("YF_TX_STATUS: sent %d\n", pAd->TxStatusSeq));
}
}
break;
case CMD_RTPRIV_IOCTL_80211_REMAIN_ON_CHAN_DUR_TIMER_INIT:
DBGPRINT(RT_DEBUG_TRACE, ("ROC TIMER INIT\n"));
RTMPInitTimer(pAd, &pAd->Cfg80211RemainOnChannelDurationTimer, GET_TIMER_FUNCTION(RemainOnChannelTimeout), pAd, FALSE);
break;
case CMD_RTPRIV_IOCTL_80211_CHANNEL_LIST_SET:
DBGPRINT(RT_DEBUG_TRACE, ("CMD_RTPRIV_IOCTL_80211_CHANNEL_LIST_SET: %d\n", Data));
UINT32 *pChanList = (UINT32 *) pData;
if (pChanList != NULL)
{
if (pAd->pCfg80211ChanList != NULL)
os_free_mem(NULL, pAd->pCfg80211ChanList);
os_alloc_mem(NULL, (UINT32 **)&pAd->pCfg80211ChanList, sizeof(UINT32 *) * Data);
if (pAd->pCfg80211ChanList != NULL)
{
NdisCopyMemory(pAd->pCfg80211ChanList, pChanList, sizeof(UINT32 *) * Data);
pAd->Cfg80211ChanListLan = Data;
}
else
{
return NDIS_STATUS_FAILURE;
}
}
break;
case CMD_RTPRIV_IOCTL_80211_BEACON_SET:
CFG80211DRV_OpsBeaconSet(pAd, pData, 0);
break;
case CMD_RTPRIV_IOCTL_80211_BEACON_ADD:
CFG80211DRV_OpsBeaconSet(pAd, pData, 1);
break;
case CMD_RTPRIV_IOCTL_80211_BEACON_DEL:
#ifdef WFD_SUPPORT
pAd->StaCfg.WfdCfg.bSuppGoOn = FALSE;
#endif /* WFD_SUPPORT */
break;
case CMD_RTPRIV_IOCTL_80211_CHANGE_BSS_PARM:
CFG80211DRV_OpsChangeBssParm(pAd, pData);
break;
case CMD_RTPRIV_IOCTL_80211_AP_PROBE_RSP:
if (pData != NULL)
{
if (pAd->pCfg80211RrobeRsp != NULL)
os_free_mem(NULL, pAd->pCfg80211RrobeRsp);
os_alloc_mem(NULL, (UCHAR **)&pAd->pCfg80211RrobeRsp, Data);
if (pAd->pCfg80211RrobeRsp != NULL)
{
NdisCopyMemory(pAd->pCfg80211RrobeRsp, pData, Data);
pAd->Cfg80211AssocRspLen = Data;
}
else
{
DBGPRINT(RT_DEBUG_TRACE, ("YF_AP: MEM ALLOC ERROR\n"));
return NDIS_STATUS_FAILURE;
}
}
else
return NDIS_STATUS_FAILURE;
break;
case CMD_RTPRIV_IOCTL_80211_PORT_SECURED:
CFG80211_StaPortSecured(pAd, pData, Data);
break;
case CMD_RTPRIV_IOCTL_80211_AP_STA_DEL:
CFG80211_ApStaDel(pAd, pData);
break;
case CMD_RTPRIV_IOCTL_80211_BITRATE_SET:
// pAd->CommonCfg.PhyMode = PHY_11AN_MIXED;
// RTMPSetPhyMode(pAd, pAd->CommonCfg.PhyMode);
//Set_WirelessMode_Proc(pAd, PHY_11AGN_MIXED);
break;
#ifdef RT_P2P_SPECIFIC_WIRELESS_EVENT
case CMD_RTPRIV_IOCTL_80211_SEND_WIRELESS_EVENT:
CFG80211_SendWirelessEvent(pAd, pData);
break;
#endif /* RT_P2P_SPECIFIC_WIRELESS_EVENT */
default:
return NDIS_STATUS_FAILURE;
}
return NDIS_STATUS_SUCCESS;
}
MAC_TABLE_ENTRY *RTMPInsertRepeaterMacEntry(
IN RTMP_ADAPTER *pAd,
IN UCHAR *pAddr,
IN struct wifi_dev *wdev,
IN UCHAR apIdx,
IN UCHAR cliIdx,
IN BOOLEAN CleanAll)
{
UCHAR HashIdx;
int i;
MAC_TABLE_ENTRY *pEntry = NULL, *pCurrEntry;
BOOLEAN Cancelled;
/* if FULL, return*/
if (pAd->MacTab.Size >= MAX_LEN_OF_MAC_TABLE)
return NULL;
/* allocate one MAC entry*/
NdisAcquireSpinLock(&pAd->MacTabLock);
i = (MAX_NUMBER_OF_MAC + ((MAX_EXT_MAC_ADDR_SIZE + 1) * (apIdx - MIN_NET_DEVICE_FOR_APCLI)));
if (cliIdx != 0xFF)
i = i + cliIdx + 1;
/* pick up the first available vacancy*/
pEntry = &pAd->MacTab.Content[i];
if (pEntry == NULL)
{
printk("###### %s pEntry == NULL, i = %d\n", __func__, i);
}
if (pEntry && IS_ENTRY_NONE(pEntry))
{
/* ENTRY PREEMPTION: initialize the entry */
if (pEntry->RetryTimer.Valid)
RTMPCancelTimer(&pEntry->RetryTimer, &Cancelled);
if (pEntry->EnqueueStartForPSKTimer.Valid)
RTMPCancelTimer(&pEntry->EnqueueStartForPSKTimer, &Cancelled);
NdisZeroMemory(pEntry, sizeof(MAC_TABLE_ENTRY));
if (CleanAll == TRUE)
{
pEntry->MaxSupportedRate = RATE_11;
pEntry->CurrTxRate = RATE_11;
NdisZeroMemory(pEntry, sizeof(MAC_TABLE_ENTRY));
pEntry->PairwiseKey.KeyLen = 0;
pEntry->PairwiseKey.CipherAlg = CIPHER_NONE;
}
SET_ENTRY_APCLI(pEntry);
pEntry->wdev = wdev;
pEntry->wcid = i;
pEntry->isCached = FALSE;
pEntry->bIAmBadAtheros = FALSE;
RTMPInitTimer(pAd, &pEntry->EnqueueStartForPSKTimer, GET_TIMER_FUNCTION(EnqueueStartForPSKExec), pEntry, FALSE);
RTMPInitTimer(pAd, &pEntry->RetryTimer, GET_TIMER_FUNCTION(WPARetryExec), pEntry, FALSE);
#ifdef TXBF_SUPPORT
if (pAd->chipCap.FlgHwTxBfCap)
RTMPInitTimer(pAd, &pEntry->eTxBfProbeTimer, GET_TIMER_FUNCTION(eTxBfProbeTimerExec), pEntry, FALSE);
#endif /* TXBF_SUPPORT */
pEntry->pAd = pAd;
pEntry->CMTimerRunning = FALSE;
pEntry->EnqueueEapolStartTimerRunning = EAPOL_START_DISABLE;
pEntry->RSNIE_Len = 0;
NdisZeroMemory(pEntry->R_Counter, sizeof(pEntry->R_Counter));
pEntry->ReTryCounter = PEER_MSG1_RETRY_TIMER_CTR;
pEntry->apidx = (apIdx - MIN_NET_DEVICE_FOR_APCLI);
pEntry->pMbss = &pAd->ApCfg.MBSSID[pEntry->apidx];
pEntry->AuthMode = pAd->ApCfg.ApCliTab[pEntry->apidx].wdev.AuthMode;
pEntry->WepStatus = pAd->ApCfg.ApCliTab[pEntry->apidx].wdev.WepStatus;
pEntry->wdev_idx = pEntry->apidx;
if (pEntry->AuthMode < Ndis802_11AuthModeWPA)
{
pEntry->WpaState = AS_NOTUSE;
pEntry->PrivacyFilter = Ndis802_11PrivFilterAcceptAll;
}
else
{
pEntry->WpaState = AS_PTKSTART;
pEntry->PrivacyFilter = Ndis802_11PrivFilter8021xWEP;
}
pEntry->GTKState = REKEY_NEGOTIATING;
pEntry->PairwiseKey.KeyLen = 0;
pEntry->PairwiseKey.CipherAlg = CIPHER_NONE;
pEntry->PortSecured = WPA_802_1X_PORT_NOT_SECURED;
pEntry->PMKID_CacheIdx = ENTRY_NOT_FOUND;
COPY_MAC_ADDR(pEntry->Addr, pAddr);
//COPY_MAC_ADDR(pEntry->HdrAddr1, pAddr);
//COPY_MAC_ADDR(pEntry->HdrAddr2, pAd->ApCfg.ApCliTab[pEntry->apidx].CurrentAddress);
//COPY_MAC_ADDR(pEntry->HdrAddr3, pAddr);
COPY_MAC_ADDR(pEntry->bssid, pAddr);
pEntry->Sst = SST_NOT_AUTH;
pEntry->AuthState = AS_NOT_AUTH;
pEntry->Aid = (USHORT)i; /*0;*/
pEntry->CapabilityInfo = 0;
pEntry->PsMode = PWR_ACTIVE;
pEntry->PsQIdleCount = 0;
pEntry->NoDataIdleCount = 0;
pEntry->AssocDeadLine = MAC_TABLE_ASSOC_TIMEOUT;
pEntry->ContinueTxFailCnt = 0;
pEntry->TimeStamp_toTxRing = 0;
InitializeQueueHeader(&pEntry->PsQueue);
#ifdef PS_ENTRY_MAITENANCE
pEntry->continuous_ps_count = 0;
#endif /* PS_ENTRY_MAITENANCE */
pAd->MacTab.Size ++;
/* Set the security mode of this entry as OPEN-NONE in ASIC */
RTMP_REMOVE_PAIRWISE_KEY_ENTRY(pAd, (UCHAR)i);
/* Add this entry into ASIC RX WCID search table */
RTMP_STA_ENTRY_ADD(pAd, pEntry);
#ifdef WSC_AP_SUPPORT
pEntry->bWscCapable = FALSE;
pEntry->Receive_EapolStart_EapRspId = 0;
#endif /* WSC_AP_SUPPORT */
#ifdef TXBF_SUPPORT
if (pAd->chipCap.FlgHwTxBfCap)
NdisAllocateSpinLock(pAd, &pEntry->TxSndgLock);
#endif /* TXBF_SUPPORT */
#ifdef PEER_DELBA_TX_ADAPT
Peer_DelBA_Tx_Adapt_Init(pAd, pEntry);
#endif /* PEER_DELBA_TX_ADAPT */
#ifdef DROP_MASK_SUPPORT
drop_mask_init_per_client(pAd, pEntry);
#endif /* DROP_MASK_SUPPORT */
#ifdef FIFO_EXT_SUPPORT
if (pAd->chipCap.FlgHwFifoExtCap)
{
UCHAR tblIdx;
if ((cliIdx != 0xFF) && IsFifoExtTblAvailable(pAd, &tblIdx))
FifoExtTblUpdateEntry(pAd, tblIdx, i);
}
#endif
DBGPRINT(RT_DEBUG_TRACE, ("%s - allocate entry #%d, Aid = %d, Wcid = %d Addr(%02x:%02x:%02x:%02x:%02x:%02x) Total= %d\n",__FUNCTION__, i,
pEntry->Aid, pEntry->wcid, PRINT_MAC(pEntry->Addr), pAd->MacTab.Size));
}
else
{
DBGPRINT(RT_DEBUG_ERROR, ("%s - exist entry #%d, Aid = %d, Total= %d\n", __FUNCTION__, i, pEntry->Aid, pAd->MacTab.Size));
NdisReleaseSpinLock(&pAd->MacTabLock);
return pEntry;
}
/* add this MAC entry into HASH table */
if (pEntry)
{
pEntry->pNext = NULL;
HashIdx = MAC_ADDR_HASH_INDEX(pAddr);
if (pAd->MacTab.Hash[HashIdx] == NULL)
{
pAd->MacTab.Hash[HashIdx] = pEntry;
}
else
{
pCurrEntry = pAd->MacTab.Hash[HashIdx];
while (pCurrEntry->pNext != NULL)
pCurrEntry = pCurrEntry->pNext;
pCurrEntry->pNext = pEntry;
}
}
NdisReleaseSpinLock(&pAd->MacTabLock);
return pEntry;
}
/*
* generate ADDBA request to
* set up BA agreement
*/
VOID BAOriSessionSetUp(
IN PRTMP_ADAPTER pAd,
IN MAC_TABLE_ENTRY *pEntry,
IN UCHAR TID,
IN USHORT TimeOut,
IN ULONG DelayTime,
IN BOOLEAN isForced)
{
//MLME_ADDBA_REQ_STRUCT AddbaReq;
BA_ORI_ENTRY *pBAEntry = NULL;
USHORT Idx;
BOOLEAN Cancelled;
if ((pAd->CommonCfg.BACapability.field.AutoBA != TRUE) && (isForced == FALSE))
return;
// if this entry is limited to use legacy tx mode, it doesn't generate BA.
if (RTMPStaFixedTxMode(pAd, pEntry) != FIXED_TXMODE_HT)
return;
if ((pEntry->BADeclineBitmap & (1<<TID)) && (isForced == FALSE))
{
// try again after 3 secs
DelayTime = 3000;
// DBGPRINT(RT_DEBUG_TRACE, ("DeCline BA from Peer\n"));
// return;
}
Idx = pEntry->BAOriWcidArray[TID];
if (Idx == 0)
{
// allocate a BA session
pBAEntry = BATableAllocOriEntry(pAd, &Idx);
if (pBAEntry == NULL)
{
DBGPRINT(RT_DEBUG_TRACE,("ADDBA - MlmeADDBAAction() allocate BA session failed \n"));
return;
}
}
else
{
pBAEntry =&pAd->BATable.BAOriEntry[Idx];
}
if (pBAEntry->ORI_BA_Status >= Originator_WaitRes)
{
return;
}
pEntry->BAOriWcidArray[TID] = Idx;
// Initialize BA session
pBAEntry->ORI_BA_Status = Originator_WaitRes;
pBAEntry->Wcid = pEntry->Aid;
pBAEntry->BAWinSize = pAd->CommonCfg.BACapability.field.RxBAWinLimit;
pBAEntry->Sequence = BA_ORI_INIT_SEQ;
pBAEntry->Token = 1; // (2008-01-21) Jan Lee recommends it - this token can't be 0
pBAEntry->TID = TID;
pBAEntry->TimeOutValue = TimeOut;
pBAEntry->pAdapter = pAd;
if (!(pEntry->TXBAbitmap & (1<<TID)))
{
RTMPInitTimer(pAd, &pBAEntry->ORIBATimer, GET_TIMER_FUNCTION(BAOriSessionSetupTimeout), pBAEntry, FALSE);
}
else
RTMPCancelTimer(&pBAEntry->ORIBATimer, &Cancelled);
// set timer to send ADDBA request
RTMPSetTimer(&pBAEntry->ORIBATimer, DelayTime);
}
/*
* generate ADDBA request to
* set up BA agreement
*/
void BAOriSessionSetUp(struct rt_rtmp_adapter *pAd,
struct rt_mac_table_entry *pEntry,
u8 TID,
u16 TimeOut,
unsigned long DelayTime, IN BOOLEAN isForced)
{
/*struct rt_mlme_addba_req AddbaReq; */
struct rt_ba_ori_entry *pBAEntry = NULL;
u16 Idx;
BOOLEAN Cancelled;
if ((pAd->CommonCfg.BACapability.field.AutoBA != TRUE)
&& (isForced == FALSE))
return;
/* if this entry is limited to use legacy tx mode, it doesn't generate BA. */
if (RTMPStaFixedTxMode(pAd, pEntry) != FIXED_TXMODE_HT)
return;
if ((pEntry->BADeclineBitmap & (1 << TID)) && (isForced == FALSE)) {
/* try again after 3 secs */
DelayTime = 3000;
/* DBGPRINT(RT_DEBUG_TRACE, ("DeCline BA from Peer\n")); */
/* return; */
}
Idx = pEntry->BAOriWcidArray[TID];
if (Idx == 0) {
/* allocate a BA session */
pBAEntry = BATableAllocOriEntry(pAd, &Idx);
if (pBAEntry == NULL) {
DBGPRINT(RT_DEBUG_TRACE,
("ADDBA - MlmeADDBAAction() allocate BA session failed \n"));
return;
}
} else {
pBAEntry = &pAd->BATable.BAOriEntry[Idx];
}
if (pBAEntry->ORI_BA_Status >= Originator_WaitRes) {
return;
}
pEntry->BAOriWcidArray[TID] = Idx;
/* Initialize BA session */
pBAEntry->ORI_BA_Status = Originator_WaitRes;
pBAEntry->Wcid = pEntry->Aid;
pBAEntry->BAWinSize = pAd->CommonCfg.BACapability.field.RxBAWinLimit;
pBAEntry->Sequence = BA_ORI_INIT_SEQ;
pBAEntry->Token = 1; /* (2008-01-21) Jan Lee recommends it - this token can't be 0 */
pBAEntry->TID = TID;
pBAEntry->TimeOutValue = TimeOut;
pBAEntry->pAdapter = pAd;
if (!(pEntry->TXBAbitmap & (1 << TID))) {
RTMPInitTimer(pAd, &pBAEntry->ORIBATimer,
GET_TIMER_FUNCTION(BAOriSessionSetupTimeout),
pBAEntry, FALSE);
} else
RTMPCancelTimer(&pBAEntry->ORIBATimer, &Cancelled);
/* set timer to send ADDBA request */
RTMPSetTimer(&pBAEntry->ORIBATimer, DelayTime);
}
MAC_TABLE_ENTRY *MacTableInsertEntry(
IN PRTMP_ADAPTER pAd,
IN PUCHAR pAddr,
IN UCHAR apidx,
IN UCHAR OpMode,
IN BOOLEAN CleanAll)
{
UCHAR HashIdx;
int i, FirstWcid;
MAC_TABLE_ENTRY *pEntry = NULL, *pCurrEntry;
/* USHORT offset;*/
/* ULONG addr;*/
BOOLEAN Cancelled;
/* if FULL, return*/
if (pAd->MacTab.Size >= MAX_LEN_OF_MAC_TABLE)
return NULL;
FirstWcid = 1;
/* allocate one MAC entry*/
NdisAcquireSpinLock(&pAd->MacTabLock);
for (i = FirstWcid; i< MAX_LEN_OF_MAC_TABLE; i++) /* skip entry#0 so that "entry index == AID" for fast lookup*/
{
/* pick up the first available vacancy*/
if (IS_ENTRY_NONE(&pAd->MacTab.Content[i]))
{
pEntry = &pAd->MacTab.Content[i];
/* ENTRY PREEMPTION: initialize the entry */
RTMPCancelTimer(&pEntry->RetryTimer, &Cancelled);
RTMPCancelTimer(&pEntry->EnqueueStartForPSKTimer, &Cancelled);
NdisZeroMemory(pEntry, sizeof(MAC_TABLE_ENTRY));
if (CleanAll == TRUE)
{
pEntry->MaxSupportedRate = RATE_11;
pEntry->CurrTxRate = RATE_11;
NdisZeroMemory(pEntry, sizeof(MAC_TABLE_ENTRY));
pEntry->PairwiseKey.KeyLen = 0;
pEntry->PairwiseKey.CipherAlg = CIPHER_NONE;
}
do
{
#ifdef CONFIG_AP_SUPPORT
#ifdef APCLI_SUPPORT
if (apidx >= MIN_NET_DEVICE_FOR_APCLI)
{
SET_ENTRY_APCLI(pEntry);
pEntry->isCached = FALSE;
break;
}
#endif /* APCLI_SUPPORT */
#ifdef WDS_SUPPORT
if (apidx >= MIN_NET_DEVICE_FOR_WDS)
{
SET_ENTRY_WDS(pEntry);
pEntry->isCached = FALSE;
break;
}
#endif /* WDS_SUPPORT */
#endif /* CONFIG_AP_SUPPORT */
#ifdef CONFIG_AP_SUPPORT
IF_DEV_CONFIG_OPMODE_ON_AP(pAd)
{ /* be a regular-entry*/
if ((apidx < pAd->ApCfg.BssidNum) &&
(apidx < MAX_MBSSID_NUM(pAd)) &&
((apidx < HW_BEACON_MAX_NUM)) &&
(pAd->ApCfg.MBSSID[apidx].MaxStaNum != 0) &&
(pAd->ApCfg.MBSSID[apidx].StaCount >= pAd->ApCfg.MBSSID[apidx].MaxStaNum))
{
DBGPRINT(RT_DEBUG_WARN, ("%s: The connection table is full in ra%d.\n", __FUNCTION__, apidx));
NdisReleaseSpinLock(&pAd->MacTabLock);
return NULL;
}
}
#endif /* CONFIG_AP_SUPPORT */
SET_ENTRY_CLIENT(pEntry);
} while (FALSE);
pEntry->bIAmBadAtheros = FALSE;
RTMPInitTimer(pAd, &pEntry->EnqueueStartForPSKTimer, GET_TIMER_FUNCTION(EnqueueStartForPSKExec), pEntry, FALSE);
#ifdef CONFIG_AP_SUPPORT
IF_DEV_CONFIG_OPMODE_ON_AP(pAd)
{
if (IS_ENTRY_CLIENT(pEntry)) /* Only Clent entry need the retry timer.*/
{
RTMPInitTimer(pAd, &pEntry->RetryTimer, GET_TIMER_FUNCTION(WPARetryExec), pEntry, FALSE);
/* RTMP_OS_Init_Timer(pAd, &pEntry->RetryTimer, GET_TIMER_FUNCTION(WPARetryExec), pAd);*/
}
#ifdef APCLI_SUPPORT
else if (IS_ENTRY_APCLI(pEntry))
{
RTMPInitTimer(pAd, &pEntry->RetryTimer, GET_TIMER_FUNCTION(WPARetryExec), pEntry, FALSE);
}
#endif /* APCLI_SUPPORT */
}
#endif /* CONFIG_AP_SUPPORT */
#ifdef TXBF_SUPPORT
if (pAd->chipCap.FlgHwTxBfCap)
RTMPInitTimer(pAd, &pEntry->eTxBfProbeTimer, GET_TIMER_FUNCTION(eTxBfProbeTimerExec), pEntry, FALSE);
#endif /* TXBF_SUPPORT */
pEntry->pAd = pAd;
pEntry->CMTimerRunning = FALSE;
pEntry->EnqueueEapolStartTimerRunning = EAPOL_START_DISABLE;
pEntry->RSNIE_Len = 0;
NdisZeroMemory(pEntry->R_Counter, sizeof(pEntry->R_Counter));
pEntry->ReTryCounter = PEER_MSG1_RETRY_TIMER_CTR;
if (IS_ENTRY_MESH(pEntry))
pEntry->apidx = (apidx - MIN_NET_DEVICE_FOR_MESH);
else if (IS_ENTRY_APCLI(pEntry))
pEntry->apidx = (apidx - MIN_NET_DEVICE_FOR_APCLI);
else if (IS_ENTRY_WDS(pEntry))
pEntry->apidx = (apidx - MIN_NET_DEVICE_FOR_WDS);
else
pEntry->apidx = apidx;
#ifdef CONFIG_AP_SUPPORT
if ((apidx < pAd->ApCfg.BssidNum) &&
(apidx < MAX_MBSSID_NUM(pAd)) &&
(apidx < HW_BEACON_MAX_NUM))
pEntry->pMbss = &pAd->ApCfg.MBSSID[pEntry->apidx];
else
pEntry->pMbss = NULL;
#endif /* CONFIG_AP_SUPPORT */
do
{
#ifdef CONFIG_AP_SUPPORT
#ifdef APCLI_SUPPORT
if (IS_ENTRY_APCLI(pEntry))
{
pEntry->AuthMode = pAd->ApCfg.ApCliTab[pEntry->apidx].AuthMode;
pEntry->WepStatus = pAd->ApCfg.ApCliTab[pEntry->apidx].WepStatus;
if (pEntry->AuthMode < Ndis802_11AuthModeWPA)
{
pEntry->WpaState = AS_NOTUSE;
pEntry->PrivacyFilter = Ndis802_11PrivFilterAcceptAll;
}
else
{
pEntry->WpaState = AS_PTKSTART;
pEntry->PrivacyFilter = Ndis802_11PrivFilter8021xWEP;
}
pEntry->MatchAPCLITabIdx = pEntry->apidx;
break;
}
#endif /* APCLI_SUPPORT */
#ifdef WDS_SUPPORT
if (IS_ENTRY_WDS(pEntry))
{
pEntry->AuthMode = Ndis802_11AuthModeOpen;
pEntry->WepStatus = Ndis802_11EncryptionDisabled;
pEntry->MatchWDSTabIdx = pEntry->apidx;
break;
}
#endif /* WDS_SUPPORT */
IF_DEV_CONFIG_OPMODE_ON_AP(pAd)
{
MBSS_MR_APIDX_SANITY_CHECK(pAd, apidx);
pEntry->AuthMode = pAd->ApCfg.MBSSID[apidx].AuthMode;
pEntry->WepStatus = pAd->ApCfg.MBSSID[apidx].WepStatus;
pEntry->GroupKeyWepStatus = pAd->ApCfg.MBSSID[apidx].GroupKeyWepStatus;
if (pEntry->AuthMode < Ndis802_11AuthModeWPA)
pEntry->WpaState = AS_NOTUSE;
else
pEntry->WpaState = AS_INITIALIZE;
pEntry->PrivacyFilter = Ndis802_11PrivFilterAcceptAll;
pEntry->StaIdleTimeout = pAd->ApCfg.StaIdleTimeout;
pAd->ApCfg.MBSSID[apidx].StaCount++;
pAd->ApCfg.EntryClientCount++;
break;
}
#endif /* CONFIG_AP_SUPPORT */
} while (FALSE);
pEntry->GTKState = REKEY_NEGOTIATING;
pEntry->PairwiseKey.KeyLen = 0;
pEntry->PairwiseKey.CipherAlg = CIPHER_NONE;
pEntry->PortSecured = WPA_802_1X_PORT_NOT_SECURED;
pEntry->PMKID_CacheIdx = ENTRY_NOT_FOUND;
COPY_MAC_ADDR(pEntry->Addr, pAddr);
COPY_MAC_ADDR(pEntry->HdrAddr1, pAddr);
do
{
#ifdef APCLI_SUPPORT
if (IS_ENTRY_APCLI(pEntry))
{
COPY_MAC_ADDR(pEntry->HdrAddr2, pAd->ApCfg.ApCliTab[pEntry->apidx].CurrentAddress);
COPY_MAC_ADDR(pEntry->HdrAddr3, pAddr);
break;
}
#endif // APCLI_SUPPORT //
#ifdef WDS_SUPPORT
if (IS_ENTRY_WDS(pEntry))
{
COPY_MAC_ADDR(pEntry->HdrAddr2, pAd->ApCfg.MBSSID[MAIN_MBSSID].Bssid);
COPY_MAC_ADDR(pEntry->HdrAddr3, pAd->ApCfg.MBSSID[MAIN_MBSSID].Bssid);
break;
}
#endif // WDS_SUPPORT //
#ifdef CONFIG_AP_SUPPORT
if (OpMode == OPMODE_AP)
{
COPY_MAC_ADDR(pEntry->HdrAddr2, pAd->ApCfg.MBSSID[apidx].Bssid);
COPY_MAC_ADDR(pEntry->HdrAddr3, pAd->ApCfg.MBSSID[apidx].Bssid);
break;
}
#endif // CONFIG_AP_SUPPORT //
} while (FALSE);
pEntry->Sst = SST_NOT_AUTH;
pEntry->AuthState = AS_NOT_AUTH;
pEntry->Aid = (USHORT)i; /*0;*/
pEntry->CapabilityInfo = 0;
pEntry->PsMode = PWR_ACTIVE;
pEntry->PsQIdleCount = 0;
pEntry->NoDataIdleCount = 0;
pEntry->AssocDeadLine = MAC_TABLE_ASSOC_TIMEOUT;
pEntry->ContinueTxFailCnt = 0;
#ifdef WDS_SUPPORT
pEntry->LockEntryTx = FALSE;
#endif /* WDS_SUPPORT */
pEntry->TimeStamp_toTxRing = 0;
InitializeQueueHeader(&pEntry->PsQueue);
#ifdef STREAM_MODE_SUPPORT
/* Enable Stream mode for first three entries in MAC table */
#endif /* STREAM_MODE_SUPPORT */
#ifdef CONFIG_AP_SUPPORT
IF_DEV_CONFIG_OPMODE_ON_AP(pAd)
{
#ifdef UAPSD_SUPPORT
if (IS_ENTRY_CLIENT(pEntry)) /* Ralink WDS doesn't support any power saving.*/
{
/* init U-APSD enhancement related parameters */
UAPSD_MR_ENTRY_INIT(pEntry);
}
#endif /* UAPSD_SUPPORT */
}
#endif /* CONFIG_AP_SUPPORT */
pAd->MacTab.Size ++;
/* Set the security mode of this entry as OPEN-NONE in ASIC */
RTMP_REMOVE_PAIRWISE_KEY_ENTRY(pAd, (UCHAR)i);
/* Add this entry into ASIC RX WCID search table */
RTMP_STA_ENTRY_ADD(pAd, pEntry);
#ifdef CONFIG_AP_SUPPORT
IF_DEV_CONFIG_OPMODE_ON_AP(pAd)
{
#ifdef WSC_AP_SUPPORT
pEntry->bWscCapable = FALSE;
pEntry->Receive_EapolStart_EapRspId = 0;
#endif /* WSC_AP_SUPPORT */
}
#endif /* CONFIG_AP_SUPPORT */
#ifdef TXBF_SUPPORT
if (pAd->chipCap.FlgHwTxBfCap)
NdisAllocateSpinLock(pAd, &pEntry->TxSndgLock);
#endif /* TXBF_SUPPORT */
DBGPRINT(RT_DEBUG_TRACE, ("MacTableInsertEntry - allocate entry #%d, Total= %d\n",i, pAd->MacTab.Size));
break;
}
}
MAC_TABLE_ENTRY *RTMPInsertRepeaterMacEntry(
IN RTMP_ADAPTER *pAd,
IN UCHAR *pAddr,
IN struct wifi_dev *wdev,
IN UCHAR apIdx,
IN UCHAR cliIdx,
IN BOOLEAN CleanAll)
{
UCHAR HashIdx;
int i;
MAC_TABLE_ENTRY *pEntry = NULL, *pCurrEntry;
BOOLEAN Cancelled;
if (pAd->MacTab.Size >= MAX_LEN_OF_MAC_TABLE)
return NULL;
/* allocate one MAC entry*/
NdisAcquireSpinLock(&pAd->MacTabLock);
i = (MAX_NUMBER_OF_MAC + ((MAX_EXT_MAC_ADDR_SIZE + 1) * (apIdx - MIN_NET_DEVICE_FOR_APCLI)));
if (cliIdx != 0xFF)
i = i + cliIdx + 1;
/* pick up the first available vacancy*/
if (IS_ENTRY_NONE(&pAd->MacTab.Content[i]))
{
pEntry = &pAd->MacTab.Content[i];
/* ENTRY PREEMPTION: initialize the entry */
if (pEntry->RetryTimer.Valid)
RTMPCancelTimer(&pEntry->RetryTimer, &Cancelled);
if (pEntry->EnqueueStartForPSKTimer.Valid)
RTMPCancelTimer(&pEntry->EnqueueStartForPSKTimer, &Cancelled);
#ifdef DOT11W_PMF_SUPPORT
RTMPCancelTimer(&pEntry->SAQueryTimer, &Cancelled);
RTMPCancelTimer(&pEntry->SAQueryConfirmTimer, &Cancelled);
#endif /* DOT11W_PMF_SUPPORT */
NdisZeroMemory(pEntry, sizeof(MAC_TABLE_ENTRY));
if (CleanAll == TRUE)
{
pEntry->MaxSupportedRate = RATE_11;
pEntry->CurrTxRate = RATE_11;
NdisZeroMemory(pEntry, sizeof(MAC_TABLE_ENTRY));
pEntry->PairwiseKey.KeyLen = 0;
pEntry->PairwiseKey.CipherAlg = CIPHER_NONE;
}
#ifdef CONFIG_AP_SUPPORT
#ifdef APCLI_SUPPORT
if (apIdx >= MIN_NET_DEVICE_FOR_APCLI)
{
SET_ENTRY_APCLI(pEntry);
}
#endif /* APCLI_SUPPORT */
#endif /* CONFIG_AP_SUPPORT */
pEntry->wdev = wdev;
pEntry->wcid = i;
//SET_ENTRY_AP(pEntry);//Carter, why set Apcli Entry then set to AP entry?
pAd->MacTab.tr_entry[i].isCached = FALSE;
//tr_entry->isCached = FALSE;
pEntry->bIAmBadAtheros = FALSE;
RTMPInitTimer(pAd, &pEntry->EnqueueStartForPSKTimer, GET_TIMER_FUNCTION(EnqueueStartForPSKExec), pEntry, FALSE);
#ifdef APCLI_SUPPORT
if (IS_ENTRY_APCLI(pEntry))
{
RTMPInitTimer(pAd, &pEntry->RetryTimer, GET_TIMER_FUNCTION(WPARetryExec), pEntry, FALSE);
}
#endif /* APCLI_SUPPORT */
pEntry->pAd = pAd;
pEntry->CMTimerRunning = FALSE;
pEntry->EnqueueEapolStartTimerRunning = EAPOL_START_DISABLE;
pEntry->RSNIE_Len = 0;
NdisZeroMemory(pEntry->R_Counter, sizeof(pEntry->R_Counter));
pEntry->ReTryCounter = PEER_MSG1_RETRY_TIMER_CTR;
pEntry->func_tb_idx = (apIdx - MIN_NET_DEVICE_FOR_APCLI);
if (IS_ENTRY_APCLI(pEntry))
pEntry->func_tb_idx = (apIdx - MIN_NET_DEVICE_FOR_APCLI);
pEntry->pMbss = NULL;
#ifdef APCLI_SUPPORT
if (IS_ENTRY_APCLI(pEntry))
{
pEntry->AuthMode = pAd->ApCfg.ApCliTab[pEntry->func_tb_idx].wdev.AuthMode;
pEntry->WepStatus = pAd->ApCfg.ApCliTab[pEntry->func_tb_idx].wdev.WepStatus;
if (pEntry->AuthMode < Ndis802_11AuthModeWPA)
{
pEntry->WpaState = AS_NOTUSE;
pEntry->PrivacyFilter = Ndis802_11PrivFilterAcceptAll;
}
else
{
pEntry->WpaState = AS_PTKSTART;
pEntry->PrivacyFilter = Ndis802_11PrivFilter8021xWEP;
}
}
#endif /* APCLI_SUPPORT */
pEntry->GTKState = REKEY_NEGOTIATING;
pEntry->PairwiseKey.KeyLen = 0;
pEntry->PairwiseKey.CipherAlg = CIPHER_NONE;
pAd->MacTab.tr_entry[i].PortSecured = WPA_802_1X_PORT_NOT_SECURED;
//pEntry->PortSecured = WPA_802_1X_PORT_NOT_SECURED;
pEntry->PMKID_CacheIdx = ENTRY_NOT_FOUND;
COPY_MAC_ADDR(pEntry->Addr, pAddr);
#ifdef APCLI_SUPPORT
if (IS_ENTRY_APCLI(pEntry))
{
COPY_MAC_ADDR(pEntry->bssid, pAddr);
}
#endif // APCLI_SUPPORT //
pEntry->Sst = SST_NOT_AUTH;
pEntry->AuthState = AS_NOT_AUTH;
pEntry->Aid = (USHORT)i;
pEntry->CapabilityInfo = 0;
pEntry->PsMode = PWR_ACTIVE;
pAd->MacTab.tr_entry[i].PsQIdleCount = 0;
//pEntry->PsQIdleCount = 0;
pEntry->NoDataIdleCount = 0;
pEntry->AssocDeadLine = MAC_TABLE_ASSOC_TIMEOUT;
pEntry->ContinueTxFailCnt = 0;
pEntry->TimeStamp_toTxRing = 0;
// TODO: shiang-usw, remove upper setting becasue we need to migrate to tr_entry!
pAd->MacTab.tr_entry[i].PsMode = PWR_ACTIVE;
pAd->MacTab.tr_entry[i].NoDataIdleCount = 0;
pAd->MacTab.tr_entry[i].ContinueTxFailCnt = 0;
pAd->MacTab.tr_entry[i].LockEntryTx = FALSE;
pAd->MacTab.tr_entry[i].TimeStamp_toTxRing = 0;
pAd->MacTab.Size ++;
/* Set the security mode of this entry as OPEN-NONE in ASIC */
RTMP_REMOVE_PAIRWISE_KEY_ENTRY(pAd, (UCHAR)i);
/* Add this entry into ASIC RX WCID search table */
RTMP_STA_ENTRY_ADD(pAd, pEntry);
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s - allocate entry #%d, Aid = %d, Total= %d\n",__FUNCTION__, i, pEntry->Aid, pAd->MacTab.Size));
}
else
{
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s - exist entry #%d, Aid = %d, Total= %d\n", __FUNCTION__, i, pEntry->Aid, pAd->MacTab.Size));
NdisReleaseSpinLock(&pAd->MacTabLock);
return pEntry;
}
/* add this MAC entry into HASH table */
if (pEntry)
{
HashIdx = MAC_ADDR_HASH_INDEX(pAddr);
if (pAd->MacTab.Hash[HashIdx] == NULL)
{
pAd->MacTab.Hash[HashIdx] = pEntry;
}
else
{
pCurrEntry = pAd->MacTab.Hash[HashIdx];
while (pCurrEntry->pNext != NULL)
pCurrEntry = pCurrEntry->pNext;
pCurrEntry->pNext = pEntry;
}
}
NdisReleaseSpinLock(&pAd->MacTabLock);
rtmp_tx_burst_set(pAd);
return pEntry;
}
/*
==========================================================================
Description:
The apcli ctrl state machine,
Parameters:
Sm - pointer to the state machine
Note:
the state machine looks like the following
==========================================================================
*/
VOID ApCliCtrlStateMachineInit(
IN PRTMP_ADAPTER pAd,
IN STATE_MACHINE *Sm,
OUT STATE_MACHINE_FUNC Trans[])
{
UCHAR i;
#ifdef APCLI_CONNECTION_TRIAL
PAPCLI_STRUCT pApCliEntry;
#endif /* APCLI_CONNECTION_TRIAL */
StateMachineInit(Sm, (STATE_MACHINE_FUNC*)Trans,
APCLI_MAX_CTRL_STATE, APCLI_MAX_CTRL_MSG,
(STATE_MACHINE_FUNC)Drop, APCLI_CTRL_DISCONNECTED,
APCLI_CTRL_MACHINE_BASE);
/* disconnected state */
StateMachineSetAction(Sm, APCLI_CTRL_DISCONNECTED, APCLI_CTRL_JOIN_REQ, (STATE_MACHINE_FUNC)ApCliCtrlJoinReqAction);
/* probe state */
StateMachineSetAction(Sm, APCLI_CTRL_PROBE, APCLI_CTRL_PROBE_RSP, (STATE_MACHINE_FUNC)ApCliCtrlProbeRspAction);
StateMachineSetAction(Sm, APCLI_CTRL_PROBE, APCLI_CTRL_JOIN_REQ_TIMEOUT, (STATE_MACHINE_FUNC)ApCliCtrlJoinReqTimeoutAction);
StateMachineSetAction(Sm, APCLI_CTRL_PROBE, APCLI_CTRL_DISCONNECT_REQ, (STATE_MACHINE_FUNC)ApCliCtrlDisconnectReqAction);
/* auth state */
StateMachineSetAction(Sm, APCLI_CTRL_AUTH, APCLI_CTRL_AUTH_RSP, (STATE_MACHINE_FUNC)ApCliCtrlAuthRspAction);
StateMachineSetAction(Sm, APCLI_CTRL_AUTH, APCLI_CTRL_AUTH_REQ_TIMEOUT, (STATE_MACHINE_FUNC)ApCliCtrlAuthReqTimeoutAction);
StateMachineSetAction(Sm, APCLI_CTRL_AUTH, APCLI_CTRL_DISCONNECT_REQ, (STATE_MACHINE_FUNC)ApCliCtrlDisconnectReqAction);
StateMachineSetAction(Sm, APCLI_CTRL_AUTH, APCLI_CTRL_PEER_DISCONNECT_REQ, (STATE_MACHINE_FUNC)ApCliCtrlPeerDeAssocReqAction);
/* auth2 state */
StateMachineSetAction(Sm, APCLI_CTRL_AUTH_2, APCLI_CTRL_AUTH_RSP, (STATE_MACHINE_FUNC)ApCliCtrlAuth2RspAction);
StateMachineSetAction(Sm, APCLI_CTRL_AUTH_2, APCLI_CTRL_AUTH_REQ_TIMEOUT, (STATE_MACHINE_FUNC)ApCliCtrlAuth2ReqTimeoutAction);
StateMachineSetAction(Sm, APCLI_CTRL_AUTH_2, APCLI_CTRL_DISCONNECT_REQ, (STATE_MACHINE_FUNC)ApCliCtrlDisconnectReqAction);
StateMachineSetAction(Sm, APCLI_CTRL_AUTH_2, APCLI_CTRL_PEER_DISCONNECT_REQ, (STATE_MACHINE_FUNC)ApCliCtrlPeerDeAssocReqAction);
/* assoc state */
StateMachineSetAction(Sm, APCLI_CTRL_ASSOC, APCLI_CTRL_ASSOC_RSP, (STATE_MACHINE_FUNC)ApCliCtrlAssocRspAction);
StateMachineSetAction(Sm, APCLI_CTRL_ASSOC, APCLI_CTRL_ASSOC_REQ_TIMEOUT, (STATE_MACHINE_FUNC)ApCliCtrlAssocReqTimeoutAction);
StateMachineSetAction(Sm, APCLI_CTRL_ASSOC, APCLI_CTRL_DISCONNECT_REQ, (STATE_MACHINE_FUNC)ApCliCtrlDeAssocAction);
StateMachineSetAction(Sm, APCLI_CTRL_ASSOC, APCLI_CTRL_PEER_DISCONNECT_REQ, (STATE_MACHINE_FUNC)ApCliCtrlPeerDeAssocReqAction);
/* deassoc state */
StateMachineSetAction(Sm, APCLI_CTRL_DEASSOC, APCLI_CTRL_DEASSOC_RSP, (STATE_MACHINE_FUNC)ApCliCtrlDeAssocRspAction);
/* connected state */
StateMachineSetAction(Sm, APCLI_CTRL_CONNECTED, APCLI_CTRL_DISCONNECT_REQ, (STATE_MACHINE_FUNC)ApCliCtrlDeAuthAction);
StateMachineSetAction(Sm, APCLI_CTRL_CONNECTED, APCLI_CTRL_PEER_DISCONNECT_REQ, (STATE_MACHINE_FUNC)ApCliCtrlPeerDeAssocReqAction);
StateMachineSetAction(Sm, APCLI_CTRL_CONNECTED, APCLI_CTRL_MT2_AUTH_REQ, (STATE_MACHINE_FUNC)ApCliCtrlProbeRspAction);
StateMachineSetAction(Sm, APCLI_CTRL_CONNECTED, APCLI_MIC_FAILURE_REPORT_FRAME, (STATE_MACHINE_FUNC)ApCliWpaMicFailureReportFrame);
#ifdef APCLI_CERT_SUPPORT
StateMachineSetAction(Sm, APCLI_CTRL_CONNECTED, APCLI_CTRL_SCAN_DONE, (STATE_MACHINE_FUNC)ApCliCtrlScanDoneAction);
#endif /* APCLI_CERT_SUPPORT */
#ifdef APCLI_CONNECTION_TRIAL
StateMachineSetAction(Sm, APCLI_CTRL_CONNECTED, APCLI_CTRL_TRIAL_CONNECT, (STATE_MACHINE_FUNC)ApCliCtrlTrialConnectAction);
StateMachineSetAction(Sm, APCLI_CTRL_DISCONNECTED, APCLI_CTRL_TRIAL_CONNECT, (STATE_MACHINE_FUNC)ApCliCtrlTrialConnectAction);
StateMachineSetAction(Sm, APCLI_CTRL_TRIAL_TRIGGERED, APCLI_CTRL_JOIN_REQ_TIMEOUT, (STATE_MACHINE_FUNC)ApCliCtrlTrialConnectAction);//for retry
#endif /* APCLI_CONNECTION_TRIAL */
for (i = 0; i < MAX_APCLI_NUM; i++)
{
pAd->ApCfg.ApCliTab[i].CtrlCurrState = APCLI_CTRL_DISCONNECTED;
#ifdef APCLI_CONNECTION_TRIAL
pApCliEntry = &pAd->ApCfg.ApCliTab[i];
/* timer init */
printk("woody init pApCliEntry->TrialConnectTimer\n");
RTMPInitTimer(pAd,
&pApCliEntry->TrialConnectTimer,
GET_TIMER_FUNCTION(ApCliTrialConnectTimeout),
(PVOID)pApCliEntry,
FALSE);
RTMPInitTimer(pAd,
&pApCliEntry->TrialConnectPhase2Timer,
GET_TIMER_FUNCTION(ApCliTrialConnectPhase2Timeout),
(PVOID)pApCliEntry,
FALSE);
RTMPInitTimer(pAd,
&pApCliEntry->TrialConnectRetryTimer,
GET_TIMER_FUNCTION(ApCliTrialConnectRetryTimeout),
pApCliEntry,
FALSE);
#endif /* APCLI_CONNECTION_TRIAL */
}
return;
}
BOOLEAN BARecSessionAdd(
IN PRTMP_ADAPTER pAd,
IN MAC_TABLE_ENTRY *pEntry,
IN PFRAME_ADDBA_REQ pFrame)
{
BA_REC_ENTRY *pBAEntry = NULL;
BOOLEAN Status = TRUE;
BOOLEAN Cancelled;
USHORT Idx;
UCHAR TID;
UCHAR BAWinSize;
//UINT32 Value;
//UINT offset;
ASSERT(pEntry);
// find TID
TID = pFrame->BaParm.TID;
BAWinSize = min(((UCHAR)pFrame->BaParm.BufSize), (UCHAR)pAd->CommonCfg.BACapability.field.RxBAWinLimit);
// Intel patch
if (BAWinSize == 0)
{
BAWinSize = 64;
}
Idx = pEntry->BARecWcidArray[TID];
if (Idx == 0)
{
pBAEntry = BATableAllocRecEntry(pAd, &Idx);
}
else
{
pBAEntry = &pAd->BATable.BARecEntry[Idx];
// flush all pending reordering mpdus
ba_refresh_reordering_mpdus(pAd, pBAEntry);
}
DBGPRINT(RT_DEBUG_TRACE,("%s(%ld): Idx = %d, BAWinSize(req %d) = %d\n", __FUNCTION__, pAd->BATable.numAsRecipient, Idx,
pFrame->BaParm.BufSize, BAWinSize));
// Start fill in parameters.
if (pBAEntry != NULL)
{
ASSERT(pBAEntry->list.qlen == 0);
pBAEntry->REC_BA_Status = Recipient_HandleRes;
pBAEntry->BAWinSize = BAWinSize;
pBAEntry->Wcid = pEntry->Aid;
pBAEntry->TID = TID;
pBAEntry->TimeOutValue = pFrame->TimeOutValue;
pBAEntry->REC_BA_Status = Recipient_Accept;
// initial sequence number
pBAEntry->LastIndSeq = RESET_RCV_SEQ; //pFrame->BaStartSeq.field.StartSeq;
DBGPRINT(RT_DEBUG_OFF, ("Start Seq = %08x\n", pFrame->BaStartSeq.field.StartSeq));
if (pEntry->RXBAbitmap & (1<<TID))
{
RTMPCancelTimer(&pBAEntry->RECBATimer, &Cancelled);
}
else
{
RTMPInitTimer(pAd, &pBAEntry->RECBATimer, GET_TIMER_FUNCTION(BARecSessionIdleTimeout), pBAEntry, TRUE);
}
// Set Bitmap flag.
pEntry->RXBAbitmap |= (1<<TID);
pEntry->BARecWcidArray[TID] = Idx;
pEntry->BADeclineBitmap &= ~(1<<TID);
// Set BA session mask in WCID table.
RTMP_ADD_BA_SESSION_TO_ASIC(pAd, pEntry->Aid, TID);
DBGPRINT(RT_DEBUG_TRACE,("MACEntry[%d]RXBAbitmap = 0x%x. BARecWcidArray=%d\n",
pEntry->Aid, pEntry->RXBAbitmap, pEntry->BARecWcidArray[TID]));
}
else
{
Status = FALSE;
DBGPRINT(RT_DEBUG_TRACE,("Can't Accept ADDBA for %02x:%02x:%02x:%02x:%02x:%02x TID = %d\n",
PRINT_MAC(pEntry->Addr), TID));
}
return(Status);
}
MAC_TABLE_ENTRY *RTMPInsertRepeaterMacEntry(
IN PRTMP_ADAPTER pAd,
IN PUCHAR pAddr,
IN UCHAR apidx,
IN UCHAR cliidx,
IN BOOLEAN CleanAll)
{
UCHAR HashIdx;
int i;
MAC_TABLE_ENTRY *pEntry = NULL, *pCurrEntry;
BOOLEAN Cancelled;
/* if FULL, return*/
if (pAd->MacTab.Size >= MAX_MAC_TABLE_SIZE_WITH_REPEATER)
return NULL;
/* allocate one MAC entry*/
NdisAcquireSpinLock(&pAd->MacTabLock);
i = (MAX_LEN_OF_MAC_TABLE + ((MAX_EXT_MAC_ADDR_SIZE + 1) * (apidx - MIN_NET_DEVICE_FOR_APCLI)));
if (cliidx != 0xFF)
i = i + cliidx + 1;
pEntry = &pAd->MacTab.Content[i];
if (IS_ENTRY_NONE(pEntry))
{
/* ENTRY PREEMPTION: initialize the entry */
if (pEntry->RetryTimer.Valid)
RTMPCancelTimer(&pEntry->RetryTimer, &Cancelled);
if (pEntry->EnqueueStartForPSKTimer.Valid)
RTMPCancelTimer(&pEntry->EnqueueStartForPSKTimer, &Cancelled);
NdisZeroMemory(pEntry, sizeof(MAC_TABLE_ENTRY));
if (CleanAll == TRUE)
{
pEntry->MaxSupportedRate = RATE_11;
pEntry->CurrTxRate = RATE_11;
NdisZeroMemory(pEntry, sizeof(MAC_TABLE_ENTRY));
pEntry->PairwiseKey.KeyLen = 0;
pEntry->PairwiseKey.CipherAlg = CIPHER_NONE;
}
SET_ENTRY_APCLI(pEntry);
pEntry->isCached = FALSE;
pEntry->bIAmBadAtheros = FALSE;
RTMPInitTimer(pAd, &pEntry->EnqueueStartForPSKTimer, GET_TIMER_FUNCTION(EnqueueStartForPSKExec), pEntry, FALSE);
RTMPInitTimer(pAd, &pEntry->RetryTimer, GET_TIMER_FUNCTION(WPARetryExec), pEntry, FALSE);
pEntry->pAd = pAd;
pEntry->CMTimerRunning = FALSE;
pEntry->EnqueueEapolStartTimerRunning = EAPOL_START_DISABLE;
pEntry->RSNIE_Len = 0;
NdisZeroMemory(pEntry->R_Counter, sizeof(pEntry->R_Counter));
pEntry->ReTryCounter = PEER_MSG1_RETRY_TIMER_CTR;
pEntry->apidx = (apidx - MIN_NET_DEVICE_FOR_APCLI);
pEntry->pMbss = NULL;
pEntry->AuthMode = pAd->ApCfg.ApCliTab[pEntry->apidx].AuthMode;
pEntry->WepStatus = pAd->ApCfg.ApCliTab[pEntry->apidx].WepStatus;
pEntry->MatchAPCLITabIdx = pEntry->apidx;
if (pEntry->AuthMode < Ndis802_11AuthModeWPA)
{
pEntry->WpaState = AS_NOTUSE;
pEntry->PrivacyFilter = Ndis802_11PrivFilterAcceptAll;
}
else
{
pEntry->WpaState = AS_PTKSTART;
pEntry->PrivacyFilter = Ndis802_11PrivFilter8021xWEP;
}
pEntry->GTKState = REKEY_NEGOTIATING;
pEntry->PairwiseKey.KeyLen = 0;
pEntry->PairwiseKey.CipherAlg = CIPHER_NONE;
pEntry->PortSecured = WPA_802_1X_PORT_NOT_SECURED;
pEntry->PMKID_CacheIdx = ENTRY_NOT_FOUND;
COPY_MAC_ADDR(pEntry->Addr, pAddr);
COPY_MAC_ADDR(pEntry->HdrAddr1, pAddr);
COPY_MAC_ADDR(pEntry->HdrAddr2, pAd->ApCfg.ApCliTab[pEntry->apidx].CurrentAddress);
COPY_MAC_ADDR(pEntry->HdrAddr3, pAddr);
pEntry->Sst = SST_NOT_AUTH;
pEntry->AuthState = AS_NOT_AUTH;
pEntry->Aid = (USHORT)i; /*0;*/
pEntry->CapabilityInfo = 0;
pEntry->PsMode = PWR_ACTIVE;
pEntry->PsQIdleCount = 0;
pEntry->NoDataIdleCount = 0;
pEntry->AssocDeadLine = MAC_TABLE_ASSOC_TIMEOUT;
pEntry->ContinueTxFailCnt = 0;
pEntry->TimeStamp_toTxRing = 0;
InitializeQueueHeader(&pEntry->PsQueue);
pAd->MacTab.Size ++;
/* Set the security mode of this entry as OPEN-NONE in ASIC */
RTMP_REMOVE_PAIRWISE_KEY_ENTRY(pAd, (UCHAR)i);
/* Add this entry into ASIC RX WCID search table */
RTMP_STA_ENTRY_ADD(pAd, pEntry);
#ifdef WSC_AP_SUPPORT
pEntry->bWscCapable = FALSE;
pEntry->Receive_EapolStart_EapRspId = 0;
#endif /* WSC_AP_SUPPORT */
DBGPRINT(RT_DEBUG_TRACE, ("MacTableInsertEntry - allocate entry #%d, Aid = %d, Total= %d\n",i, pEntry->Aid, pAd->MacTab.Size));
}
else
{
DBGPRINT(RT_DEBUG_ERROR, ("%s - exist entry #%d, Aid = %d, Total= %d\n", __FUNCTION__, i, pEntry->Aid, pAd->MacTab.Size));
NdisReleaseSpinLock(&pAd->MacTabLock);
return pEntry;
}
/* add this MAC entry into HASH table */
if (pEntry)
{
HashIdx = MAC_ADDR_HASH_INDEX(pAddr);
if (pAd->MacTab.Hash[HashIdx] == NULL)
{
pAd->MacTab.Hash[HashIdx] = pEntry;
}
else
{
pCurrEntry = pAd->MacTab.Hash[HashIdx];
while (pCurrEntry->pNext != NULL)
pCurrEntry = pCurrEntry->pNext;
pCurrEntry->pNext = pEntry;
}
}
NdisReleaseSpinLock(&pAd->MacTabLock);
return pEntry;
}