[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / misc / mediatek / connectivity / combo / drv_wlan / mt6620 / wlan / mgmt / p2p_state.c

#include "p2p_precomp.h"


BOOLEAN
p2pStateInit_IDLE(IN P_ADAPTER_T prAdapter,
		  IN P_P2P_FSM_INFO_T prP2pFsmInfo,
		  IN P_BSS_INFO_T prP2pBssInfo, OUT P_ENUM_P2P_STATE_T peNextState)
{
	BOOLEAN fgIsTransOut = FALSE;
/* P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T)NULL; */

	do {
		ASSERT_BREAK((prAdapter != NULL) &&
			     (prP2pFsmInfo != NULL) &&
			     (prP2pBssInfo != NULL) && (peNextState != NULL));

		if ((prP2pBssInfo->eIntendOPMode == OP_MODE_ACCESS_POINT)
		    && IS_NET_PWR_STATE_ACTIVE(prAdapter, NETWORK_TYPE_P2P_INDEX)) {
			P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);

			fgIsTransOut = TRUE;
			prChnlReqInfo->eChannelReqType = CHANNEL_REQ_TYPE_GO_START_BSS;
			*peNextState = P2P_STATE_REQING_CHANNEL;

		} else {
#if 0
			else
		if (IS_NET_PWR_STATE_ACTIVE(prAdapter, NETWORK_TYPE_P2P_INDEX)) {

			ASSERT((prP2pBssInfo->eCurrentOPMode == OP_MODE_ACCESS_POINT) ||
			       (prP2pBssInfo->eCurrentOPMode == OP_MODE_INFRASTRUCTURE));

			prChnlReqInfo = &prP2pFsmInfo->rChnlReqInfo;

			if (prChnlReqInfo->fgIsChannelRequested) {
				/* Start a timer for return channel. */
				DBGLOG(P2P, TRACE, ("start a GO channel timer.\n"));
			}

		}
#endif
			cnmTimerStartTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer), 5000);
		}

	} while (FALSE);

	return fgIsTransOut;
}				/* p2pStateInit_IDLE */


VOID
p2pStateAbort_IDLE(IN P_ADAPTER_T prAdapter,
		   IN P_P2P_FSM_INFO_T prP2pFsmInfo, IN ENUM_P2P_STATE_T eNextState)
{

	P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T) NULL;

	do {
		ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));

		prChnlReqInfo = &prP2pFsmInfo->rChnlReqInfo;


		if (prChnlReqInfo->fgIsChannelRequested) {
			/* Release channel before timeout. */
			p2pFuncReleaseCh(prAdapter, prChnlReqInfo);
		}


		/* Stop timer for leaving this state. */
		cnmTimerStopTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer));

	} while (FALSE);

	return;
}				/* p2pStateAbort_IDLE */


VOID
p2pStateInit_CHNL_ON_HAND(IN P_ADAPTER_T prAdapter,
			  IN P_BSS_INFO_T prP2pBssInfo, IN P_P2P_FSM_INFO_T prP2pFsmInfo)
{
	P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T) NULL;

	do {
		ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));

		prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);

		/* Store the original channel info. */
		prChnlReqInfo->ucOriChnlNum = prP2pBssInfo->ucPrimaryChannel;
		prChnlReqInfo->eOriBand = prP2pBssInfo->eBand;
		prChnlReqInfo->eOriChnlSco = prP2pBssInfo->eBssSCO;

		/* RX Probe Request would check primary channel. */
		prP2pBssInfo->ucPrimaryChannel = prChnlReqInfo->ucReqChnlNum;
		prP2pBssInfo->eBand = prChnlReqInfo->eBand;
		prP2pBssInfo->eBssSCO = prChnlReqInfo->eChnlSco;


		DBGLOG(P2P, TRACE, ("start a channel on hand timer.\n"));
		cnmTimerStartTimer(prAdapter,
				   &(prP2pFsmInfo->rP2pFsmTimeoutTimer),
				   prChnlReqInfo->u4MaxInterval);

		kalP2PIndicateChannelReady(prAdapter->prGlueInfo,
					   prChnlReqInfo->u8Cookie,
					   prChnlReqInfo->ucReqChnlNum,
					   prChnlReqInfo->eBand,
					   prChnlReqInfo->eChnlSco, prChnlReqInfo->u4MaxInterval);

	} while (FALSE);

	return;
}				/* p2pStateInit_CHNL_ON_HAND */


VOID
p2pStateAbort_CHNL_ON_HAND(IN P_ADAPTER_T prAdapter,
			   IN P_P2P_FSM_INFO_T prP2pFsmInfo,
			   IN P_BSS_INFO_T prP2pBssInfo, IN ENUM_P2P_STATE_T eNextState)
{
	P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T) NULL;


	do {
		ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));

		prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);

		cnmTimerStopTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer));

		/* Restore the original channel info. */
		prP2pBssInfo->ucPrimaryChannel = prChnlReqInfo->ucOriChnlNum;
		prP2pBssInfo->eBand = prChnlReqInfo->eOriBand;
		prP2pBssInfo->eBssSCO = prChnlReqInfo->eOriChnlSco;

		if (eNextState != P2P_STATE_CHNL_ON_HAND) {
			/* Indicate channel return. */
			kalP2PIndicateChannelExpired(prAdapter->prGlueInfo,
						     &prP2pFsmInfo->rChnlReqInfo);

			/* Return Channel. */
			p2pFuncReleaseCh(prAdapter, &(prP2pFsmInfo->rChnlReqInfo));
		}

	} while (FALSE);
	return;
}				/* p2pStateAbort_CHNL_ON_HAND */


