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.
287 prChnlReqInfo->eChannelReqType = CHANNEL_REQ_TYPE_GO_START_BSS;
288 prChnlReqInfo->ucReqChnlNum = prP2pSpecificBssInfo->ucPreferredChannel = ucPreferedChnl;
289 prChnlReqInfo->eBand = prP2pSpecificBssInfo->eRfBand = eBand;
290 prChnlReqInfo->eChnlSco = prP2pSpecificBssInfo->eRfSco = eSco;
293 p2pFuncCancelScan(prAdapter, &(prP2pFsmInfo->rScanReqInfo));
300 } /* p2pStateAbort_AP_CHANNEL_DETECT */
306 IN P_ADAPTER_T prAdapter,
307 IN P_P2P_FSM_INFO_T prP2pFsmInfo
310 P_P2P_SCAN_REQ_INFO_T prScanReqInfo = (P_P2P_SCAN_REQ_INFO_T)NULL;
314 ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));
316 prScanReqInfo = &prP2pFsmInfo->rScanReqInfo;
318 prScanReqInfo->fgIsScanRequest = TRUE;
320 p2pFuncRequestScan(prAdapter, prScanReqInfo);
324 } /* p2pStateInit_SCAN */
329 IN P_ADAPTER_T prAdapter,
330 IN P_P2P_FSM_INFO_T prP2pFsmInfo,
331 IN ENUM_P2P_STATE_T eNextState
335 ASSERT_BREAK(prAdapter != NULL);
337 // 1. Scan cancel. (Make sure the scan request is invalid.
338 p2pFuncCancelScan(prAdapter, &(prP2pFsmInfo->rScanReqInfo));
340 // Scan done indication.
341 kalP2PIndicateScanDone(prAdapter->prGlueInfo, prP2pFsmInfo->rScanReqInfo.fgIsAbort);
345 } /* p2pStateAbort_SCAN */
349 p2pStateInit_GC_JOIN (
350 IN P_ADAPTER_T prAdapter,
351 IN P_P2P_FSM_INFO_T prP2pFsmInfo,
352 IN P_BSS_INFO_T prP2pBssInfo,
353 IN P_P2P_JOIN_INFO_T prJoinInfo,
354 IN P_BSS_DESC_T prBssDesc
357 P_MSG_JOIN_REQ_T prJoinReqMsg = (P_MSG_JOIN_REQ_T)NULL;
358 P_STA_RECORD_T prStaRec = (P_STA_RECORD_T)NULL;
359 P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T)NULL;
362 ASSERT_BREAK((prAdapter != NULL) &&
363 (prP2pFsmInfo != NULL) &&
364 (prP2pBssInfo != NULL) &&
365 (prJoinInfo != NULL) &&
366 (prBssDesc != NULL));
368 prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
370 if (prBssDesc->ucSSIDLen) {
371 COPY_SSID(prP2pConnSettings->aucSSID,
372 prP2pConnSettings->ucSSIDLen,
374 prBssDesc->ucSSIDLen);
378 // Setup a join timer.
379 DBGLOG(P2P, TRACE, ("Start a join init timer\n"));
380 cnmTimerStartTimer(prAdapter,
381 &(prP2pFsmInfo->rP2pFsmTimeoutTimer),
382 (prP2pFsmInfo->u4GrantInterval - AIS_JOIN_CH_GRANT_THRESHOLD));
384 //2 <1> We are goin to connect to this BSS
385 prBssDesc->fgIsConnecting = TRUE;
387 //2 <2> Setup corresponding STA_RECORD_T
388 prStaRec = bssCreateStaRecFromBssDesc(prAdapter,
389 (prBssDesc->fgIsP2PPresent?(STA_TYPE_P2P_GO):(STA_TYPE_LEGACY_AP)),
390 NETWORK_TYPE_P2P_INDEX,
393 if (prStaRec == NULL) {
394 DBGLOG(P2P, TRACE, ("Create station record fail\n"));
399 prJoinInfo->prTargetStaRec = prStaRec;
400 prJoinInfo->fgIsJoinComplete = FALSE;
401 prJoinInfo->u4BufLength = 0;
403 //2 <2.1> Sync. to FW domain
404 cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
407 if (prP2pBssInfo->eConnectionState == PARAM_MEDIA_STATE_DISCONNECTED) {
408 P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T)NULL;
410 prStaRec->fgIsReAssoc = FALSE;
412 prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
414 switch (prP2pConnSettings->eAuthMode) {
415 case AUTH_MODE_OPEN: /* Note: Omit break here. */
417 case AUTH_MODE_WPA_PSK:
419 case AUTH_MODE_WPA2_PSK:
420 prJoinInfo->ucAvailableAuthTypes = (UINT_8)AUTH_TYPE_OPEN_SYSTEM;
422 case AUTH_MODE_SHARED:
423 prJoinInfo->ucAvailableAuthTypes = (UINT_8)AUTH_TYPE_SHARED_KEY;
425 case AUTH_MODE_AUTO_SWITCH:
426 DBGLOG(P2P, LOUD, ("JOIN INIT: eAuthMode == AUTH_MODE_AUTO_SWITCH\n"));
427 prJoinInfo->ucAvailableAuthTypes = (UINT_8)(AUTH_TYPE_OPEN_SYSTEM |
428 AUTH_TYPE_SHARED_KEY);
431 ASSERT(!(prP2pConnSettings->eAuthMode == AUTH_MODE_WPA_NONE));
432 DBGLOG(P2P, ERROR, ("JOIN INIT: Auth Algorithm : %d was not supported by JOIN\n",
433 prP2pConnSettings->eAuthMode));
434 /* TODO(Kevin): error handling ? */
437 prStaRec->ucTxAuthAssocRetryLimit = TX_AUTH_ASSOCI_RETRY_LIMIT;
441 // TODO: Shall we considering ROAMIN case for P2P Device?.
445 //2 <4> Use an appropriate Authentication Algorithm Number among the ucAvailableAuthTypes.
446 if (prJoinInfo->ucAvailableAuthTypes &
447 (UINT_8)AUTH_TYPE_OPEN_SYSTEM) {
449 DBGLOG(P2P, TRACE, ("JOIN INIT: Try to do Authentication with AuthType == OPEN_SYSTEM.\n"));
451 prJoinInfo->ucAvailableAuthTypes &=
452 ~(UINT_8)AUTH_TYPE_OPEN_SYSTEM;
454 prStaRec->ucAuthAlgNum = (UINT_8)AUTH_ALGORITHM_NUM_OPEN_SYSTEM;
456 else if (prJoinInfo->ucAvailableAuthTypes &
457 (UINT_8)AUTH_TYPE_SHARED_KEY) {
459 DBGLOG(P2P, TRACE, ("JOIN INIT: Try to do Authentication with AuthType == SHARED_KEY.\n"));
461 prJoinInfo->ucAvailableAuthTypes &=
462 ~(UINT_8)AUTH_TYPE_SHARED_KEY;
464 prStaRec->ucAuthAlgNum = (UINT_8)AUTH_ALGORITHM_NUM_SHARED_KEY;
466 else if (prJoinInfo->ucAvailableAuthTypes &
467 (UINT_8)AUTH_TYPE_FAST_BSS_TRANSITION) {
469 DBGLOG(P2P, TRACE, ("JOIN INIT: Try to do Authentication with AuthType == FAST_BSS_TRANSITION.\n"));
471 prJoinInfo->ucAvailableAuthTypes &=
472 ~(UINT_8)AUTH_TYPE_FAST_BSS_TRANSITION;
474 prStaRec->ucAuthAlgNum = (UINT_8)AUTH_ALGORITHM_NUM_FAST_BSS_TRANSITION;
481 //4 <5> Overwrite Connection Setting for eConnectionPolicy == ANY (Used by Assoc Req)
482 if (prBssDesc->ucSSIDLen) {
483 COPY_SSID(prJoinInfo->rSsidStruct.aucSsid,
484 prJoinInfo->rSsidStruct.ucSsidLen,
486 prBssDesc->ucSSIDLen);
489 //2 <5> Backup desired channel.
491 //2 <6> Send a Msg to trigger SAA to start JOIN process.
492 prJoinReqMsg = (P_MSG_JOIN_REQ_T)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_JOIN_REQ_T));
495 DBGLOG(P2P, TRACE, ("Allocation Join Message Fail\n"));
500 prJoinReqMsg->rMsgHdr.eMsgId = MID_P2P_SAA_FSM_START;
501 prJoinReqMsg->ucSeqNum = ++prJoinInfo->ucSeqNumOfReqMsg;
502 prJoinReqMsg->prStaRec = prStaRec;
504 // TODO: Consider fragmentation info in station record.
506 mboxSendMsg(prAdapter,
508 (P_MSG_HDR_T)prJoinReqMsg,
509 MSG_SEND_METHOD_BUF);
517 } /* p2pStateInit_GC_JOIN */
521 /*----------------------------------------------------------------------------*/
523 * @brief Process of JOIN Abort. Leave JOIN State & Abort JOIN.
529 /*----------------------------------------------------------------------------*/
531 p2pStateAbort_GC_JOIN (
532 IN P_ADAPTER_T prAdapter,
533 IN P_P2P_FSM_INFO_T prP2pFsmInfo,
534 IN P_P2P_JOIN_INFO_T prJoinInfo,
535 IN ENUM_P2P_STATE_T eNextState
538 P_MSG_JOIN_ABORT_T prJoinAbortMsg = (P_MSG_JOIN_ABORT_T)NULL;
542 ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL) && (prJoinInfo != NULL));
544 if (prJoinInfo->fgIsJoinComplete == FALSE) {
546 prJoinAbortMsg = (P_MSG_JOIN_ABORT_T)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_JOIN_ABORT_T));
547 if (!prJoinAbortMsg) {
548 DBGLOG(P2P, TRACE, ("Fail to allocate join abort message buffer\n"));
553 prJoinAbortMsg->rMsgHdr.eMsgId = MID_P2P_SAA_FSM_ABORT;
554 prJoinAbortMsg->ucSeqNum = prJoinInfo->ucSeqNumOfReqMsg;
555 prJoinAbortMsg->prStaRec = prJoinInfo->prTargetStaRec;
557 mboxSendMsg(prAdapter,
559 (P_MSG_HDR_T)prJoinAbortMsg,
560 MSG_SEND_METHOD_BUF);
564 /* Stop Join Timer. */
565 cnmTimerStopTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer));
567 /* Release channel requested. */
568 p2pFuncReleaseCh(prAdapter, &(prP2pFsmInfo->rChnlReqInfo));
574 } /* p2pStateAbort_GC_JOIN */