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; }