VOID
p2pStateAbort_REQING_CHANNEL(IN P_ADAPTER_T prAdapter,
			     IN P_P2P_FSM_INFO_T prP2pFsmInfo, IN ENUM_P2P_STATE_T eNextState)
{
	P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T) NULL;
	P_P2P_SPECIFIC_BSS_INFO_T prP2pSpecificBssInfo = (P_P2P_SPECIFIC_BSS_INFO_T) NULL;

	do {

		ASSERT_BREAK((prAdapter != NULL) &&
			     (prP2pFsmInfo != NULL) && (eNextState < P2P_STATE_NUM));

		prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
		prP2pSpecificBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;

		if (eNextState == P2P_STATE_IDLE) {
			if (prP2pBssInfo->eIntendOPMode == OP_MODE_ACCESS_POINT) {
				/* Intend to be AP. */
				/* Setup for AP mode. */
				p2pFuncStartGO(prAdapter,
					       prP2pBssInfo,
					       prP2pSpecificBssInfo->aucGroupSsid,
					       prP2pSpecificBssInfo->u2GroupSsidLen,
					       prP2pSpecificBssInfo->ucPreferredChannel,
					       prP2pSpecificBssInfo->eRfBand,
					       prP2pSpecificBssInfo->eRfSco,
					       prP2pFsmInfo->fgIsApMode);

			} else {
				/* Return Channel. */
				p2pFuncReleaseCh(prAdapter, &(prP2pFsmInfo->rChnlReqInfo));
			}

		}


	} while (FALSE);

	return;
}				/* p2pStateInit_AP_CHANNEL_DETECT */


VOID p2pStateInit_AP_CHANNEL_DETECT(IN P_ADAPTER_T prAdapter, IN P_P2P_FSM_INFO_T prP2pFsmInfo)
{
	P_P2P_SCAN_REQ_INFO_T prScanReqInfo = (P_P2P_SCAN_REQ_INFO_T) NULL;

	do {
		ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));

		prScanReqInfo = &(prP2pFsmInfo->rScanReqInfo);

		prScanReqInfo->eScanType = SCAN_TYPE_PASSIVE_SCAN;
		prScanReqInfo->eChannelSet = SCAN_CHANNEL_2G4;
		prScanReqInfo->u2PassiveDewellTime = 50;	/* 50ms for passive channel load detection */
		prScanReqInfo->fgIsAbort = TRUE;
		prScanReqInfo->fgIsScanRequest = TRUE;
		prScanReqInfo->ucNumChannelList = 0;
		prScanReqInfo->u4BufLength = 0;
		prScanReqInfo->rSsidStruct.ucSsidLen = 0;

		p2pFuncRequestScan(prAdapter, prScanReqInfo);

	} while (FALSE);

	return;
}				/* p2pStateInit_AP_CHANNEL_DETECT */


VOID
p2pStateAbort_AP_CHANNEL_DETECT(IN P_ADAPTER_T prAdapter,
				IN P_P2P_FSM_INFO_T prP2pFsmInfo,
				IN P_P2P_SPECIFIC_BSS_INFO_T prP2pSpecificBssInfo,
				IN ENUM_P2P_STATE_T eNextState)
{
	P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T) NULL;
	P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T) NULL;

	do {

		if (eNextState == P2P_STATE_REQING_CHANNEL) {
			UINT_8 ucPreferedChnl = 0;
			ENUM_BAND_T eBand = BAND_NULL;
			ENUM_CHNL_EXT_T eSco = CHNL_EXT_SCN;

			prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);

			/* Determine the channel for AP. */
			if (cnmPreferredChannel(prAdapter, &eBand, &ucPreferedChnl, &eSco) == FALSE) {

				prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;

				if ((ucPreferedChnl = prP2pConnSettings->ucOperatingChnl) == 0) {

					if (scnQuerySparseChannel
					    (prAdapter, &eBand, &ucPreferedChnl) == FALSE) {

						/* What to do? */
						ASSERT(FALSE);
						/* TODO: Pick up a valid channel from channel list. */
						ucPreferedChnl = 1;
						eBand = BAND_2G4;
					}
				}
			}


			prChnlReqInfo->eChannelReqType = CHANNEL_REQ_TYPE_GO_START_BSS;
			prChnlReqInfo->ucReqChnlNum = prP2pSpecificBssInfo->ucPreferredChannel =
			    ucPreferedChnl;
			prChnlReqInfo->eBand = prP2pSpecificBssInfo->eRfBand = eBand;
			prChnlReqInfo->eChnlSco = prP2pSpecificBssInfo->eRfSco = eSco;
		} else {
			p2pFuncCancelScan(prAdapter, &(prP2pFsmInfo->rScanReqInfo));
		}


	} while (FALSE);

	return;
}				/* p2pStateAbort_AP_CHANNEL_DETECT */


VOID p2pStateInit_SCAN(IN P_ADAPTER_T prAdapter, IN P_P2P_FSM_INFO_T prP2pFsmInfo)
{
	P_P2P_SCAN_REQ_INFO_T prScanReqInfo = (P_P2P_SCAN_REQ_INFO_T) NULL;

	do {

		ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));

		prScanReqInfo = &prP2pFsmInfo->rScanReqInfo;

		prScanReqInfo->fgIsScanRequest = TRUE;

		p2pFuncRequestScan(prAdapter, prScanReqInfo);

	} while (FALSE);
	return;
}				/* p2pStateInit_SCAN */


