1 #include "p2p_precomp.h"
6 IN P_ADAPTER_T prAdapter,
7 IN P_P2P_FSM_INFO_T prP2pFsmInfo,
8 IN P_BSS_INFO_T prP2pBssInfo,
9 OUT P_ENUM_P2P_STATE_T peNextState
12 BOOLEAN fgIsTransOut = FALSE;
13 // P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T)NULL;
16 ASSERT_BREAK((prAdapter != NULL) &&
17 (prP2pFsmInfo != NULL) &&
18 (prP2pBssInfo != NULL) &&
19 (peNextState != NULL));
21 if ((prP2pBssInfo->eIntendOPMode == OP_MODE_ACCESS_POINT) && IS_NET_PWR_STATE_ACTIVE(prAdapter, NETWORK_TYPE_P2P_INDEX)) {
22 P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);
25 prChnlReqInfo->eChannelReqType = CHANNEL_REQ_TYPE_GO_START_BSS;
26 *peNextState = P2P_STATE_REQING_CHANNEL;
31 else if (IS_NET_PWR_STATE_ACTIVE(prAdapter, NETWORK_TYPE_P2P_INDEX)) {
33 ASSERT((prP2pBssInfo->eCurrentOPMode == OP_MODE_ACCESS_POINT) ||
34 (prP2pBssInfo->eCurrentOPMode == OP_MODE_INFRASTRUCTURE));
36 prChnlReqInfo = &prP2pFsmInfo->rChnlReqInfo;
38 if (prChnlReqInfo->fgIsChannelRequested) {
39 /* Start a timer for return channel. */
40 DBGLOG(P2P, TRACE, ("start a GO channel timer.\n"));
46 cnmTimerStartTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer), 5000);
52 } /* p2pStateInit_IDLE */
57 IN P_ADAPTER_T prAdapter,
58 IN P_P2P_FSM_INFO_T prP2pFsmInfo,
59 IN ENUM_P2P_STATE_T eNextState
63 P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T)NULL;
66 ASSERT_BREAK((prAdapter != NULL) &&
67 (prP2pFsmInfo != NULL));
69 prChnlReqInfo = &prP2pFsmInfo->rChnlReqInfo;
72 if (prChnlReqInfo->fgIsChannelRequested) {
73 /* Release channel before timeout. */
74 p2pFuncReleaseCh(prAdapter, prChnlReqInfo);
78 /* Stop timer for leaving this state. */
79 cnmTimerStopTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer));
84 } /* p2pStateAbort_IDLE */
89 p2pStateInit_CHNL_ON_HAND (
90 IN P_ADAPTER_T prAdapter,
91 IN P_BSS_INFO_T prP2pBssInfo,
92 IN P_P2P_FSM_INFO_T prP2pFsmInfo
95 P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T)NULL;
98 ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));
100 prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);
102 /* Store the original channel info. */
103 prChnlReqInfo->ucOriChnlNum = prP2pBssInfo->ucPrimaryChannel;
104 prChnlReqInfo->eOriBand = prP2pBssInfo->eBand;
105 prChnlReqInfo->eOriChnlSco = prP2pBssInfo->eBssSCO;
107 /* RX Probe Request would check primary channel.*/
108 prP2pBssInfo->ucPrimaryChannel = prChnlReqInfo->ucReqChnlNum;
109 prP2pBssInfo->eBand = prChnlReqInfo->eBand;
110 prP2pBssInfo->eBssSCO = prChnlReqInfo->eChnlSco;
113 DBGLOG(P2P, TRACE, ("start a channel on hand timer.\n"));
114 cnmTimerStartTimer(prAdapter,
115 &(prP2pFsmInfo->rP2pFsmTimeoutTimer),
116 prChnlReqInfo->u4MaxInterval);
118 kalP2PIndicateChannelReady(prAdapter->prGlueInfo,
119 prChnlReqInfo->u8Cookie,
120 prChnlReqInfo->ucReqChnlNum,
121 prChnlReqInfo->eBand,
122 prChnlReqInfo->eChnlSco,
123 prChnlReqInfo->u4MaxInterval);
128 } /* p2pStateInit_CHNL_ON_HAND */
132 p2pStateAbort_CHNL_ON_HAND (
133 IN P_ADAPTER_T prAdapter,
134 IN P_P2P_FSM_INFO_T prP2pFsmInfo,
135 IN P_BSS_INFO_T prP2pBssInfo,
136 IN ENUM_P2P_STATE_T eNextState
139 P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T)NULL;
143 ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));
145 prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);
147 cnmTimerStopTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer));
149 /* Restore the original channel info. */
150 prP2pBssInfo->ucPrimaryChannel = prChnlReqInfo->ucOriChnlNum;
151 prP2pBssInfo->eBand = prChnlReqInfo->eOriBand;
152 prP2pBssInfo->eBssSCO = prChnlReqInfo->eOriChnlSco;
154 if (eNextState != P2P_STATE_CHNL_ON_HAND) {
155 /* Indicate channel return. */
156 kalP2PIndicateChannelExpired(prAdapter->prGlueInfo, &prP2pFsmInfo->rChnlReqInfo);
159 p2pFuncReleaseCh(prAdapter, &(prP2pFsmInfo->rChnlReqInfo));
164 } /* p2pStateAbort_CHNL_ON_HAND */
168 p2pStateAbort_REQING_CHANNEL (
169 IN P_ADAPTER_T prAdapter,
170 IN P_P2P_FSM_INFO_T prP2pFsmInfo,
171 IN ENUM_P2P_STATE_T eNextState
174 P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T)NULL;
175 P_P2P_SPECIFIC_BSS_INFO_T prP2pSpecificBssInfo = (P_P2P_SPECIFIC_BSS_INFO_T)NULL;
179 ASSERT_BREAK((prAdapter != NULL) &&
180 (prP2pFsmInfo != NULL) &&
181 (eNextState < P2P_STATE_NUM));
183 prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
184 prP2pSpecificBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;
186 if (eNextState == P2P_STATE_IDLE) {
187 if (prP2pBssInfo->eIntendOPMode == OP_MODE_ACCESS_POINT) {
188 /* Intend to be AP. */
189 /* Setup for AP mode. */
190 p2pFuncStartGO(prAdapter,
192 prP2pSpecificBssInfo->aucGroupSsid,
193 prP2pSpecificBssInfo->u2GroupSsidLen,
194 prP2pSpecificBssInfo->ucPreferredChannel,
195 prP2pSpecificBssInfo->eRfBand,
196 prP2pSpecificBssInfo->eRfSco,
197 prP2pFsmInfo->fgIsApMode);
202 p2pFuncReleaseCh(prAdapter, &(prP2pFsmInfo->rChnlReqInfo));
211 } /* p2pStateInit_AP_CHANNEL_DETECT */
215 p2pStateInit_AP_CHANNEL_DETECT (
216 IN P_ADAPTER_T prAdapter,
217 IN P_P2P_FSM_INFO_T prP2pFsmInfo
220 P_P2P_SCAN_REQ_INFO_T prScanReqInfo = (P_P2P_SCAN_REQ_INFO_T)NULL;
223 ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));
225 prScanReqInfo = &(prP2pFsmInfo->rScanReqInfo);
227 prScanReqInfo->eScanType = SCAN_TYPE_PASSIVE_SCAN;
228 prScanReqInfo->eChannelSet = SCAN_CHANNEL_2G4;
229 prScanReqInfo->u2PassiveDewellTime = 50; // 50ms for passive channel load detection
230 prScanReqInfo->fgIsAbort = TRUE;
231 prScanReqInfo->fgIsScanRequest = TRUE;
232 prScanReqInfo->ucNumChannelList = 0;
233 prScanReqInfo->u4BufLength = 0;
234 prScanReqInfo->rSsidStruct.ucSsidLen = 0;
236 p2pFuncRequestScan(prAdapter, prScanReqInfo);
241 } /* p2pStateInit_AP_CHANNEL_DETECT */
246 p2pStateAbort_AP_CHANNEL_DETECT (
247 IN P_ADAPTER_T prAdapter,
248 IN P_P2P_FSM_INFO_T prP2pFsmInfo,
249 IN P_P2P_SPECIFIC_BSS_INFO_T prP2pSpecificBssInfo,
250 IN ENUM_P2P_STATE_T eNextState
253 P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T)NULL;
254 P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T)NULL;
258 if (eNextState == P2P_STATE_REQING_CHANNEL) {
259 UINT_8 ucPreferedChnl = 0;
260 ENUM_BAND_T eBand = BAND_NULL;
261 ENUM_CHNL_EXT_T eSco = CHNL_EXT_SCN;
263 prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);
265 /* Determine the channel for AP. */
266 if (cnmPreferredChannel(prAdapter,
271 prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
273 if ((ucPreferedChnl = prP2pConnSettings->ucOperatingChnl) == 0) {
275 if (scnQuerySparseChannel(prAdapter, &eBand, &ucPreferedChnl) == FALSE) {
279 // TODO: Pick up a valid channel from channel list.
285 prChnlReqInfo->eChannelReqType = CHANNEL_REQ_TYPE_GO_START_BSS;
286 prChnlReqInfo->ucReqChnlNum = prP2pSpecificBssInfo->ucPreferredChannel = ucPreferedChnl;
287 prChnlReqInfo->eBand = prP2pSpecificBssInfo->eRfBand = eBand;
288 prChnlReqInfo->eChnlSco = prP2pSpecificBssInfo->eRfSco = eSco;
291 p2pFuncCancelScan(prAdapter, &(prP2pFsmInfo->rScanReqInfo));
298 } /* p2pStateAbort_AP_CHANNEL_DETECT */
304 IN P_ADAPTER_T prAdapter,
305 IN P_P2P_FSM_INFO_T prP2pFsmInfo
308 P_P2P_SCAN_REQ_INFO_T prScanReqInfo = (P_P2P_SCAN_REQ_INFO_T)NULL;
312 ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));
314 prScanReqInfo = &prP2pFsmInfo->rScanReqInfo;
316 prScanReqInfo->fgIsScanRequest = TRUE;
318 p2pFuncRequestScan(prAdapter, prScanReqInfo);
322 } /* p2pStateInit_SCAN */
327 IN P_ADAPTER_T prAdapter,
328 IN P_P2P_FSM_INFO_T prP2pFsmInfo,
329 IN ENUM_P2P_STATE_T eNextState
333 ASSERT_BREAK(prAdapter != NULL);
335 // 1. Scan cancel. (Make sure the scan request is invalid.
336 p2pFuncCancelScan(prAdapter, &(prP2pFsmInfo->rScanReqInfo));
338 // Scan done indication.
339 kalP2PIndicateScanDone(prAdapter->prGlueInfo, prP2pFsmInfo->rScanReqInfo.fgIsAbort);
343 } /* p2pStateAbort_SCAN */
347 p2pStateInit_GC_JOIN (
348 IN P_ADAPTER_T prAdapter,
349 IN P_P2P_FSM_INFO_T prP2pFsmInfo,
350 IN P_BSS_INFO_T prP2pBssInfo,
351 IN P_P2P_JOIN_INFO_T prJoinInfo,
352 IN P_BSS_DESC_T prBssDesc
355 P_MSG_JOIN_REQ_T prJoinReqMsg = (P_MSG_JOIN_REQ_T)NULL;
356 P_STA_RECORD_T prStaRec = (P_STA_RECORD_T)NULL;
357 P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T)NULL;
360 ASSERT_BREAK((prAdapter != NULL) &&
361 (prP2pFsmInfo != NULL) &&
362 (prP2pBssInfo != NULL) &&
363 (prJoinInfo != NULL) &&
364 (prBssDesc != NULL));
366 prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
368 if (prBssDesc->ucSSIDLen) {
369 COPY_SSID(prP2pConnSettings->aucSSID,
370 prP2pConnSettings->ucSSIDLen,
372 prBssDesc->ucSSIDLen);
376 // Setup a join timer.
377 DBGLOG(P2P, TRACE, ("Start a join init timer\n"));
378 cnmTimerStartTimer(prAdapter,
379 &(prP2pFsmInfo->rP2pFsmTimeoutTimer),
380 (prP2pFsmInfo->u4GrantInterval - AIS_JOIN_CH_GRANT_THRESHOLD));
382 //2 <1> We are goin to connect to this BSS
383 prBssDesc->fgIsConnecting = TRUE;
385 //2 <2> Setup corresponding STA_RECORD_T
386 prStaRec = bssCreateStaRecFromBssDesc(prAdapter,
387 (prBssDesc->fgIsP2PPresent?(STA_TYPE_P2P_GO):(STA_TYPE_LEGACY_AP)),
388 NETWORK_TYPE_P2P_INDEX,
391 if (prStaRec == NULL) {
392 DBGLOG(P2P, TRACE, ("Create station record fail\n"));
397 prJoinInfo->prTargetStaRec = prStaRec;
398 prJoinInfo->fgIsJoinComplete = FALSE;
399 prJoinInfo->u4BufLength = 0;
401 //2 <2.1> Sync. to FW domain
402 cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
405 if (prP2pBssInfo->eConnectionState == PARAM_MEDIA_STATE_DISCONNECTED) {
406 P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T)NULL;
408 prStaRec->fgIsReAssoc = FALSE;
410 prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
412 switch (prP2pConnSettings->eAuthMode) {
413 case AUTH_MODE_OPEN: /* Note: Omit break here. */
415 case AUTH_MODE_WPA_PSK:
417 case AUTH_MODE_WPA2_PSK:
418 prJoinInfo->ucAvailableAuthTypes = (UINT_8)AUTH_TYPE_OPEN_SYSTEM;
420 case AUTH_MODE_SHARED:
421 prJoinInfo->ucAvailableAuthTypes = (UINT_8)AUTH_TYPE_SHARED_KEY;
423 case AUTH_MODE_AUTO_SWITCH:
424 DBGLOG(P2P, LOUD, ("JOIN INIT: eAuthMode == AUTH_MODE_AUTO_SWITCH\n"));
425 prJoinInfo->ucAvailableAuthTypes = (UINT_8)(AUTH_TYPE_OPEN_SYSTEM |
426 AUTH_TYPE_SHARED_KEY);
429 ASSERT(!(prP2pConnSettings->eAuthMode == AUTH_MODE_WPA_NONE));
430 DBGLOG(P2P, ERROR, ("JOIN INIT: Auth Algorithm : %d was not supported by JOIN\n",
431 prP2pConnSettings->eAuthMode));
432 /* TODO(Kevin): error handling ? */
435 prStaRec->ucTxAuthAssocRetryLimit = TX_AUTH_ASSOCI_RETRY_LIMIT;
439 // TODO: Shall we considering ROAMIN case for P2P Device?.
443 //2 <4> Use an appropriate Authentication Algorithm Number among the ucAvailableAuthTypes.
444 if (prJoinInfo->ucAvailableAuthTypes &
445 (UINT_8)AUTH_TYPE_OPEN_SYSTEM) {
447 DBGLOG(P2P, TRACE, ("JOIN INIT: Try to do Authentication with AuthType == OPEN_SYSTEM.\n"));
449 prJoinInfo->ucAvailableAuthTypes &=
450 ~(UINT_8)AUTH_TYPE_OPEN_SYSTEM;
452 prStaRec->ucAuthAlgNum = (UINT_8)AUTH_ALGORITHM_NUM_OPEN_SYSTEM;
454 else if (prJoinInfo->ucAvailableAuthTypes &
455 (UINT_8)AUTH_TYPE_SHARED_KEY) {
457 DBGLOG(P2P, TRACE, ("JOIN INIT: Try to do Authentication with AuthType == SHARED_KEY.\n"));
459 prJoinInfo->ucAvailableAuthTypes &=
460 ~(UINT_8)AUTH_TYPE_SHARED_KEY;
462 prStaRec->ucAuthAlgNum = (UINT_8)AUTH_ALGORITHM_NUM_SHARED_KEY;
464 else if (prJoinInfo->ucAvailableAuthTypes &
465 (UINT_8)AUTH_TYPE_FAST_BSS_TRANSITION) {
467 DBGLOG(P2P, TRACE, ("JOIN INIT: Try to do Authentication with AuthType == FAST_BSS_TRANSITION.\n"));
469 prJoinInfo->ucAvailableAuthTypes &=
470 ~(UINT_8)AUTH_TYPE_FAST_BSS_TRANSITION;
472 prStaRec->ucAuthAlgNum = (UINT_8)AUTH_ALGORITHM_NUM_FAST_BSS_TRANSITION;
479 //4 <5> Overwrite Connection Setting for eConnectionPolicy == ANY (Used by Assoc Req)
480 if (prBssDesc->ucSSIDLen) {
481 COPY_SSID(prJoinInfo->rSsidStruct.aucSsid,
482 prJoinInfo->rSsidStruct.ucSsidLen,
484 prBssDesc->ucSSIDLen);
487 //2 <5> Backup desired channel.
489 //2 <6> Send a Msg to trigger SAA to start JOIN process.
490 prJoinReqMsg = (P_MSG_JOIN_REQ_T)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_JOIN_REQ_T));
493 DBGLOG(P2P, TRACE, ("Allocation Join Message Fail\n"));
498 prJoinReqMsg->rMsgHdr.eMsgId = MID_P2P_SAA_FSM_START;
499 prJoinReqMsg->ucSeqNum = ++prJoinInfo->ucSeqNumOfReqMsg;
500 prJoinReqMsg->prStaRec = prStaRec;
502 // TODO: Consider fragmentation info in station record.
504 mboxSendMsg(prAdapter,
506 (P_MSG_HDR_T)prJoinReqMsg,
507 MSG_SEND_METHOD_BUF);
515 } /* p2pStateInit_GC_JOIN */
519 /*----------------------------------------------------------------------------*/
521 * @brief Process of JOIN Abort. Leave JOIN State & Abort JOIN.
527 /*----------------------------------------------------------------------------*/
529 p2pStateAbort_GC_JOIN (
530 IN P_ADAPTER_T prAdapter,
531 IN P_P2P_FSM_INFO_T prP2pFsmInfo,
532 IN P_P2P_JOIN_INFO_T prJoinInfo,
533 IN ENUM_P2P_STATE_T eNextState
536 P_MSG_JOIN_ABORT_T prJoinAbortMsg = (P_MSG_JOIN_ABORT_T)NULL;
540 ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL) && (prJoinInfo != NULL));
542 if (prJoinInfo->fgIsJoinComplete == FALSE) {
544 prJoinAbortMsg = (P_MSG_JOIN_ABORT_T)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_JOIN_ABORT_T));
545 if (!prJoinAbortMsg) {
546 DBGLOG(P2P, TRACE, ("Fail to allocate join abort message buffer\n"));
551 prJoinAbortMsg->rMsgHdr.eMsgId = MID_P2P_SAA_FSM_ABORT;
552 prJoinAbortMsg->ucSeqNum = prJoinInfo->ucSeqNumOfReqMsg;
553 prJoinAbortMsg->prStaRec = prJoinInfo->prTargetStaRec;
555 mboxSendMsg(prAdapter,
557 (P_MSG_HDR_T)prJoinAbortMsg,
558 MSG_SEND_METHOD_BUF);
562 /* Stop Join Timer. */
563 cnmTimerStopTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer));
565 /* Release channel requested. */
566 p2pFuncReleaseCh(prAdapter, &(prP2pFsmInfo->rChnlReqInfo));
572 } /* p2pStateAbort_GC_JOIN */