UINT_32
wfdFuncAppendAttriAssocBssid(IN P_ADAPTER_T prAdapter,
IN BOOLEAN fgIsAssocFrame,
IN PUINT_16 pu2Offset,
IN PUINT_8 pucBuf, IN UINT_16 u2BufSize)
{
UINT_32 u4AttriLen = 0;
PUINT_8 pucBuffer = NULL;
P_WFD_ASSOCIATED_BSSID_IE_T prWfdAssocBssid =
(P_WFD_ASSOCIATED_BSSID_IE_T) NULL;
P_WFD_CFG_SETTINGS_T prWfdCfgSettings = (P_WFD_CFG_SETTINGS_T) NULL;
P_BSS_INFO_T prAisBssInfo = (P_BSS_INFO_T) NULL;
do {
ASSERT_BREAK((prAdapter != NULL) && (pucBuf != NULL) &&
(pu2Offset != NULL));
prWfdCfgSettings =
&(prAdapter->rWifiVar.prP2pFsmInfo->rWfdConfigureSettings);
ASSERT_BREAK((prWfdCfgSettings != NULL));
if (prWfdCfgSettings->ucWfdEnable == 0) {
break;
}
/* AIS network. */
prAisBssInfo =
&(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_AIS_INDEX]);
if ((!IS_NET_ACTIVE(prAdapter, NETWORK_TYPE_AIS_INDEX)) ||
(prAisBssInfo->eConnectionState !=
PARAM_MEDIA_STATE_CONNECTED)) {
break;
}
pucBuffer =
(PUINT_8) ((UINT_32) pucBuf + (UINT_32) (*pu2Offset));
ASSERT_BREAK(pucBuffer != NULL);
prWfdAssocBssid = (P_WFD_ASSOCIATED_BSSID_IE_T) pucBuffer;
prWfdAssocBssid->ucElemID = WFD_ATTRI_ID_ASSOC_BSSID;
WLAN_SET_FIELD_BE16(&prWfdAssocBssid->u2Length,
WFD_ATTRI_MAX_LEN_ASSOC_BSSID);
COPY_MAC_ADDR(prWfdAssocBssid->aucAssocBssid,
prAisBssInfo->aucBSSID);
u4AttriLen = WFD_ATTRI_MAX_LEN_ASSOC_BSSID + WFD_ATTRI_HDR_LEN;
} while (FALSE);
(*pu2Offset) += (UINT_16) u4AttriLen;
return u4AttriLen;
}
UINT_32
wfdFuncAppendAttriDevInfo(IN P_ADAPTER_T prAdapter,
IN BOOLEAN fgIsAssocFrame,
IN PUINT_16 pu2Offset,
IN PUINT_8 pucBuf, IN UINT_16 u2BufSize)
{
UINT_32 u4AttriLen = 0;
PUINT_8 pucBuffer = NULL;
P_WFD_DEVICE_INFORMATION_IE_T prWfdDevInfo =
(P_WFD_DEVICE_INFORMATION_IE_T) NULL;
P_WFD_CFG_SETTINGS_T prWfdCfgSettings = (P_WFD_CFG_SETTINGS_T) NULL;
do {
ASSERT_BREAK((prAdapter != NULL) && (pucBuf != NULL) &&
(pu2Offset != NULL));
prWfdCfgSettings =
&(prAdapter->rWifiVar.prP2pFsmInfo->rWfdConfigureSettings);
ASSERT_BREAK((prWfdCfgSettings != NULL));
if ((prWfdCfgSettings->ucWfdEnable == 0) ||
((prWfdCfgSettings->u4WfdFlag &
WFD_FLAGS_DEV_INFO_VALID) == 0)) {
break;
}
pucBuffer =
(PUINT_8) ((UINT_32) pucBuf + (UINT_32) (*pu2Offset));
ASSERT_BREAK(pucBuffer != NULL);
prWfdDevInfo = (P_WFD_DEVICE_INFORMATION_IE_T) pucBuffer;
prWfdDevInfo->ucElemID = WFD_ATTRI_ID_DEV_INFO;
WLAN_SET_FIELD_BE16(&prWfdDevInfo->u2WfdDevInfo,
prWfdCfgSettings->u2WfdDevInfo);
WLAN_SET_FIELD_BE16(&prWfdDevInfo->u2SessionMgmtCtrlPort,
prWfdCfgSettings->u2WfdControlPort);
WLAN_SET_FIELD_BE16(&prWfdDevInfo->u2WfdDevMaxSpeed,
prWfdCfgSettings->u2WfdMaximumTp);
WLAN_SET_FIELD_BE16(&prWfdDevInfo->u2Length,
WFD_ATTRI_MAX_LEN_DEV_INFO);
u4AttriLen = WFD_ATTRI_MAX_LEN_DEV_INFO + WFD_ATTRI_HDR_LEN;
} while (FALSE);
(*pu2Offset) += (UINT_16) u4AttriLen;
return u4AttriLen;
}
UINT_32
wfdFuncAppendAttriCoupledSinkInfo(IN P_ADAPTER_T prAdapter,
IN BOOLEAN fgIsAssocFrame,
IN PUINT_16 pu2Offset,
IN PUINT_8 pucBuf, IN UINT_16 u2BufSize)
{
UINT_32 u4AttriLen = 0;
PUINT_8 pucBuffer = NULL;
P_WFD_COUPLE_SINK_INFORMATION_IE_T prWfdCoupleSinkInfo =
(P_WFD_COUPLE_SINK_INFORMATION_IE_T) NULL;
P_WFD_CFG_SETTINGS_T prWfdCfgSettings = (P_WFD_CFG_SETTINGS_T) NULL;
do {
ASSERT_BREAK((prAdapter != NULL) && (pucBuf != NULL) &&
(pu2Offset != NULL));
prWfdCfgSettings =
&(prAdapter->rWifiVar.prP2pFsmInfo->rWfdConfigureSettings);
ASSERT_BREAK((prWfdCfgSettings != NULL));
if ((prWfdCfgSettings->ucWfdEnable == 0) ||
((prWfdCfgSettings->u4WfdFlag &
WFD_FLAGS_SINK_INFO_VALID) == 0)) {
break;
}
pucBuffer =
(PUINT_8) ((UINT_32) pucBuf + (UINT_32) (*pu2Offset));
ASSERT_BREAK(pucBuffer != NULL);
prWfdCoupleSinkInfo =
(P_WFD_COUPLE_SINK_INFORMATION_IE_T) pucBuffer;
prWfdCoupleSinkInfo->ucElemID = WFD_ATTRI_ID_COUPLED_SINK_INFO;
WLAN_SET_FIELD_BE16(&prWfdCoupleSinkInfo->u2Length,
WFD_ATTRI_MAX_LEN_COUPLED_SINK_INFO);
COPY_MAC_ADDR(prWfdCoupleSinkInfo->aucCoupleSinkMac,
prWfdCfgSettings->aucWfdCoupleSinkAddress);
prWfdCoupleSinkInfo->ucCoupleSinkStatusBp =
prWfdCfgSettings->ucWfdCoupleSinkStatus;
u4AttriLen = WFD_ATTRI_MAX_LEN_COUPLED_SINK_INFO +
WFD_ATTRI_HDR_LEN;
} while (FALSE);
(*pu2Offset) += (UINT_16) u4AttriLen;
return u4AttriLen;
}
UINT_32
wfdFuncAppendAttriSessionInfo(IN P_ADAPTER_T prAdapter,
IN BOOLEAN fgIsAssocFrame,
IN PUINT_16 pu2Offset,
IN PUINT_8 pucBuf, IN UINT_16 u2BufSize)
{
UINT_32 u4AttriLen = 0;
PUINT_8 pucBuffer = NULL;
P_WFD_SESSION_INFORMATION_IE_T prWfdSessionInfo =
(P_WFD_SESSION_INFORMATION_IE_T) NULL;
P_WFD_CFG_SETTINGS_T prWfdCfgSettings = (P_WFD_CFG_SETTINGS_T) NULL;
do {
ASSERT_BREAK((prAdapter != NULL) && (pucBuf != NULL) &&
(pu2Offset != NULL));
prWfdCfgSettings =
&(prAdapter->rWifiVar.prP2pFsmInfo->rWfdConfigureSettings);
ASSERT_BREAK((prWfdCfgSettings != NULL));
if ((prWfdCfgSettings->ucWfdEnable == 0) ||
(prWfdCfgSettings->u2WfdSessionInformationIELen == 0)) {
break;
}
pucBuffer =
(PUINT_8) ((UINT_32) pucBuf + (UINT_32) (*pu2Offset));
ASSERT_BREAK(pucBuffer != NULL);
prWfdSessionInfo = (P_WFD_SESSION_INFORMATION_IE_T) pucBuffer;
prWfdSessionInfo->ucElemID = WFD_ATTRI_ID_SESSION_INFO;
/* TODO: Check endian issue? */
kalMemCopy(prWfdSessionInfo->pucWfdDevInfoDesc,
prWfdCfgSettings->aucWfdSessionInformationIE,
prWfdCfgSettings->u2WfdSessionInformationIELen);
WLAN_SET_FIELD_16(&prWfdSessionInfo->u2Length,
prWfdCfgSettings->u2WfdSessionInformationIELen);
u4AttriLen = prWfdCfgSettings->u2WfdSessionInformationIELen +
WFD_ATTRI_HDR_LEN;
} while (FALSE);
(*pu2Offset) += (UINT_16) u4AttriLen;
return u4AttriLen;
}
UINT_32
wfdFuncAppendAttriExtCapability(IN P_ADAPTER_T prAdapter,
IN BOOLEAN fgIsAssocFrame,
IN PUINT_16 pu2Offset,
IN PUINT_8 pucBuf, IN UINT_16 u2BufSize)
{
UINT_32 u4AttriLen = 0;
PUINT_8 pucBuffer = NULL;
P_WFD_EXTENDED_CAPABILITY_IE_T prWfdExtCapability =
(P_WFD_EXTENDED_CAPABILITY_IE_T) NULL;
P_WFD_CFG_SETTINGS_T prWfdCfgSettings = (P_WFD_CFG_SETTINGS_T) NULL;
do {
ASSERT_BREAK((prAdapter != NULL) && (pucBuf != NULL) &&
(pu2Offset != NULL));
prWfdCfgSettings =
&(prAdapter->rWifiVar.prP2pFsmInfo->rWfdConfigureSettings);
ASSERT_BREAK((prWfdCfgSettings != NULL));
if ((prWfdCfgSettings->ucWfdEnable == 0) ||
((prWfdCfgSettings->u4WfdFlag &
WFD_FLAGS_EXT_CAPABILITY_VALID) == 0)) {
break;
}
pucBuffer =
(PUINT_8) ((UINT_32) pucBuf + (UINT_32) (*pu2Offset));
ASSERT_BREAK(pucBuffer != NULL);
prWfdExtCapability = (P_WFD_EXTENDED_CAPABILITY_IE_T) pucBuffer;
prWfdExtCapability->ucElemID = WFD_ATTRI_ID_EXT_CAPABILITY;
WLAN_SET_FIELD_BE16(&prWfdExtCapability->u2Length,
WFD_ATTRI_MAX_LEN_EXT_CAPABILITY);
WLAN_SET_FIELD_BE16(&prWfdExtCapability->u2WfdExtCapabilityBp,
prWfdCfgSettings->u2WfdExtendCap);
u4AttriLen = WFD_ATTRI_MAX_LEN_EXT_CAPABILITY +
WFD_ATTRI_HDR_LEN;
} while (FALSE);
(*pu2Offset) += (UINT_16) u4AttriLen;
return u4AttriLen;
}
VOID
p2pDevStateAbort_CHNL_ON_HAND(IN P_ADAPTER_T prAdapter,
IN P_BSS_INFO_T prP2pBssInfo,
IN P_P2P_DEV_FSM_INFO_T prP2pDevFsmInfo,
IN P_P2P_CHNL_REQ_INFO_T prChnlReqInfo)
{
do {
ASSERT_BREAK((prAdapter != NULL) || (prChnlReqInfo != NULL));
cnmTimerStopTimer(prAdapter, &(prP2pDevFsmInfo->rP2pFsmTimeoutTimer));
prP2pBssInfo->ucPrimaryChannel = prChnlReqInfo->ucOriChnlNum;
prP2pBssInfo->eBand = prChnlReqInfo->eOriBand;
prP2pBssInfo->eBssSCO = prChnlReqInfo->eOriChnlSco;
kalP2PIndicateChannelExpired(prAdapter->prGlueInfo,
prChnlReqInfo->u8Cookie,
prChnlReqInfo->ucReqChnlNum,
prChnlReqInfo->eBand, prChnlReqInfo->eChnlSco);
p2pFuncReleaseCh(prAdapter, prP2pDevFsmInfo->ucBssIndex, prChnlReqInfo);
} while (FALSE);
return;
} /* p2pDevStateAbort_CHNL_ON_HAND */
VOID
p2pDevStateInit_CHNL_ON_HAND(IN P_ADAPTER_T prAdapter,
IN P_BSS_INFO_T prP2pBssInfo,
IN P_P2P_DEV_FSM_INFO_T prP2pDevFsmInfo,
IN P_P2P_CHNL_REQ_INFO_T prChnlReqInfo)
{
do {
ASSERT_BREAK((prAdapter != NULL) &&
(prP2pDevFsmInfo != NULL) && (prChnlReqInfo != NULL));
ASSERT(prChnlReqInfo->eChnlReqType == CH_REQ_TYPE_P2P_LISTEN);
prChnlReqInfo->ucOriChnlNum = prP2pBssInfo->ucPrimaryChannel;
prChnlReqInfo->eOriBand = prP2pBssInfo->eBand;
prChnlReqInfo->eOriChnlSco = prP2pBssInfo->eBssSCO;
prP2pBssInfo->ucPrimaryChannel = prChnlReqInfo->ucReqChnlNum;
prP2pBssInfo->eBand = prChnlReqInfo->eBand;
prP2pBssInfo->eBssSCO = prChnlReqInfo->eChnlSco;
cnmTimerStartTimer(prAdapter, &(prP2pDevFsmInfo->rP2pFsmTimeoutTimer),
prChnlReqInfo->u4MaxInterval);
kalP2PIndicateChannelReady(prAdapter->prGlueInfo,
prChnlReqInfo->u8Cookie,
prChnlReqInfo->ucReqChnlNum,
prChnlReqInfo->eBand,
prChnlReqInfo->eChnlSco, prChnlReqInfo->u4MaxInterval);
} while (FALSE);
return;
} /* p2pDevStateInit_CHNL_ON_HAND */
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, &(prAdapter->rP2pFsmTimeoutTimer), prChnlReqInfo->u4MaxInterval);
kalP2PIndicateChannelReady(prAdapter->prGlueInfo,
prChnlReqInfo->u8Cookie,
prChnlReqInfo->ucReqChnlNum,
prChnlReqInfo->eBand, prChnlReqInfo->eChnlSco, prChnlReqInfo->u4MaxInterval);
} while (FALSE);
return;
} /* p2pStateInit_CHNL_ON_HAND */
BOOLEAN
p2pDevStateInit_IDLE (
IN P_ADAPTER_T prAdapter,
IN P_P2P_CHNL_REQ_INFO_T prChnlReqInfo,
OUT P_ENUM_P2P_DEV_STATE_T peNextState
)
{
BOOLEAN fgIsTransition = FALSE;
do {
ASSERT_BREAK((prAdapter != NULL) &&
(prChnlReqInfo) &&
(peNextState != NULL));
if (!LINK_IS_EMPTY(&(prChnlReqInfo->rP2pChnlReqLink))) {
fgIsTransition = TRUE;
*peNextState = P2P_DEV_STATE_REQING_CHANNEL;
break;
}
/* Stay in IDLE state. */
} while (FALSE);
return fgIsTransition;
} /* p2pDevStateInit_IDLE */
UINT_32
p2pCalculate_IEForAssocReq(IN P_ADAPTER_T prAdapter,
IN ENUM_NETWORK_TYPE_INDEX_T eNetTypeIndex, IN P_STA_RECORD_T prStaRec)
{
P_P2P_FSM_INFO_T prP2pFsmInfo = (P_P2P_FSM_INFO_T) NULL;
P_P2P_CONNECTION_REQ_INFO_T prConnReqInfo = (P_P2P_CONNECTION_REQ_INFO_T) NULL;
UINT_32 u4RetValue = 0;
do {
ASSERT_BREAK((eNetTypeIndex == NETWORK_TYPE_P2P_INDEX) && (prAdapter != NULL));
prP2pFsmInfo = prAdapter->rWifiVar.prP2pFsmInfo;
prConnReqInfo = &(prP2pFsmInfo->rConnReqInfo);
u4RetValue = prConnReqInfo->u4BufLength;
/* ADD HT Capability */
u4RetValue += (ELEM_HDR_LEN + ELEM_MAX_LEN_HT_CAP);
/* ADD WMM Information Element */
u4RetValue += (ELEM_HDR_LEN + ELEM_MAX_LEN_WMM_INFO);
} while (FALSE);
return u4RetValue;
} /* p2pCalculate_IEForAssocReq */
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 */
/*----------------------------------------------------------------------------*/
UINT_32
wfdFuncCalculateAttriLenSessionInfo (
IN P_ADAPTER_T prAdapter,
IN P_STA_RECORD_T prStaRec
)
{
UINT_16 u2AttriLen = 0;
P_WFD_CFG_SETTINGS_T prWfdCfgSettings = (P_WFD_CFG_SETTINGS_T)NULL;
do {
ASSERT_BREAK((prAdapter != NULL) && (prStaRec != NULL));
prWfdCfgSettings = &(prAdapter->rWifiVar.prP2pFsmInfo->rWfdConfigureSettings);
if (prWfdCfgSettings->ucWfdEnable == 0) {
break;
}
u2AttriLen = prWfdCfgSettings->u2WfdSessionInformationIELen + WFD_ATTRI_HDR_LEN;
} while (FALSE);
return (UINT_32)u2AttriLen;
} /* wfdFuncCalculateAttriLenSessionInfo */
/*----------------------------------------------------------------------------*/
VOID p2pGenerate_IEForAssocReq(IN P_ADAPTER_T prAdapter, IN P_MSDU_INFO_T prMsduInfo)
{
P_P2P_FSM_INFO_T prP2pFsmInfo = (P_P2P_FSM_INFO_T) NULL;
P_P2P_CONNECTION_REQ_INFO_T prConnReqInfo = (P_P2P_CONNECTION_REQ_INFO_T) NULL;
PUINT_8 pucIEBuf = (PUINT_8) NULL;
do {
ASSERT_BREAK((prAdapter != NULL) && (prMsduInfo != NULL));
prP2pFsmInfo = prAdapter->rWifiVar.prP2pFsmInfo;
prConnReqInfo = &(prP2pFsmInfo->rConnReqInfo);
pucIEBuf = (PUINT_8) ((ULONG) prMsduInfo->prPacket + (UINT_32) prMsduInfo->u2FrameLength);
kalMemCopy(pucIEBuf, prConnReqInfo->aucIEBuf, prConnReqInfo->u4BufLength);
prMsduInfo->u2FrameLength += prConnReqInfo->u4BufLength;
rlmReqGenerateHtCapIE(prAdapter, prMsduInfo);
mqmGenerateWmmInfoIE(prAdapter, prMsduInfo);
} while (FALSE);
return;
} /* p2pGenerate_IEForAssocReq */
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
p2pDevStateAbort_OFF_CHNL_TX(IN P_ADAPTER_T prAdapter,
IN P_P2P_MGMT_TX_REQ_INFO_T prP2pMgmtTxInfo,
IN P_P2P_CHNL_REQ_INFO_T prChnlReqInfo,
IN ENUM_P2P_DEV_STATE_T eNextState)
{
P_P2P_OFF_CHNL_TX_REQ_INFO_T prP2pOffChnlTxPkt = (P_P2P_OFF_CHNL_TX_REQ_INFO_T) NULL;
do {
ASSERT_BREAK((prAdapter != NULL) &&
(prP2pMgmtTxInfo != NULL) && (prChnlReqInfo != NULL));
if (eNextState != P2P_DEV_STATE_OFF_CHNL_TX) {
while (!LINK_IS_EMPTY(&(prP2pMgmtTxInfo->rP2pTxReqLink))) {
LINK_REMOVE_HEAD(&(prP2pMgmtTxInfo->rP2pTxReqLink),
prP2pOffChnlTxPkt, P_P2P_OFF_CHNL_TX_REQ_INFO_T);
kalP2PIndicateMgmtTxStatus(prAdapter->prGlueInfo,
prP2pOffChnlTxPkt->prMgmtTxMsdu, FALSE);
}
p2pFuncReleaseCh(prAdapter, P2P_DEV_BSS_INDEX, prChnlReqInfo);
}
} while (FALSE);
return;
} /* p2pDevSateAbort_OFF_CHNL_TX */
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
p2pDevStateAbort_REQING_CHANNEL(IN P_ADAPTER_T prAdapter,
IN P_P2P_CHNL_REQ_INFO_T prChnlReqInfo,
IN ENUM_P2P_DEV_STATE_T eNextState)
{
do {
ASSERT_BREAK((prAdapter != NULL) &&
(prChnlReqInfo != NULL) && (eNextState < P2P_DEV_STATE_NUM));
switch (eNextState) {
case P2P_DEV_STATE_IDLE:
/* Channel abort case. */
p2pFuncReleaseCh(prAdapter, P2P_DEV_BSS_INDEX, prChnlReqInfo);
break;
case P2P_DEV_STATE_CHNL_ON_HAND:
/* Channel on hand case. */
break;
default:
/* Un-expected state transition. */
DBGLOG(P2P, ERROR, ("Unexpected State Transition(%d)\n", eNextState));
ASSERT(FALSE);
break;
}
} while (FALSE);
return;
} /* p2pDevStateAbort_REQING_CHANNEL */
void DBMainLoop::Run()
{
MsgSet msgSet;
DBThreadPool& dbThreadPool = DBThreadPool::Instance();
while (continueFlag)
{
Time::UpdateTime();
msgSet.Clear();
if (ReceiveIPCMsg(msgSet))
{
//这里用sessionID根据线程数量进行取模分配到具体的DB线程
int modID = msgSet.head().session_id() % threadNum;
ASSERT_BREAK(msgSet.msg().size() == 1);
dbThreadPool.InsertDBMsg(modID+1, msgSet);
}
Time::MsSleep(10);
}
dbThreadPool.Stop();
}
BOOLEAN
p2pDevStateInit_REQING_CHANNEL (
IN P_ADAPTER_T prAdapter,
IN UINT_8 ucBssIdx,
IN P_P2P_CHNL_REQ_INFO_T prChnlReqInfo,
OUT P_ENUM_P2P_DEV_STATE_T peNextState
)
{
BOOLEAN fgIsTransition = FALSE;
P_MSG_P2P_CHNL_REQUEST_T prP2pMsgChnlReq = (P_MSG_P2P_CHNL_REQUEST_T)NULL;
do {
ASSERT_BREAK((prAdapter != NULL) &&
(prChnlReqInfo != NULL) &&
(peNextState != NULL));
if (LINK_IS_EMPTY(&(prChnlReqInfo->rP2pChnlReqLink))) {
/* NO Channel Request Pending. */
DBGLOG(P2P, ERROR, ("NO Pending Channel Request, but enter Req Channel State\n"));
fgIsTransition = TRUE;
*peNextState = P2P_DEV_STATE_IDLE;
break;
}
LINK_REMOVE_HEAD(&(prChnlReqInfo->rP2pChnlReqLink),
prP2pMsgChnlReq,
P_MSG_P2P_CHNL_REQUEST_T);
ASSERT(prP2pMsgChnlReq);
prChnlReqInfo->u4MaxInterval = prP2pMsgChnlReq->u4Duration;
prChnlReqInfo->ucReqChnlNum = prP2pMsgChnlReq->rChannelInfo.ucChannelNum;
prChnlReqInfo->eChnlSco = prP2pMsgChnlReq->eChnlSco;
prChnlReqInfo->eBand = prP2pMsgChnlReq->rChannelInfo.eBand;
prChnlReqInfo->u8Cookie = prP2pMsgChnlReq->u8Cookie;
prChnlReqInfo->eChnlReqType = prP2pMsgChnlReq->eChnlReqType;
prChnlReqInfo->eChannelWidth = CW_20_40MHZ;
prChnlReqInfo->ucCenterFreqS1 = 0;
prChnlReqInfo->ucCenterFreqS2 = 0;
p2pFuncAcquireCh(prAdapter,
ucBssIdx,
prChnlReqInfo);
} while (FALSE);
if (prP2pMsgChnlReq) {
cnmMemFree(prAdapter, prP2pMsgChnlReq);
}
return fgIsTransition;
} /* p2pDevStateInit_REQING_CHANNEL */
bool ETSocketClient::startClient() {
bool bRet = false;
do {
// init pthread for send
isRunning_ = true;
BREAK_IF(bSendStart_);
ASSERT_BREAK(pthread_create(&sendThread_, NULL, sendThreadCallFunc, this) == 0);
bSendStart_ = true;
} while (false);
return bRet;
}
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;
DBGLOG(P2P, INFO,("p2pStateInit_IDLE GO Scan \n"));
*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, &(prAdapter->rP2pFsmTimeoutTimer), 5000);
}
} while (FALSE);
return fgIsTransOut;
} /* p2pStateInit_IDLE */
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 */
bool ETSocketClient::startRecv() {
bool bRet = false;
do {
BREAK_IF(bRecvStart_);
ASSERT_BREAK(pthread_create(&recvThread_, NULL, recvThreadCallFunc, this) == 0);
bRecvStart_ = true;
bRet = true;
return bRet;
} while (false);
socket_.close();
return bRet;
}
VOID
p2pDevStateInit_SCAN(IN P_ADAPTER_T prAdapter,
IN UINT_8 ucBssIndex, IN P_P2P_SCAN_REQ_INFO_T prScanReqInfo)
{
do {
ASSERT_BREAK((prAdapter != NULL) && (prScanReqInfo != NULL));
prScanReqInfo->fgIsScanRequest = TRUE;
p2pFuncRequestScan(prAdapter, ucBssIndex, prScanReqInfo);
} while (FALSE);
return;
} /* p2pDevStateInit_CHNL_ON_HAND */
VOID p2pDevStateAbort_SCAN(IN P_ADAPTER_T prAdapter, IN P_P2P_DEV_FSM_INFO_T prP2pDevFsmInfo)
{
P_P2P_SCAN_REQ_INFO_T prScanInfo = (P_P2P_SCAN_REQ_INFO_T) NULL;
do {
ASSERT_BREAK((prAdapter != NULL) && (prP2pDevFsmInfo != NULL));
prScanInfo = &(prP2pDevFsmInfo->rScanReqInfo);
p2pFuncCancelScan(prAdapter, prP2pDevFsmInfo->ucBssIndex, prScanInfo);
kalP2PIndicateScanDone(prAdapter->prGlueInfo, 0xFF, prScanInfo->fgIsAbort);
} while (FALSE);
return;
} /* p2pDevStateAbort_CHNL_ON_HAND */
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 */
/*----------------------------------------------------------------------------*/
UINT_8 rlmFuncFindOperatingClass(IN P_ADAPTER_T prAdapter, IN UINT_8 ucChannelNum)
{
UINT_8 ucRegulatoryClass = 0, ucBufferSize = 0;
P_P2P_CONNECTION_SETTINGS_T prP2pConnSetting = (P_P2P_CONNECTION_SETTINGS_T) NULL;
P_CHANNEL_ENTRY_FIELD_T prChannelEntryField = (P_CHANNEL_ENTRY_FIELD_T) NULL;
UINT_32 u4Idx = 0;
do {
ASSERT_BREAK(prAdapter != NULL);
prP2pConnSetting = prAdapter->rWifiVar.prP2PConnSettings;
ucBufferSize = prP2pConnSetting->ucRfChannelListSize;
prChannelEntryField =
(P_CHANNEL_ENTRY_FIELD_T) prP2pConnSetting->aucChannelEntriesField;
while (ucBufferSize != 0) {
for (u4Idx = 0; u4Idx < prChannelEntryField->ucNumberOfChannels; u4Idx++) {
if (prChannelEntryField->aucChannelList[u4Idx] == ucChannelNum) {
ucRegulatoryClass = prChannelEntryField->ucRegulatoryClass;
break;
}
}
if (ucRegulatoryClass != 0) {
break; /* while */
} else {
prChannelEntryField =
(P_CHANNEL_ENTRY_FIELD_T) ((UINT_32) prChannelEntryField +
P2P_ATTRI_LEN_CHANNEL_ENTRY +
(UINT_32) prChannelEntryField->
ucNumberOfChannels);
ucBufferSize -=
(P2P_ATTRI_LEN_CHANNEL_ENTRY +
prChannelEntryField->ucNumberOfChannels);
}
}
} while (FALSE);
return ucRegulatoryClass;
} /* rlmFuncFindOperatingClass */
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. */
#if 0
p2pFuncStartGO(prAdapter,
prP2pBssInfo,
prP2pSpecificBssInfo->aucGroupSsid,
prP2pSpecificBssInfo->u2GroupSsidLen,
prP2pSpecificBssInfo->ucPreferredChannel,
prP2pSpecificBssInfo->eRfBand,
prP2pSpecificBssInfo->eRfSco,
prP2pFsmInfo->fgIsApMode);
#endif
}
else {
// Return Channel.
p2pFuncReleaseCh(prAdapter, &(prP2pFsmInfo->rChnlReqInfo));
}
}
} while (FALSE);
return;
} /* p2pStateInit_AP_CHANNEL_DETECT */
/*----------------------------------------------------------------------------*/
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 */
VOID
wfdFuncGenerateWfdIEForAssocRsp(IN P_ADAPTER_T prAdapter,
IN P_MSDU_INFO_T prMsduInfo)
{
#if CFG_SUPPORT_WFD_COMPOSE_IE
P_WFD_CFG_SETTINGS_T prWfdCfgSettings = (P_WFD_CFG_SETTINGS_T) NULL;
P_STA_RECORD_T prStaRec;
do {
ASSERT_BREAK((prMsduInfo != NULL) && (prAdapter != NULL));
prWfdCfgSettings =
&(prAdapter->rWifiVar.prP2pFsmInfo->rWfdConfigureSettings);
prStaRec = cnmGetStaRecByIndex(prAdapter,
prMsduInfo->ucStaRecIndex);
if (IS_STA_P2P_TYPE(prStaRec)) {
if (prWfdCfgSettings->ucWfdEnable == 0) {
break;
}
if ((prWfdCfgSettings->u4WfdFlag &
WFD_FLAGS_DEV_INFO_VALID) == 0) {
break;
}
wfdFuncGenerateWfd_IE(prAdapter,
FALSE,
&prMsduInfo->u2FrameLength,
prMsduInfo->prPacket,
1500,
txAssocRspWFDAttributesTable,
sizeof
(txAssocRspWFDAttributesTable)
/
sizeof(APPEND_VAR_ATTRI_ENTRY_T));
}
} while (FALSE);
return;
#else
return;
#endif
} /* wfdFuncGenerateWfdIEForAssocRsp */