VOID
p2pStateAbort_SCAN(IN P_ADAPTER_T prAdapter,
		   IN P_P2P_FSM_INFO_T prP2pFsmInfo, IN ENUM_P2P_STATE_T eNextState)
{
	do {
		ASSERT_BREAK(prAdapter != NULL);

		/* 1. Scan cancel. (Make sure the scan request is invalid. */
		p2pFuncCancelScan(prAdapter, &(prP2pFsmInfo->rScanReqInfo));

		/* Scan done indication. */
		kalP2PIndicateScanDone(prAdapter->prGlueInfo, prP2pFsmInfo->rScanReqInfo.fgIsAbort);
	} while (FALSE);

	return;
}				/* p2pStateAbort_SCAN */


VOID
p2pStateInit_GC_JOIN(IN P_ADAPTER_T prAdapter,
		     IN P_P2P_FSM_INFO_T prP2pFsmInfo,
		     IN P_BSS_INFO_T prP2pBssInfo,
		     IN P_P2P_JOIN_INFO_T prJoinInfo, IN P_BSS_DESC_T prBssDesc)
{
	P_MSG_JOIN_REQ_T prJoinReqMsg = (P_MSG_JOIN_REQ_T) NULL;
	P_STA_RECORD_T prStaRec = (P_STA_RECORD_T) NULL;
	P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T) NULL;

	do {
		ASSERT_BREAK((prAdapter != NULL) &&
			     (prP2pFsmInfo != NULL) &&
			     (prP2pBssInfo != NULL) && (prJoinInfo != NULL) && (prBssDesc != NULL));

		prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;

		if (prBssDesc->ucSSIDLen) {
			COPY_SSID(prP2pConnSettings->aucSSID,
				  prP2pConnSettings->ucSSIDLen,
				  prBssDesc->aucSSID, prBssDesc->ucSSIDLen);
		}

		/* Setup a join timer. */
		DBGLOG(P2P, TRACE, ("Start a join init timer\n"));
		cnmTimerStartTimer(prAdapter,
				   &(prP2pFsmInfo->rP2pFsmTimeoutTimer),
				   (prP2pFsmInfo->u4GrantInterval - AIS_JOIN_CH_GRANT_THRESHOLD));

		/* 2 <1> We are goin to connect to this BSS */
		prBssDesc->fgIsConnecting = TRUE;

		/* 2 <2> Setup corresponding STA_RECORD_T */
		prStaRec = bssCreateStaRecFromBssDesc(prAdapter,
						      (prBssDesc->
						       fgIsP2PPresent ? (STA_TYPE_P2P_GO)
						       : (STA_TYPE_LEGACY_AP)),
						      NETWORK_TYPE_P2P_INDEX, prBssDesc);

		if (prStaRec == NULL) {
			DBGLOG(P2P, TRACE, ("Create station record fail\n"));
			break;
		}


		prJoinInfo->prTargetStaRec = prStaRec;
		prJoinInfo->fgIsJoinComplete = FALSE;
		prJoinInfo->u4BufLength = 0;

		/* 2 <2.1> Sync. to FW domain */
		cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);


		if (prP2pBssInfo->eConnectionState == PARAM_MEDIA_STATE_DISCONNECTED) {
			P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings =
			    (P_P2P_CONNECTION_SETTINGS_T) NULL;

			prStaRec->fgIsReAssoc = FALSE;

			prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;

			switch (prP2pConnSettings->eAuthMode) {
			case AUTH_MODE_OPEN:	/* Note: Omit break here. */
			case AUTH_MODE_WPA:
			case AUTH_MODE_WPA_PSK:
			case AUTH_MODE_WPA2:
			case AUTH_MODE_WPA2_PSK:
				prJoinInfo->ucAvailableAuthTypes = (UINT_8) AUTH_TYPE_OPEN_SYSTEM;
				break;
			case AUTH_MODE_SHARED:
				prJoinInfo->ucAvailableAuthTypes = (UINT_8) AUTH_TYPE_SHARED_KEY;
				break;
			case AUTH_MODE_AUTO_SWITCH:
				DBGLOG(P2P, LOUD,
				       ("JOIN INIT: eAuthMode == AUTH_MODE_AUTO_SWITCH\n"));
				prJoinInfo->ucAvailableAuthTypes =
				    (UINT_8) (AUTH_TYPE_OPEN_SYSTEM | AUTH_TYPE_SHARED_KEY);
				break;
			default:
				ASSERT(!(prP2pConnSettings->eAuthMode == AUTH_MODE_WPA_NONE));
				DBGLOG(P2P, ERROR,
				       ("JOIN INIT: Auth Algorithm : %d was not supported by JOIN\n",
					prP2pConnSettings->eAuthMode));
				/* TODO(Kevin): error handling ? */
				return;
			}
			prStaRec->ucTxAuthAssocRetryLimit = TX_AUTH_ASSOCI_RETRY_LIMIT;
		} else {
			ASSERT(FALSE);
			/* TODO: Shall we considering ROAMIN case for P2P Device?. */
		}


		/* 2 <4> Use an appropriate Authentication Algorithm Number among the ucAvailableAuthTypes. */
		if (prJoinInfo->ucAvailableAuthTypes & (UINT_8) AUTH_TYPE_OPEN_SYSTEM) {

			DBGLOG(P2P, TRACE,
			       ("JOIN INIT: Try to do Authentication with AuthType == OPEN_SYSTEM.\n"));

			prJoinInfo->ucAvailableAuthTypes &= ~(UINT_8) AUTH_TYPE_OPEN_SYSTEM;

			prStaRec->ucAuthAlgNum = (UINT_8) AUTH_ALGORITHM_NUM_OPEN_SYSTEM;
		} else if (prJoinInfo->ucAvailableAuthTypes & (UINT_8) AUTH_TYPE_SHARED_KEY) {

			DBGLOG(P2P, TRACE,
			       ("JOIN INIT: Try to do Authentication with AuthType == SHARED_KEY.\n"));

			prJoinInfo->ucAvailableAuthTypes &= ~(UINT_8) AUTH_TYPE_SHARED_KEY;

			prStaRec->ucAuthAlgNum = (UINT_8) AUTH_ALGORITHM_NUM_SHARED_KEY;
		} else if (prJoinInfo->ucAvailableAuthTypes &
			   (UINT_8) AUTH_TYPE_FAST_BSS_TRANSITION) {

			DBGLOG(P2P, TRACE,
			       ("JOIN INIT: Try to do Authentication with AuthType == FAST_BSS_TRANSITION.\n"));

			prJoinInfo->ucAvailableAuthTypes &= ~(UINT_8) AUTH_TYPE_FAST_BSS_TRANSITION;

			prStaRec->ucAuthAlgNum = (UINT_8) AUTH_ALGORITHM_NUM_FAST_BSS_TRANSITION;
		} else {
			ASSERT(0);
		}


		/* 4 <5> Overwrite Connection Setting for eConnectionPolicy == ANY (Used by Assoc Req) */
		if (prBssDesc->ucSSIDLen) {
			COPY_SSID(prJoinInfo->rSsidStruct.aucSsid,
				  prJoinInfo->rSsidStruct.ucSsidLen,
				  prBssDesc->aucSSID, prBssDesc->ucSSIDLen);
		}
		/* 2 <5> Backup desired channel. */

		/* 2 <6> Send a Msg to trigger SAA to start JOIN process. */
		prJoinReqMsg =
		    (P_MSG_JOIN_REQ_T) cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_JOIN_REQ_T));

		if (!prJoinReqMsg) {
			DBGLOG(P2P, TRACE, ("Allocation Join Message Fail\n"));
			ASSERT(FALSE);
			return;
		}

		prJoinReqMsg->rMsgHdr.eMsgId = MID_P2P_SAA_FSM_START;
		prJoinReqMsg->ucSeqNum = ++prJoinInfo->ucSeqNumOfReqMsg;
		prJoinReqMsg->prStaRec = prStaRec;

		/* TODO: Consider fragmentation info in station record. */

		mboxSendMsg(prAdapter, MBOX_ID_0, (P_MSG_HDR_T) prJoinReqMsg, MSG_SEND_METHOD_BUF);


	} while (FALSE);

	return;
}				/* p2pStateInit_GC_JOIN */


