/*----------------------------------------------------------------------------*/
WLAN_STATUS aaaFsmSendEventJoinComplete(WLAN_STATUS rJoinStatus, P_STA_RECORD_T prStaRec, P_SW_RFB_T prSwRfb)
{
P_MSG_SAA_JOIN_COMP_T prJoinCompMsg;
ASSERT(prStaRec);
prJoinCompMsg = cnmMemAlloc(RAM_TYPE_TCM, sizeof(MSG_SAA_JOIN_COMP_T));
if (!prJoinCompMsg)
return WLAN_STATUS_RESOURCES;
if (IS_STA_IN_AIS(prStaRec))
prJoinCompMsg->rMsgHdr.eMsgId = MID_SAA_AIS_JOIN_COMPLETE;
else if (IS_STA_IN_P2P(prStaRec))
prJoinCompMsg->rMsgHdr.eMsgId = MID_SAA_P2P_JOIN_COMPLETE;
else if (IS_STA_IN_BOW(prStaRec))
prJoinCompMsg->rMsgHdr.eMsgId = MID_SAA_BOW_JOIN_COMPLETE;
else
ASSERT(0);
prJoinCompMsg->rJoinStatus = rJoinStatus;
prJoinCompMsg->prStaRec = prStaRec;
prJoinCompMsg->prSwRfb = prSwRfb;
mboxSendMsg(MBOX_ID_0, (P_MSG_HDR_T) prJoinCompMsg, MSG_SEND_METHOD_BUF);
return WLAN_STATUS_SUCCESS;
} /* end of saaFsmSendEventJoinComplete() */
/*----------------------------------------------------------------------------*/
VOID rlmObssTriggerScan(P_ADAPTER_T prAdapter, P_BSS_INFO_T prBssInfo)
{
P_MSG_SCN_SCAN_REQ prScanReqMsg;
ASSERT(prBssInfo);
prScanReqMsg = (P_MSG_SCN_SCAN_REQ)
cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_SCN_SCAN_REQ));
ASSERT(prScanReqMsg);
if (!prScanReqMsg) {
DBGLOG(RLM, WARN, "No buf for OBSS scan (NetIdx=%d)!!\n", prBssInfo->ucNetTypeIndex);
cnmTimerStartTimer(prAdapter, &prBssInfo->rObssScanTimer, prBssInfo->u2ObssScanInterval * MSEC_PER_SEC);
return;
}
/* It is ok that ucSeqNum is set to fixed value because the same network
* OBSS scan interval is limited to OBSS_SCAN_MIN_INTERVAL (min 10 sec)
* and scan module don't care seqNum of OBSS scanning
*/
prScanReqMsg->rMsgHdr.eMsgId = MID_RLM_SCN_SCAN_REQ;
prScanReqMsg->ucSeqNum = 0x33;
prScanReqMsg->ucNetTypeIndex = prBssInfo->ucNetTypeIndex;
prScanReqMsg->eScanType = SCAN_TYPE_ACTIVE_SCAN;
prScanReqMsg->ucSSIDType = SCAN_REQ_SSID_WILDCARD;
prScanReqMsg->ucSSIDLength = 0;
prScanReqMsg->eScanChannel = SCAN_CHANNEL_2G4;
prScanReqMsg->u2IELen = 0;
mboxSendMsg(prAdapter, MBOX_ID_0, (P_MSG_HDR_T) prScanReqMsg, MSG_SEND_METHOD_BUF);
DBGLOG(RLM, INFO, "Timeout to trigger OBSS scan (NetIdx=%d)!!\n", prBssInfo->ucNetTypeIndex);
}
VOID
kalP2PIndicateChannelReady (
IN P_GLUE_INFO_T prGlueInfo,
IN UINT_64 u8SeqNum,
IN UINT_32 u4ChannelNum,
IN ENUM_BAND_T eBand,
IN ENUM_CHNL_EXT_T eSco,
IN UINT_32 u4Duration
)
{
struct ieee80211_channel *prIEEE80211ChnlStruct = (struct ieee80211_channel *)NULL;
RF_CHANNEL_INFO_T rChannelInfo;
enum nl80211_channel_type eChnlType = NL80211_CHAN_NO_HT;
P_MSG_P2P_MGMT_TX_REQUEST_T prMsgTxReq = (P_MSG_P2P_MGMT_TX_REQUEST_T)NULL;
INT_32 i4Rslt = -EINVAL;
P_P2P_FSM_INFO_T prP2pFsmInfo = (P_P2P_FSM_INFO_T)NULL;
prP2pFsmInfo = prGlueInfo->prAdapter->rWifiVar.prP2pFsmInfo;
P_P2P_CHNL_REQ_INFO_T prChnlReqInfo = &(prP2pFsmInfo->rChnlReqInfo);
do {
if (prGlueInfo == NULL) {
break;
}
if (prChnlReqInfo->fgNeedIndSupp) {
kalMemZero(&rChannelInfo, sizeof(RF_CHANNEL_INFO_T));
rChannelInfo.ucChannelNum = u4ChannelNum;
rChannelInfo.eBand = eBand;
prIEEE80211ChnlStruct = kalP2pFuncGetChannelEntry(prGlueInfo->prP2PInfo, &rChannelInfo);
kalP2pFuncGetChannelType(eSco, &eChnlType);
cfg80211_ready_on_channel(prGlueInfo->prP2PInfo->prDevHandler, //struct net_device * dev,
u8SeqNum, //u64 cookie,
prIEEE80211ChnlStruct, //struct ieee80211_channel * chan,
eChnlType, //enum nl80211_channel_type channel_type,
u4Duration, //unsigned int duration,
GFP_KERNEL); //gfp_t gfp /* allocation flags */
}
if (prChnlReqInfo->prMsgTxReq!=NULL) {
prMsgTxReq = prChnlReqInfo->prMsgTxReq;
mboxSendMsg(prGlueInfo->prAdapter,
MBOX_ID_0,
(P_MSG_HDR_T)prMsgTxReq,
MSG_SEND_METHOD_UNBUF);
i4Rslt = 0;
prChnlReqInfo->prMsgTxReq=NULL;
atomic_set(&prGlueInfo->rMgmtTxAto, 0);
complete(&prGlueInfo->rMgmtTxComp);
init_completion(&prGlueInfo->rMgmtTxComp);
}
} while (FALSE);
return i4Rslt;
} /* kalP2PIndicateChannelReady */
/*----------------------------------------------------------------------------*/
VOID cnmChMngrHandleChEvent(P_ADAPTER_T prAdapter, P_WIFI_EVENT_T prEvent)
{
P_EVENT_CH_PRIVILEGE_T prEventBody;
P_MSG_CH_GRANT_T prChResp;
ASSERT(prAdapter);
ASSERT(prEvent);
prEventBody = (P_EVENT_CH_PRIVILEGE_T) (prEvent->aucBuffer);
prChResp = (P_MSG_CH_GRANT_T)
cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_CH_GRANT_T));
ASSERT(prChResp);
/* To do: exception handle */
if (!prChResp) {
DBGLOG(CNM, ERROR, ("ChGrant: fail to get buf (net=%d, token=%d)\n",
prEventBody->ucNetTypeIndex, prEventBody->ucTokenID));
return;
}
DBGLOG(CNM, INFO, ("ChGrant net=%d token=%d ch=%d sco=%d\n",
prEventBody->ucNetTypeIndex, prEventBody->ucTokenID,
prEventBody->ucPrimaryChannel, prEventBody->ucRfSco));
ASSERT(prEventBody->ucNetTypeIndex < NETWORK_TYPE_INDEX_NUM);
ASSERT(prEventBody->ucStatus == EVENT_CH_STATUS_GRANT);
/* Decide message ID based on network and response status */
if (prEventBody->ucNetTypeIndex == NETWORK_TYPE_AIS_INDEX) {
prChResp->rMsgHdr.eMsgId = MID_CNM_AIS_CH_GRANT;
}
#if CFG_ENABLE_WIFI_DIRECT
else if ((prAdapter->fgIsP2PRegistered) &&
(prEventBody->ucNetTypeIndex == NETWORK_TYPE_P2P_INDEX)) {
prChResp->rMsgHdr.eMsgId = MID_CNM_P2P_CH_GRANT;
}
#endif
#if CFG_ENABLE_BT_OVER_WIFI
else if (prEventBody->ucNetTypeIndex == NETWORK_TYPE_BOW_INDEX) {
prChResp->rMsgHdr.eMsgId = MID_CNM_BOW_CH_GRANT;
}
#endif
else {
cnmMemFree(prAdapter, prChResp);
return;
}
prChResp->ucNetTypeIndex = prEventBody->ucNetTypeIndex;
prChResp->ucTokenID = prEventBody->ucTokenID;
prChResp->ucPrimaryChannel = prEventBody->ucPrimaryChannel;
prChResp->eRfSco = (ENUM_CHNL_EXT_T) prEventBody->ucRfSco;
prChResp->eRfBand = (ENUM_BAND_T) prEventBody->ucRfBand;
prChResp->eReqType = (ENUM_CH_REQ_TYPE_T) prEventBody->ucReqType;
prChResp->u4GrantInterval = prEventBody->u4GrantInterval;
mboxSendMsg(prAdapter, MBOX_ID_0, (P_MSG_HDR_T) prChResp, MSG_SEND_METHOD_BUF);
}
/*----------------------------------------------------------------------------*/
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
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 = P2P_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 */
/*----------------------------------------------------------------------------*/
VOID
kalP2PInvitationIndication (
IN P_GLUE_INFO_T prGlueInfo,
IN P_P2P_DEVICE_DESC_T prP2pDevDesc,
IN PUINT_8 pucSsid,
IN UINT_8 ucSsidLen,
IN UINT_8 ucOperatingChnl,
IN UINT_8 ucInvitationType,
IN PUINT_8 pucGroupBssid
)
{
#if 1
union iwreq_data evt;
UINT_8 aucBuffer[IW_CUSTOM_MAX];
ASSERT(prGlueInfo);
/* buffer peer information for later IOC_P2P_GET_STRUCT access */
prGlueInfo->prP2PInfo->u4ConnReqNameLength = (UINT_32)((prP2pDevDesc->u2NameLength > 32)? 32 : prP2pDevDesc->u2NameLength);
kalMemCopy(prGlueInfo->prP2PInfo->aucConnReqDevName,
prP2pDevDesc->aucName,
prGlueInfo->prP2PInfo->u4ConnReqNameLength);
COPY_MAC_ADDR(prGlueInfo->prP2PInfo->rConnReqPeerAddr, prP2pDevDesc->aucDeviceAddr);
COPY_MAC_ADDR(prGlueInfo->prP2PInfo->rConnReqGroupAddr, pucGroupBssid);
prGlueInfo->prP2PInfo->i4ConnReqConfigMethod = (INT_32)(prP2pDevDesc->u2ConfigMethod);
prGlueInfo->prP2PInfo->ucOperatingChnl = ucOperatingChnl;
prGlueInfo->prP2PInfo->ucInvitationType = ucInvitationType;
// prepare event structure
memset(&evt, 0, sizeof(evt));
snprintf(aucBuffer, IW_CUSTOM_MAX-1, "P2P_INV_INDICATE");
evt.data.length = strlen(aucBuffer);
/* indicate in IWEVCUSTOM event */
wireless_send_event(prGlueInfo->prP2PInfo->prDevHandler,
IWEVCUSTOM,
&evt,
aucBuffer);
return;
#else
P_MSG_P2P_CONNECTION_REQUEST_T prP2pConnReq = (P_MSG_P2P_CONNECTION_REQUEST_T)NULL;
P_P2P_SPECIFIC_BSS_INFO_T prP2pSpecificBssInfo = (P_P2P_SPECIFIC_BSS_INFO_T)NULL;
P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T)NULL;
do {
ASSERT_BREAK((prGlueInfo != NULL) && (prP2pDevDesc != NULL));
// Not a real solution
prP2pSpecificBssInfo = prGlueInfo->prAdapter->rWifiVar.prP2pSpecificBssInfo;
prP2pConnSettings = prGlueInfo->prAdapter->rWifiVar.prP2PConnSettings;
prP2pConnReq = (P_MSG_P2P_CONNECTION_REQUEST_T)cnmMemAlloc(prGlueInfo->prAdapter,
RAM_TYPE_MSG,
sizeof(MSG_P2P_CONNECTION_REQUEST_T));
if (prP2pConnReq == NULL) {
break;
}
kalMemZero(prP2pConnReq, sizeof(MSG_P2P_CONNECTION_REQUEST_T));
prP2pConnReq->rMsgHdr.eMsgId = MID_MNY_P2P_CONNECTION_REQ;
prP2pConnReq->eFormationPolicy = ENUM_P2P_FORMATION_POLICY_AUTO;
COPY_MAC_ADDR(prP2pConnReq->aucDeviceID, prP2pDevDesc->aucDeviceAddr);
prP2pConnReq->u2ConfigMethod = prP2pDevDesc->u2ConfigMethod;
if (ucInvitationType == P2P_INVITATION_TYPE_INVITATION) {
prP2pConnReq->fgIsPersistentGroup = FALSE;
prP2pConnReq->fgIsTobeGO = FALSE;
}
else if (ucInvitationType == P2P_INVITATION_TYPE_REINVOKE) {
DBGLOG(P2P, TRACE, ("Re-invoke Persistent Group\n"));
prP2pConnReq->fgIsPersistentGroup = TRUE;
prP2pConnReq->fgIsTobeGO = (prGlueInfo->prP2PInfo->ucRole == 2)?TRUE:FALSE;
}
p2pFsmRunEventDeviceDiscoveryAbort(prGlueInfo->prAdapter, NULL);
if (ucOperatingChnl != 0) {
prP2pSpecificBssInfo->ucPreferredChannel = ucOperatingChnl;
}
if ((ucSsidLen < 32) && (pucSsid != NULL)) {
COPY_SSID(prP2pConnSettings->aucSSID,
prP2pConnSettings->ucSSIDLen,
pucSsid,
ucSsidLen);
}
mboxSendMsg(prGlueInfo->prAdapter,
MBOX_ID_0,
(P_MSG_HDR_T)prP2pConnReq,
MSG_SEND_METHOD_BUF);
} while (FALSE);
// frog add.
// TODO: Invitation Indication
return;
#endif
} /* kalP2PInvitationIndication */
/*----------------------------------------------------------------------------*/
VOID
cnmChMngrHandleChEvent (
P_ADAPTER_T prAdapter,
P_WIFI_EVENT_T prEvent
)
{
P_EVENT_CH_PRIVILEGE_T prEventBody;
P_MSG_CH_GRANT_T prChResp;
P_BSS_INFO_T prBssInfo;
P_CNM_INFO_T prCnmInfo;
ASSERT(prAdapter);
ASSERT(prEvent);
prEventBody = (P_EVENT_CH_PRIVILEGE_T) (prEvent->aucBuffer);
prChResp = (P_MSG_CH_GRANT_T)
cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_CH_GRANT_T));
ASSERT(prChResp);
/* To do: exception handle */
if (!prChResp) {
DBGLOG(CNM, ERROR, ("ChGrant: fail to get buf (net=%d, token=%d)\n",
prEventBody->ucBssIndex, prEventBody->ucTokenID));
return;
}
DBGLOG(CNM, INFO, ("ChGrant net=%d token=%d ch=%d sco=%d\n",
prEventBody->ucBssIndex, prEventBody->ucTokenID,
prEventBody->ucPrimaryChannel, prEventBody->ucRfSco));
ASSERT(prEventBody->ucBssIndex <= MAX_BSS_INDEX);
ASSERT(prEventBody->ucStatus == EVENT_CH_STATUS_GRANT);
prBssInfo = prAdapter->aprBssInfo[prEventBody->ucBssIndex];
/* Decide message ID based on network and response status */
if (IS_BSS_AIS(prBssInfo)) {
prChResp->rMsgHdr.eMsgId = MID_CNM_AIS_CH_GRANT;
}
#if CFG_ENABLE_WIFI_DIRECT
else if (prAdapter->fgIsP2PRegistered && IS_BSS_P2P(prBssInfo)) {
prChResp->rMsgHdr.eMsgId = MID_CNM_P2P_CH_GRANT;
}
#endif
#if CFG_ENABLE_BT_OVER_WIFI
else if (IS_BSS_BOW(prBssInfo)) {
prChResp->rMsgHdr.eMsgId = MID_CNM_BOW_CH_GRANT;
}
#endif
else {
cnmMemFree(prAdapter, prChResp);
return;
}
prChResp->ucBssIndex = prEventBody->ucBssIndex;
prChResp->ucTokenID = prEventBody->ucTokenID;
prChResp->ucPrimaryChannel = prEventBody->ucPrimaryChannel;
prChResp->eRfSco = (ENUM_CHNL_EXT_T) prEventBody->ucRfSco;
prChResp->eRfBand = (ENUM_BAND_T) prEventBody->ucRfBand;
prChResp->eRfChannelWidth =
(ENUM_CHANNEL_WIDTH_T) prEventBody->ucRfChannelWidth;
prChResp->ucRfCenterFreqSeg1 = prEventBody->ucRfCenterFreqSeg1;
prChResp->ucRfCenterFreqSeg2 = prEventBody->ucRfCenterFreqSeg2;
prChResp->eReqType = (ENUM_CH_REQ_TYPE_T) prEventBody->ucReqType;
prChResp->u4GrantInterval = prEventBody->u4GrantInterval;
mboxSendMsg(prAdapter,
MBOX_ID_0,
(P_MSG_HDR_T) prChResp,
MSG_SEND_METHOD_BUF);
/* Record current granted BSS for TXM's reference */
prCnmInfo = &prAdapter->rCnmInfo;
prCnmInfo->ucBssIndex = prEventBody->ucBssIndex;
prCnmInfo->ucTokenID = prEventBody->ucTokenID;
prCnmInfo->fgChGranted = TRUE;
}