/*----------------------------------------------------------------------------*/
/*!
* @brief Process of JOIN Abort. Leave JOIN State & Abort JOIN.
*
* @param (none)
*
* @return (none)
*/
/*----------------------------------------------------------------------------*/
VOID
p2pStateAbort_GC_JOIN(IN P_ADAPTER_T prAdapter,
		      IN P_P2P_FSM_INFO_T prP2pFsmInfo,
		      IN P_P2P_JOIN_INFO_T prJoinInfo, IN ENUM_P2P_STATE_T eNextState)
{
	P_MSG_JOIN_ABORT_T prJoinAbortMsg = (P_MSG_JOIN_ABORT_T) NULL;


	do {
		ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL) && (prJoinInfo != NULL));

		if (prJoinInfo->fgIsJoinComplete == FALSE) {

			prJoinAbortMsg =
			    (P_MSG_JOIN_ABORT_T) cnmMemAlloc(prAdapter, RAM_TYPE_MSG,
							     sizeof(MSG_JOIN_ABORT_T));
			if (!prJoinAbortMsg) {
				DBGLOG(P2P, TRACE,
				       ("Fail to allocate join abort message buffer\n"));
				ASSERT(FALSE);
				return;
			}

			prJoinAbortMsg->rMsgHdr.eMsgId = MID_P2P_SAA_FSM_ABORT;
			prJoinAbortMsg->ucSeqNum = prJoinInfo->ucSeqNumOfReqMsg;
			prJoinAbortMsg->prStaRec = prJoinInfo->prTargetStaRec;

			mboxSendMsg(prAdapter,
				    MBOX_ID_0, (P_MSG_HDR_T) prJoinAbortMsg, MSG_SEND_METHOD_BUF);

		}

		/* Stop Join Timer. */
		cnmTimerStopTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer));

		/* Release channel requested. */
		p2pFuncReleaseCh(prAdapter, &(prP2pFsmInfo->rChnlReqInfo));

	} while (FALSE);

	return;

}				/* p2pStateAbort_GC_JOIN */
Commit	Line	Data
6fa3eb70 S	1	#include "p2p_precomp.h"
	2
	3
	4	BOOLEAN
	5	p2pStateInit_IDLE(IN P_ADAPTER_T prAdapter,
	6	IN P_P2P_FSM_INFO_T prP2pFsmInfo,
	7	IN P_BSS_INFO_T prP2pBssInfo, OUT P_ENUM_P2P_STATE_T peNextState)
	8	{
	9	BOOLEAN fgIsTransOut = FALSE;
	10	/* P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T)NULL; */
	11
	12	do {
	13	ASSERT_BREAK((prAdapter != NULL) &&
	14	(prP2pFsmInfo != NULL) &&
	15	(prP2pBssInfo != NULL) && (peNextState != NULL));
	16
	17	if ((prP2pBssInfo->eIntendOPMode == OP_MODE_ACCESS_POINT)
	18	&& IS_NET_PWR_STATE_ACTIVE(prAdapter, NETWORK_TYPE_P2P_INDEX)) {
	19	P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);
	20
	21	fgIsTransOut = TRUE;
	22	prChnlReqInfo->eChannelReqType = CHANNEL_REQ_TYPE_GO_START_BSS;
	23	*peNextState = P2P_STATE_REQING_CHANNEL;
	24
	25	} else {
	26	#if 0
	27	else
	28	if (IS_NET_PWR_STATE_ACTIVE(prAdapter, NETWORK_TYPE_P2P_INDEX)) {
	29
	30	ASSERT((prP2pBssInfo->eCurrentOPMode == OP_MODE_ACCESS_POINT) \|\|
	31	(prP2pBssInfo->eCurrentOPMode == OP_MODE_INFRASTRUCTURE));
	32
	33	prChnlReqInfo = &prP2pFsmInfo->rChnlReqInfo;
	34
	35	if (prChnlReqInfo->fgIsChannelRequested) {
	36	/* Start a timer for return channel. */
	37	DBGLOG(P2P, TRACE, ("start a GO channel timer.\n"));
	38	}
	39
	40	}
	41	#endif
	42	cnmTimerStartTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer), 5000);
	43	}
	44
	45	} while (FALSE);
	46
	47	return fgIsTransOut;
	48	} /* p2pStateInit_IDLE */
	49
	50
	51	VOID
	52	p2pStateAbort_IDLE(IN P_ADAPTER_T prAdapter,
	53	IN P_P2P_FSM_INFO_T prP2pFsmInfo, IN ENUM_P2P_STATE_T eNextState)
	54	{
	55
	56	P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T) NULL;
	57
	58	do {
	59	ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));
	60
	61	prChnlReqInfo = &prP2pFsmInfo->rChnlReqInfo;
	62
	63
	64	if (prChnlReqInfo->fgIsChannelRequested) {
65	/* Release channel before timeout. */
66	p2pFuncReleaseCh(prAdapter, prChnlReqInfo);
67	}
68
69
70	/* Stop timer for leaving this state. */
71	cnmTimerStopTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer));
72
73	} while (FALSE);
74
75	return;
76	} /* p2pStateAbort_IDLE */
77
78
79
80	VOID
81	p2pStateInit_CHNL_ON_HAND(IN P_ADAPTER_T prAdapter,
82	IN P_BSS_INFO_T prP2pBssInfo, IN P_P2P_FSM_INFO_T prP2pFsmInfo)
83	{
84	P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T) NULL;
85
86	do {
87	ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));
88
89	prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);
90
91	/* Store the original channel info. */
92	prChnlReqInfo->ucOriChnlNum = prP2pBssInfo->ucPrimaryChannel;
93	prChnlReqInfo->eOriBand = prP2pBssInfo->eBand;
94	prChnlReqInfo->eOriChnlSco = prP2pBssInfo->eBssSCO;
95
96	/* RX Probe Request would check primary channel. */
97	prP2pBssInfo->ucPrimaryChannel = prChnlReqInfo->ucReqChnlNum;
98	prP2pBssInfo->eBand = prChnlReqInfo->eBand;
99	prP2pBssInfo->eBssSCO = prChnlReqInfo->eChnlSco;
100
101
102	DBGLOG(P2P, TRACE, ("start a channel on hand timer.\n"));
103	cnmTimerStartTimer(prAdapter,
104	&(prP2pFsmInfo->rP2pFsmTimeoutTimer),
105	prChnlReqInfo->u4MaxInterval);
106
107	kalP2PIndicateChannelReady(prAdapter->prGlueInfo,
108	prChnlReqInfo->u8Cookie,
109	prChnlReqInfo->ucReqChnlNum,
110	prChnlReqInfo->eBand,
111	prChnlReqInfo->eChnlSco, prChnlReqInfo->u4MaxInterval);
112
113	} while (FALSE);
114
115	return;
116	} /* p2pStateInit_CHNL_ON_HAND */
117
118
119	VOID
120	p2pStateAbort_CHNL_ON_HAND(IN P_ADAPTER_T prAdapter,
121	IN P_P2P_FSM_INFO_T prP2pFsmInfo,
122	IN P_BSS_INFO_T prP2pBssInfo, IN ENUM_P2P_STATE_T eNextState)
123	{
124	P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T) NULL;
125
126
127	do {
128	ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));
129
130	prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);
131
132	cnmTimerStopTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer));
133
134	/* Restore the original channel info. */
135	prP2pBssInfo->ucPrimaryChannel = prChnlReqInfo->ucOriChnlNum;
136	prP2pBssInfo->eBand = prChnlReqInfo->eOriBand;
137	prP2pBssInfo->eBssSCO = prChnlReqInfo->eOriChnlSco;
138
139	if (eNextState != P2P_STATE_CHNL_ON_HAND) {
140	/* Indicate channel return. */
141	kalP2PIndicateChannelExpired(prAdapter->prGlueInfo,
142	&prP2pFsmInfo->rChnlReqInfo);
143
144	/* Return Channel. */
145	p2pFuncReleaseCh(prAdapter, &(prP2pFsmInfo->rChnlReqInfo));
146	}
147
148	} while (FALSE);
149	return;
150	} /* p2pStateAbort_CHNL_ON_HAND */
151
152
153	VOID
154	p2pStateAbort_REQING_CHANNEL(IN P_ADAPTER_T prAdapter,
155	IN P_P2P_FSM_INFO_T prP2pFsmInfo, IN ENUM_P2P_STATE_T eNextState)
156	{
157	P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T) NULL;
158	P_P2P_SPECIFIC_BSS_INFO_T prP2pSpecificBssInfo = (P_P2P_SPECIFIC_BSS_INFO_T) NULL;
159
160	do {
161
162	ASSERT_BREAK((prAdapter != NULL) &&
163	(prP2pFsmInfo != NULL) && (eNextState < P2P_STATE_NUM));
164
165	prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
166	prP2pSpecificBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;
167
168	if (eNextState == P2P_STATE_IDLE) {
169	if (prP2pBssInfo->eIntendOPMode == OP_MODE_ACCESS_POINT) {
170	/* Intend to be AP. */
171	/* Setup for AP mode. */
172	p2pFuncStartGO(prAdapter,
173	prP2pBssInfo,
174	prP2pSpecificBssInfo->aucGroupSsid,
175	prP2pSpecificBssInfo->u2GroupSsidLen,
176	prP2pSpecificBssInfo->ucPreferredChannel,
177	prP2pSpecificBssInfo->eRfBand,
178	prP2pSpecificBssInfo->eRfSco,
179	prP2pFsmInfo->fgIsApMode);
180
181	} else {
182	/* Return Channel. */
183	p2pFuncReleaseCh(prAdapter, &(prP2pFsmInfo->rChnlReqInfo));
184	}
185
186	}
187
188
189	} while (FALSE);
190
191	return;
192	} /* p2pStateInit_AP_CHANNEL_DETECT */
193
194
195	VOID p2pStateInit_AP_CHANNEL_DETECT(IN P_ADAPTER_T prAdapter, IN P_P2P_FSM_INFO_T prP2pFsmInfo)
196	{
197	P_P2P_SCAN_REQ_INFO_T prScanReqInfo = (P_P2P_SCAN_REQ_INFO_T) NULL;
198
199	do {
200	ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));
201
202	prScanReqInfo = &(prP2pFsmInfo->rScanReqInfo);
203
204	prScanReqInfo->eScanType = SCAN_TYPE_PASSIVE_SCAN;
205	prScanReqInfo->eChannelSet = SCAN_CHANNEL_2G4;
206	prScanReqInfo->u2PassiveDewellTime = 50; /* 50ms for passive channel load detection */
207	prScanReqInfo->fgIsAbort = TRUE;
208	prScanReqInfo->fgIsScanRequest = TRUE;
209	prScanReqInfo->ucNumChannelList = 0;
210	prScanReqInfo->u4BufLength = 0;
211	prScanReqInfo->rSsidStruct.ucSsidLen = 0;
212
213	p2pFuncRequestScan(prAdapter, prScanReqInfo);
214
215	} while (FALSE);
216
217	return;
218	} /* p2pStateInit_AP_CHANNEL_DETECT */
219
220
221
222	VOID
223	p2pStateAbort_AP_CHANNEL_DETECT(IN P_ADAPTER_T prAdapter,
224	IN P_P2P_FSM_INFO_T prP2pFsmInfo,
225	IN P_P2P_SPECIFIC_BSS_INFO_T prP2pSpecificBssInfo,
226	IN ENUM_P2P_STATE_T eNextState)
227	{
228	P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = (P_P2P_CHNL_REQ_INFO_T) NULL;
229	P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T) NULL;
230
231	do {
232
233	if (eNextState == P2P_STATE_REQING_CHANNEL) {
234	UINT_8 ucPreferedChnl = 0;
235	ENUM_BAND_T eBand = BAND_NULL;
236	ENUM_CHNL_EXT_T eSco = CHNL_EXT_SCN;
237
238	prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);
239
240	/* Determine the channel for AP. */
241	if (cnmPreferredChannel(prAdapter, &eBand, &ucPreferedChnl, &eSco) == FALSE) {
242
243	prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
244
245	if ((ucPreferedChnl = prP2pConnSettings->ucOperatingChnl) == 0) {
246
247	if (scnQuerySparseChannel
248	(prAdapter, &eBand, &ucPreferedChnl) == FALSE) {
249
250	/* What to do? */
251	ASSERT(FALSE);
252	/* TODO: Pick up a valid channel from channel list. */
253	ucPreferedChnl = 1;
254	eBand = BAND_2G4;
255	}
256	}
257	}
258
259
260	prChnlReqInfo->eChannelReqType = CHANNEL_REQ_TYPE_GO_START_BSS;
261	prChnlReqInfo->ucReqChnlNum = prP2pSpecificBssInfo->ucPreferredChannel =
262	ucPreferedChnl;
263	prChnlReqInfo->eBand = prP2pSpecificBssInfo->eRfBand = eBand;
264	prChnlReqInfo->eChnlSco = prP2pSpecificBssInfo->eRfSco = eSco;
265	} else {
266	p2pFuncCancelScan(prAdapter, &(prP2pFsmInfo->rScanReqInfo));
267	}
268
269
270	} while (FALSE);
271
272	return;
273	} /* p2pStateAbort_AP_CHANNEL_DETECT */
274
275
276	VOID p2pStateInit_SCAN(IN P_ADAPTER_T prAdapter, IN P_P2P_FSM_INFO_T prP2pFsmInfo)
277	{
278	P_P2P_SCAN_REQ_INFO_T prScanReqInfo = (P_P2P_SCAN_REQ_INFO_T) NULL;
279
280	do {
281
282	ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL));
283
284	prScanReqInfo = &prP2pFsmInfo->rScanReqInfo;
285
286	prScanReqInfo->fgIsScanRequest = TRUE;
287
288	p2pFuncRequestScan(prAdapter, prScanReqInfo);
289
290	} while (FALSE);
291	return;
292	} /* p2pStateInit_SCAN */
293
294
295	VOID
296	p2pStateAbort_SCAN(IN P_ADAPTER_T prAdapter,
297	IN P_P2P_FSM_INFO_T prP2pFsmInfo, IN ENUM_P2P_STATE_T eNextState)
298	{
299	do {
300	ASSERT_BREAK(prAdapter != NULL);
301
302	/* 1. Scan cancel. (Make sure the scan request is invalid. */
303	p2pFuncCancelScan(prAdapter, &(prP2pFsmInfo->rScanReqInfo));
304
305	/* Scan done indication. */
306	kalP2PIndicateScanDone(prAdapter->prGlueInfo, prP2pFsmInfo->rScanReqInfo.fgIsAbort);
307	} while (FALSE);
308
309	return;
310	} /* p2pStateAbort_SCAN */
311
312
313	VOID
314	p2pStateInit_GC_JOIN(IN P_ADAPTER_T prAdapter,
315	IN P_P2P_FSM_INFO_T prP2pFsmInfo,
316	IN P_BSS_INFO_T prP2pBssInfo,
317	IN P_P2P_JOIN_INFO_T prJoinInfo, IN P_BSS_DESC_T prBssDesc)
318	{
319	P_MSG_JOIN_REQ_T prJoinReqMsg = (P_MSG_JOIN_REQ_T) NULL;
320	P_STA_RECORD_T prStaRec = (P_STA_RECORD_T) NULL;
321	P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T) NULL;
322
323	do {
324	ASSERT_BREAK((prAdapter != NULL) &&
325	(prP2pFsmInfo != NULL) &&
326	(prP2pBssInfo != NULL) && (prJoinInfo != NULL) && (prBssDesc != NULL));
327
328	prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
329
330	if (prBssDesc->ucSSIDLen) {
331	COPY_SSID(prP2pConnSettings->aucSSID,
332	prP2pConnSettings->ucSSIDLen,
333	prBssDesc->aucSSID, prBssDesc->ucSSIDLen);
334	}
335
336	/* Setup a join timer. */
337	DBGLOG(P2P, TRACE, ("Start a join init timer\n"));
338	cnmTimerStartTimer(prAdapter,
339	&(prP2pFsmInfo->rP2pFsmTimeoutTimer),
340	(prP2pFsmInfo->u4GrantInterval - AIS_JOIN_CH_GRANT_THRESHOLD));
341
342	/* 2 <1> We are goin to connect to this BSS */
343	prBssDesc->fgIsConnecting = TRUE;
344
345	/* 2 <2> Setup corresponding STA_RECORD_T */
346	prStaRec = bssCreateStaRecFromBssDesc(prAdapter,
347	(prBssDesc->
348	fgIsP2PPresent ? (STA_TYPE_P2P_GO)
349	: (STA_TYPE_LEGACY_AP)),
350	NETWORK_TYPE_P2P_INDEX, prBssDesc);
351
352	if (prStaRec == NULL) {
353	DBGLOG(P2P, TRACE, ("Create station record fail\n"));
354	break;
355	}
356
357
358	prJoinInfo->prTargetStaRec = prStaRec;
359	prJoinInfo->fgIsJoinComplete = FALSE;
360	prJoinInfo->u4BufLength = 0;
361
362	/* 2 <2.1> Sync. to FW domain */
363	cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
364
365
366	if (prP2pBssInfo->eConnectionState == PARAM_MEDIA_STATE_DISCONNECTED) {
367	P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings =
368	(P_P2P_CONNECTION_SETTINGS_T) NULL;
369
370	prStaRec->fgIsReAssoc = FALSE;
371
372	prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
373
374	switch (prP2pConnSettings->eAuthMode) {
375	case AUTH_MODE_OPEN: /* Note: Omit break here. */
376	case AUTH_MODE_WPA:
377	case AUTH_MODE_WPA_PSK:
378	case AUTH_MODE_WPA2:
379	case AUTH_MODE_WPA2_PSK:
380	prJoinInfo->ucAvailableAuthTypes = (UINT_8) AUTH_TYPE_OPEN_SYSTEM;
381	break;
382	case AUTH_MODE_SHARED:
383	prJoinInfo->ucAvailableAuthTypes = (UINT_8) AUTH_TYPE_SHARED_KEY;
384	break;
385	case AUTH_MODE_AUTO_SWITCH:
386	DBGLOG(P2P, LOUD,
387	("JOIN INIT: eAuthMode == AUTH_MODE_AUTO_SWITCH\n"));
388	prJoinInfo->ucAvailableAuthTypes =
389	(UINT_8) (AUTH_TYPE_OPEN_SYSTEM \| AUTH_TYPE_SHARED_KEY);
390	break;
391	default:
392	ASSERT(!(prP2pConnSettings->eAuthMode == AUTH_MODE_WPA_NONE));
393	DBGLOG(P2P, ERROR,
394	("JOIN INIT: Auth Algorithm : %d was not supported by JOIN\n",
395	prP2pConnSettings->eAuthMode));
396	/* TODO(Kevin): error handling ? */
397	return;
398	}
399	prStaRec->ucTxAuthAssocRetryLimit = TX_AUTH_ASSOCI_RETRY_LIMIT;
400	} else {
401	ASSERT(FALSE);
402	/* TODO: Shall we considering ROAMIN case for P2P Device?. */
403	}
404
405
406	/* 2 <4> Use an appropriate Authentication Algorithm Number among the ucAvailableAuthTypes. */
407	if (prJoinInfo->ucAvailableAuthTypes & (UINT_8) AUTH_TYPE_OPEN_SYSTEM) {
408
409	DBGLOG(P2P, TRACE,
410	("JOIN INIT: Try to do Authentication with AuthType == OPEN_SYSTEM.\n"));
411
412	prJoinInfo->ucAvailableAuthTypes &= ~(UINT_8) AUTH_TYPE_OPEN_SYSTEM;
413
414	prStaRec->ucAuthAlgNum = (UINT_8) AUTH_ALGORITHM_NUM_OPEN_SYSTEM;
415	} else if (prJoinInfo->ucAvailableAuthTypes & (UINT_8) AUTH_TYPE_SHARED_KEY) {
416
417	DBGLOG(P2P, TRACE,
418	("JOIN INIT: Try to do Authentication with AuthType == SHARED_KEY.\n"));
419
420	prJoinInfo->ucAvailableAuthTypes &= ~(UINT_8) AUTH_TYPE_SHARED_KEY;
421
422	prStaRec->ucAuthAlgNum = (UINT_8) AUTH_ALGORITHM_NUM_SHARED_KEY;
423	} else if (prJoinInfo->ucAvailableAuthTypes &
424	(UINT_8) AUTH_TYPE_FAST_BSS_TRANSITION) {
425
426	DBGLOG(P2P, TRACE,
427	("JOIN INIT: Try to do Authentication with AuthType == FAST_BSS_TRANSITION.\n"));
428
429	prJoinInfo->ucAvailableAuthTypes &= ~(UINT_8) AUTH_TYPE_FAST_BSS_TRANSITION;
430
431	prStaRec->ucAuthAlgNum = (UINT_8) AUTH_ALGORITHM_NUM_FAST_BSS_TRANSITION;
432	} else {
433	ASSERT(0);
434	}
435
436
437	/* 4 <5> Overwrite Connection Setting for eConnectionPolicy == ANY (Used by Assoc Req) */
438	if (prBssDesc->ucSSIDLen) {
439	COPY_SSID(prJoinInfo->rSsidStruct.aucSsid,
440	prJoinInfo->rSsidStruct.ucSsidLen,
441	prBssDesc->aucSSID, prBssDesc->ucSSIDLen);
442	}
443	/* 2 <5> Backup desired channel. */
444
445	/* 2 <6> Send a Msg to trigger SAA to start JOIN process. */
446	prJoinReqMsg =
447	(P_MSG_JOIN_REQ_T) cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_JOIN_REQ_T));
448
449	if (!prJoinReqMsg) {
450	DBGLOG(P2P, TRACE, ("Allocation Join Message Fail\n"));
451	ASSERT(FALSE);
452	return;
453	}
454
455	prJoinReqMsg->rMsgHdr.eMsgId = MID_P2P_SAA_FSM_START;
456	prJoinReqMsg->ucSeqNum = ++prJoinInfo->ucSeqNumOfReqMsg;
457	prJoinReqMsg->prStaRec = prStaRec;
458
459	/* TODO: Consider fragmentation info in station record. */
460
461	mboxSendMsg(prAdapter, MBOX_ID_0, (P_MSG_HDR_T) prJoinReqMsg, MSG_SEND_METHOD_BUF);
462
463
464
465
466	} while (FALSE);
467
468	return;
469	} /* p2pStateInit_GC_JOIN */
470
471
472
473	/----------------------------------------------------------------------------/
474	/*!
475	* @brief Process of JOIN Abort. Leave JOIN State & Abort JOIN.
476	*
477	* @param (none)
478	*
479	* @return (none)
480	*/
481	/----------------------------------------------------------------------------/
482	VOID
483	p2pStateAbort_GC_JOIN(IN P_ADAPTER_T prAdapter,
484	IN P_P2P_FSM_INFO_T prP2pFsmInfo,
485	IN P_P2P_JOIN_INFO_T prJoinInfo, IN ENUM_P2P_STATE_T eNextState)
486	{
487	P_MSG_JOIN_ABORT_T prJoinAbortMsg = (P_MSG_JOIN_ABORT_T) NULL;
488
489
490	do {
491	ASSERT_BREAK((prAdapter != NULL) && (prP2pFsmInfo != NULL) && (prJoinInfo != NULL));
492
493	if (prJoinInfo->fgIsJoinComplete == FALSE) {
494
495	prJoinAbortMsg =
496	(P_MSG_JOIN_ABORT_T) cnmMemAlloc(prAdapter, RAM_TYPE_MSG,
497	sizeof(MSG_JOIN_ABORT_T));
498	if (!prJoinAbortMsg) {
499	DBGLOG(P2P, TRACE,
500	("Fail to allocate join abort message buffer\n"));
501	ASSERT(FALSE);
502	return;
503	}
504
505	prJoinAbortMsg->rMsgHdr.eMsgId = MID_P2P_SAA_FSM_ABORT;
506	prJoinAbortMsg->ucSeqNum = prJoinInfo->ucSeqNumOfReqMsg;
507	prJoinAbortMsg->prStaRec = prJoinInfo->prTargetStaRec;
508
509	mboxSendMsg(prAdapter,
510	MBOX_ID_0, (P_MSG_HDR_T) prJoinAbortMsg, MSG_SEND_METHOD_BUF);
511
512	}
513
514	/* Stop Join Timer. */
515	cnmTimerStopTimer(prAdapter, &(prP2pFsmInfo->rP2pFsmTimeoutTimer));
516
517	/* Release channel requested. */
518	p2pFuncReleaseCh(prAdapter, &(prP2pFsmInfo->rChnlReqInfo));
519
520	} while (FALSE);
521
522	return;
523
524	} /* p2pStateAbort_GC_JOIN */