4 #pragma GCC diagnostic ignored "-Wformat"
8 APPEND_VAR_ATTRI_ENTRY_T txAssocRspAttributesTable[] = {
9 { (P2P_ATTRI_HDR_LEN + P2P_ATTRI_MAX_LEN_STATUS) , NULL, p2pFuncAppendAttriStatusForAssocRsp } /* 0 */ // Status
10 ,{ (P2P_ATTRI_HDR_LEN + P2P_ATTRI_MAX_LEN_EXT_LISTEN_TIMING), NULL, p2pFuncAppendAttriExtListenTiming } /* 8 */
14 APPEND_VAR_IE_ENTRY_T txProbeRspIETable[] = {
15 { (ELEM_HDR_LEN + (RATE_NUM - ELEM_MAX_LEN_SUP_RATES)), NULL, bssGenerateExtSuppRate_IE } /* 50 */
16 ,{ (ELEM_HDR_LEN + ELEM_MAX_LEN_ERP), NULL, rlmRspGenerateErpIE } /* 42 */
17 ,{ (ELEM_HDR_LEN + ELEM_MAX_LEN_HT_CAP), NULL, rlmRspGenerateHtCapIE } /* 45 */
18 ,{ (ELEM_HDR_LEN + ELEM_MAX_LEN_HT_OP), NULL, rlmRspGenerateHtOpIE } /* 61 */
19 ,{ (ELEM_HDR_LEN + ELEM_MAX_LEN_RSN), NULL, rsnGenerateRSNIE } /* 48 */
20 ,{ (ELEM_HDR_LEN + ELEM_MAX_LEN_OBSS_SCAN), NULL, rlmRspGenerateObssScanIE } /* 74 */
21 ,{ (ELEM_HDR_LEN + ELEM_MAX_LEN_EXT_CAP), NULL, rlmRspGenerateExtCapIE } /* 127 */
22 ,{ (ELEM_HDR_LEN + ELEM_MAX_LEN_WPA), NULL, rsnGenerateWpaNoneIE } /* 221 */
23 ,{ (ELEM_HDR_LEN + ELEM_MAX_LEN_WMM_PARAM), NULL, mqmGenerateWmmParamIE } /* 221 */
26 /*----------------------------------------------------------------------------*/
28 * @brief Function for requesting scan. There is an option to do ACTIVE or PASSIVE scan.
30 * @param eScanType - Specify the scan type of the scan request. It can be an ACTIVE/PASSIVE
32 * eChannelSet - Specify the prefered channel set.
33 * A FULL scan would request a legacy full channel normal scan.(usually ACTIVE).
34 * A P2P_SOCIAL scan would scan 1+6+11 channels.(usually ACTIVE)
35 * A SPECIFIC scan would only 1/6/11 channels scan. (Passive Listen/Specific Search)
36 * ucChannelNum - A specific channel number. (Only when channel is specified)
37 * eBand - A specific band. (Only when channel is specified)
42 /*----------------------------------------------------------------------------*/
45 IN P_ADAPTER_T prAdapter,
46 IN P_P2P_SCAN_REQ_INFO_T prScanReqInfo
50 P_MSG_SCN_SCAN_REQ prScanReq = (P_MSG_SCN_SCAN_REQ)NULL;
52 DEBUGFUNC("p2pFuncRequestScan()");
55 ASSERT_BREAK((prAdapter != NULL) &&
56 (prScanReqInfo != NULL));
58 if (prScanReqInfo->eChannelSet == SCAN_CHANNEL_SPECIFIED) {
59 ASSERT_BREAK(prScanReqInfo->ucNumChannelList > 0);
60 DBGLOG(P2P, LOUD, ("P2P Scan Request Channel:%d\n", prScanReqInfo->arScanChannelList[0].ucChannelNum));
63 prScanReq = (P_MSG_SCN_SCAN_REQ)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_SCN_SCAN_REQ));
65 ASSERT(0); // Can't trigger SCAN FSM
69 prScanReq->rMsgHdr.eMsgId = MID_P2P_SCN_SCAN_REQ;
70 prScanReq->ucSeqNum = ++prScanReqInfo->ucSeqNumOfScnMsg;
71 prScanReq->ucNetTypeIndex = (UINT_8)NETWORK_TYPE_P2P_INDEX;
72 prScanReq->eScanType = prScanReqInfo->eScanType;
73 prScanReq->eScanChannel = prScanReqInfo->eChannelSet;
74 prScanReq->u2IELen = 0;
76 /* Copy IE for Probe Request. */
77 kalMemCopy(prScanReq->aucIE, prScanReqInfo->aucIEBuf, prScanReqInfo->u4BufLength);
78 prScanReq->u2IELen = (UINT_16)prScanReqInfo->u4BufLength;
80 prScanReq->u2ChannelDwellTime = prScanReqInfo->u2PassiveDewellTime;
82 switch (prScanReqInfo->eChannelSet) {
83 case SCAN_CHANNEL_SPECIFIED:
86 P_RF_CHANNEL_INFO_T prDomainInfo = (P_RF_CHANNEL_INFO_T)prScanReqInfo->arScanChannelList;
88 if (prScanReqInfo->ucNumChannelList > MAXIMUM_OPERATION_CHANNEL_LIST) {
89 prScanReqInfo->ucNumChannelList = MAXIMUM_OPERATION_CHANNEL_LIST;
93 for (u4Idx = 0; u4Idx < prScanReqInfo->ucNumChannelList; u4Idx++) {
94 prScanReq->arChnlInfoList[u4Idx].ucChannelNum = prDomainInfo->ucChannelNum;
95 prScanReq->arChnlInfoList[u4Idx].eBand = prDomainInfo->eBand;
99 prScanReq->ucChannelListNum = prScanReqInfo->ucNumChannelList;
101 case SCAN_CHANNEL_FULL:
102 case SCAN_CHANNEL_2G4:
103 case SCAN_CHANNEL_P2P_SOCIAL:
105 UINT_8 aucP2pSsid[] = P2P_WILDCARD_SSID;
107 COPY_SSID(prScanReq->aucSSID,
108 prScanReq->ucSSIDLength,
109 prScanReqInfo->rSsidStruct.aucSsid,
110 prScanReqInfo->rSsidStruct.ucSsidLen);
112 /* For compatible. */
113 if (EQUAL_SSID(aucP2pSsid, P2P_WILDCARD_SSID_LEN, prScanReq->aucSSID, prScanReq->ucSSIDLength)) {
114 prScanReq->ucSSIDType = SCAN_REQ_SSID_P2P_WILDCARD;
116 else if (prScanReq->ucSSIDLength != 0) {
117 prScanReq->ucSSIDType = SCAN_REQ_SSID_SPECIFIED;
122 /* Currently there is no other scan channel set. */
127 mboxSendMsg(prAdapter,
129 (P_MSG_HDR_T)prScanReq,
130 MSG_SEND_METHOD_BUF);
135 } /* p2pFuncRequestScan */
139 IN P_ADAPTER_T prAdapter,
140 IN P_P2P_SCAN_REQ_INFO_T prScanInfo
143 P_MSG_SCN_SCAN_CANCEL prScanCancelMsg = (P_MSG_SCN_SCAN_CANCEL)NULL;
146 ASSERT_BREAK((prAdapter != NULL) && (prScanInfo != NULL));
148 if (!prScanInfo->fgIsScanRequest) {
153 if (prScanInfo->ucSeqNumOfScnMsg) {
154 /* There is a channel privilege on hand. */
155 DBGLOG(P2P, TRACE, ("P2P Cancel Scan\n"));
157 prScanCancelMsg = (P_MSG_SCN_SCAN_CANCEL)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_SCN_SCAN_CANCEL));
158 if (!prScanCancelMsg) {
159 /* Buffer not enough, can not cancel scan request. */
160 DBGLOG(P2P, TRACE, ("Buffer not enough, can not cancel scan.\n"));
165 prScanCancelMsg->rMsgHdr.eMsgId = MID_P2P_SCN_SCAN_CANCEL;
166 prScanCancelMsg->ucNetTypeIndex = NETWORK_TYPE_P2P_INDEX;
167 prScanCancelMsg->ucSeqNum = prScanInfo->ucSeqNumOfScnMsg++;
168 prScanCancelMsg->fgIsChannelExt = FALSE;
169 prScanInfo->fgIsScanRequest = FALSE;
171 mboxSendMsg(prAdapter,
173 (P_MSG_HDR_T)prScanCancelMsg,
174 MSG_SEND_METHOD_BUF);
183 } /* p2pFuncCancelScan */
187 p2pFuncSwitchOPMode (
188 IN P_ADAPTER_T prAdapter,
189 IN P_BSS_INFO_T prP2pBssInfo,
190 IN ENUM_OP_MODE_T eOpMode,
191 IN BOOLEAN fgSyncToFW
195 ASSERT_BREAK((prAdapter != NULL) &&
196 (prP2pBssInfo != NULL) &&
197 (eOpMode < OP_MODE_NUM));
199 if (prP2pBssInfo->eCurrentOPMode != eOpMode) {
200 DBGLOG(P2P, TRACE, ("p2pFuncSwitchOPMode: Switch to from %d, to %d.\n", prP2pBssInfo->eCurrentOPMode, eOpMode));
202 switch (prP2pBssInfo->eCurrentOPMode) {
203 case OP_MODE_ACCESS_POINT:
204 p2pFuncDissolve(prAdapter, prP2pBssInfo, TRUE, REASON_CODE_DEAUTH_LEAVING_BSS);
206 p2pFsmRunEventStopAP(prAdapter, NULL);
213 prP2pBssInfo->eIntendOPMode = eOpMode;
214 prP2pBssInfo->eCurrentOPMode = eOpMode;
216 case OP_MODE_INFRASTRUCTURE:
217 DBGLOG(P2P, TRACE, ("p2pFuncSwitchOPMode: Switch to Client.\n"));
218 case OP_MODE_ACCESS_POINT:
219 // if (!IS_BSS_ACTIVE(prP2pBssInfo)) {
220 // SET_NET_ACTIVE(prAdapter, NETWORK_TYPE_P2P_INDEX);
221 // nicActivateNetwork(prAdapter, NETWORK_TYPE_P2P_INDEX);
224 /* Change interface address. */
225 if (eOpMode == OP_MODE_ACCESS_POINT) {
226 DBGLOG(P2P, TRACE, ("p2pFuncSwitchOPMode: Switch to AP.\n"));
227 prP2pBssInfo->ucSSIDLen = 0;
230 COPY_MAC_ADDR(prP2pBssInfo->aucOwnMacAddr, prAdapter->rWifiVar.aucInterfaceAddress);
231 COPY_MAC_ADDR(prP2pBssInfo->aucBSSID, prAdapter->rWifiVar.aucInterfaceAddress);
235 case OP_MODE_P2P_DEVICE:
237 /* Change device address. */
238 DBGLOG(P2P, TRACE, ("p2pFuncSwitchOPMode: Switch back to P2P Device.\n"));
240 // if (!IS_BSS_ACTIVE(prP2pBssInfo)) {
241 // SET_NET_ACTIVE(prAdapter, NETWORK_TYPE_P2P_INDEX);
242 // nicActivateNetwork(prAdapter, NETWORK_TYPE_P2P_INDEX);
245 p2pChangeMediaState(prAdapter, PARAM_MEDIA_STATE_DISCONNECTED);
247 COPY_MAC_ADDR(prP2pBssInfo->aucOwnMacAddr, prAdapter->rWifiVar.aucDeviceAddress);
248 COPY_MAC_ADDR(prP2pBssInfo->aucBSSID, prAdapter->rWifiVar.aucDeviceAddress);
254 // if (IS_BSS_ACTIVE(prP2pBssInfo)) {
255 // UNSET_NET_ACTIVE(prAdapter, NETWORK_TYPE_P2P_INDEX);
257 // nicDeactivateNetwork(prAdapter, NETWORK_TYPE_P2P_INDEX);
264 P2P_DISCONNECT_INFO rP2PDisInfo;
266 rP2PDisInfo.ucRole = 2;
267 wlanSendSetQueryCmd(prAdapter,
274 sizeof(P2P_DISCONNECT_INFO),
275 (PUINT_8)&rP2PDisInfo,
281 DBGLOG(P2P, TRACE, ("The device address is changed to " MACSTR " \n", MAC2STR(prP2pBssInfo->aucOwnMacAddr)));
282 DBGLOG(P2P, TRACE, ("The BSSID is changed to " MACSTR " \n", MAC2STR(prP2pBssInfo->aucBSSID)));
284 /* Update BSS INFO to FW. */
285 if ((fgSyncToFW) && (eOpMode != OP_MODE_ACCESS_POINT)) {
286 nicUpdateBss(prAdapter, NETWORK_TYPE_P2P_INDEX);
293 } /* p2pFuncSwitchOPMode */
297 /*----------------------------------------------------------------------------*/
299 * @brief This function will start a P2P Group Owner and send Beacon Frames.
305 /*----------------------------------------------------------------------------*/
308 IN P_ADAPTER_T prAdapter,
309 IN P_BSS_INFO_T prBssInfo,
310 IN PUINT_8 pucSsidBuf,
312 IN UINT_8 ucChannelNum,
313 IN ENUM_BAND_T eBand,
314 IN ENUM_CHNL_EXT_T eSco,
315 IN BOOLEAN fgIsPureAP
319 ASSERT_BREAK((prAdapter != NULL) && (prBssInfo != NULL));
321 ASSERT(prBssInfo->eCurrentOPMode == OP_MODE_ACCESS_POINT);
323 DBGLOG(P2P, TRACE, ("p2pFuncStartGO:\n"));
325 /* AP mode started. */
326 p2pFuncSwitchOPMode(prAdapter, prBssInfo, prBssInfo->eIntendOPMode, FALSE);
328 prBssInfo->eIntendOPMode = OP_MODE_NUM;
330 //4 <1.1> Assign SSID
331 COPY_SSID(prBssInfo->aucSSID,
332 prBssInfo->ucSSIDLen,
336 DBGLOG(P2P, TRACE, ("GO SSID:%s \n", prBssInfo->aucSSID));
338 //4 <1.2> Clear current AP's STA_RECORD_T and current AID
339 prBssInfo->prStaRecOfAP = (P_STA_RECORD_T)NULL;
340 prBssInfo->u2AssocId = 0;
343 //4 <1.3> Setup Channel, Band and Phy Attributes
344 prBssInfo->ucPrimaryChannel = ucChannelNum;
345 prBssInfo->eBand = eBand;
346 prBssInfo->eBssSCO = eSco;
348 DBGLOG(P2P, TRACE, ("GO Channel:%d \n", ucChannelNum));
351 if (prBssInfo->eBand == BAND_5G) {
352 prBssInfo->ucPhyTypeSet = (prAdapter->rWifiVar.ucAvailablePhyTypeSet & PHY_TYPE_SET_802_11AN); /* Depend on eBand */
353 prBssInfo->ucConfigAdHocAPMode = AP_MODE_11A; /* Depend on eCurrentOPMode and ucPhyTypeSet */
355 else if (fgIsPureAP) {
356 prBssInfo->ucPhyTypeSet = (prAdapter->rWifiVar.ucAvailablePhyTypeSet & PHY_TYPE_SET_802_11BGN); /* Depend on eBand */
357 prBssInfo->ucConfigAdHocAPMode = AP_MODE_MIXED_11BG; /* Depend on eCurrentOPMode and ucPhyTypeSet */
360 prBssInfo->ucPhyTypeSet = (prAdapter->rWifiVar.ucAvailablePhyTypeSet & PHY_TYPE_SET_802_11GN); /* Depend on eBand */
361 prBssInfo->ucConfigAdHocAPMode = AP_MODE_11G_P2P; /* Depend on eCurrentOPMode and ucPhyTypeSet */
365 prBssInfo->ucNonHTBasicPhyType = (UINT_8)
366 rNonHTApModeAttributes[prBssInfo->ucConfigAdHocAPMode].ePhyTypeIndex;
367 prBssInfo->u2BSSBasicRateSet =
368 rNonHTApModeAttributes[prBssInfo->ucConfigAdHocAPMode].u2BSSBasicRateSet;
369 prBssInfo->u2OperationalRateSet =
370 rNonHTPhyAttributes[prBssInfo->ucNonHTBasicPhyType].u2SupportedRateSet;
372 if (prBssInfo->ucAllSupportedRatesLen == 0) {
373 rateGetDataRatesFromRateSet(prBssInfo->u2OperationalRateSet,
374 prBssInfo->u2BSSBasicRateSet,
375 prBssInfo->aucAllSupportedRates,
376 &prBssInfo->ucAllSupportedRatesLen);
379 //4 <1.5> Setup MIB for current BSS
380 prBssInfo->u2ATIMWindow = 0;
381 prBssInfo->ucBeaconTimeoutCount = 0;
383 //3 <2> Update BSS_INFO_T common part
386 prBssInfo->fgIsProtection = TRUE; /* Always enable protection at P2P GO */
387 kalP2PSetCipher(prAdapter->prGlueInfo, IW_AUTH_CIPHER_CCMP);
390 if (kalP2PGetCipher(prAdapter->prGlueInfo))
391 prBssInfo->fgIsProtection = TRUE;
394 // 20120106 frog: I want separate OP_Mode & Beacon TX Function.
395 //p2pFuncSwitchOPMode(prAdapter, prBssInfo, OP_MODE_ACCESS_POINT, FALSE);
397 bssInitForAP(prAdapter, prBssInfo, FALSE);
399 nicQmUpdateWmmParms(prAdapter, NETWORK_TYPE_P2P_INDEX);
400 #endif /* CFG_SUPPORT_AAA */
404 //4 <3.1> Setup channel and bandwidth
405 rlmBssInitForAPandIbss(prAdapter, prBssInfo);
407 //4 <3.2> Reset HW TSF Update Mode and Beacon Mode
408 nicUpdateBss(prAdapter, NETWORK_TYPE_P2P_INDEX);
410 //4 <3.3> Update Beacon again for network phy type confirmed.
411 bssUpdateBeaconContent(prAdapter, NETWORK_TYPE_P2P_INDEX);
413 //4 <3.4> Setup BSSID
414 nicPmIndicateBssCreated(prAdapter, NETWORK_TYPE_P2P_INDEX);
419 } /* p2pFuncStartGO() */
424 /*----------------------------------------------------------------------------*/
426 * \brief This function is to inform CNM that channel privilege
429 * \param[in] prAdapter Pointer of ADAPTER_T
433 /*----------------------------------------------------------------------------*/
436 IN P_ADAPTER_T prAdapter,
437 IN P_P2P_CHNL_REQ_INFO_T prChnlReqInfo
440 P_MSG_CH_ABORT_T prMsgChRelease = (P_MSG_CH_ABORT_T)NULL;
442 DEBUGFUNC("p2pFuncReleaseCh()");
445 ASSERT_BREAK((prAdapter != NULL) && (prChnlReqInfo != NULL));
447 if (!prChnlReqInfo->fgIsChannelRequested) {
451 DBGLOG(P2P, TRACE, ("P2P Release Channel\n"));
452 prChnlReqInfo->fgIsChannelRequested = FALSE;
455 /* 1. return channel privilege to CNM immediately */
456 prMsgChRelease = (P_MSG_CH_ABORT_T)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_CH_ABORT_T));
457 if (!prMsgChRelease) {
458 ASSERT(0); // Can't release Channel to CNM
462 prMsgChRelease->rMsgHdr.eMsgId = MID_MNY_CNM_CH_ABORT;
463 prMsgChRelease->ucNetTypeIndex = NETWORK_TYPE_P2P_INDEX;
464 prMsgChRelease->ucTokenID = prChnlReqInfo->ucSeqNumOfChReq++;
466 mboxSendMsg(prAdapter,
468 (P_MSG_HDR_T) prMsgChRelease,
469 MSG_SEND_METHOD_BUF);
474 } /* p2pFuncReleaseCh */
477 /*----------------------------------------------------------------------------*/
479 * @brief Process of CHANNEL_REQ_JOIN Initial. Enter CHANNEL_REQ_JOIN State.
485 /*----------------------------------------------------------------------------*/
488 IN P_ADAPTER_T prAdapter,
489 IN P_P2P_CHNL_REQ_INFO_T prChnlReqInfo
492 P_MSG_CH_REQ_T prMsgChReq = (P_MSG_CH_REQ_T)NULL;
495 ASSERT_BREAK((prAdapter != NULL) && (prChnlReqInfo != NULL));
497 p2pFuncReleaseCh(prAdapter, prChnlReqInfo);
499 /* send message to CNM for acquiring channel */
500 prMsgChReq = (P_MSG_CH_REQ_T)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_CH_REQ_T));
503 ASSERT(0); // Can't indicate CNM for channel acquiring
507 prMsgChReq->rMsgHdr.eMsgId = MID_MNY_CNM_CH_REQ;
508 prMsgChReq->ucNetTypeIndex = NETWORK_TYPE_P2P_INDEX;
509 prMsgChReq->ucTokenID = ++prChnlReqInfo->ucSeqNumOfChReq;
510 prMsgChReq->eReqType = CH_REQ_TYPE_JOIN;
511 prMsgChReq->u4MaxInterval = prChnlReqInfo->u4MaxInterval;
513 prMsgChReq->ucPrimaryChannel = prChnlReqInfo->ucReqChnlNum;
514 prMsgChReq->eRfSco = prChnlReqInfo->eChnlSco;
515 prMsgChReq->eRfBand = prChnlReqInfo->eBand;
517 kalMemZero(prMsgChReq->aucBSSID, MAC_ADDR_LEN);
519 /* Channel request join BSSID. */
521 mboxSendMsg(prAdapter,
523 (P_MSG_HDR_T) prMsgChReq,
524 MSG_SEND_METHOD_BUF);
526 prChnlReqInfo->fgIsChannelRequested = TRUE;
531 } /* p2pFuncAcquireCh */
536 IN P_ADAPTER_T prAdapter,
537 IN PUINT_8 pucBcnHdr,
539 IN PUINT_8 pucBcnBody,
540 IN UINT_32 u4BodyLen,
541 IN UINT_32 u4DtimPeriod,
542 IN UINT_32 u4BcnInterval)
544 WLAN_STATUS rResultStatus = WLAN_STATUS_INVALID_DATA;
545 P_WLAN_BEACON_FRAME_T prBcnFrame = (P_WLAN_BEACON_FRAME_T)NULL;
546 P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T)NULL;
547 P_MSDU_INFO_T prBcnMsduInfo = (P_MSDU_INFO_T)NULL;
548 PUINT_8 pucTIMBody = (PUINT_8)NULL;
549 UINT_16 u2FrameLength = 0, UINT_16 u2OldBodyLen = 0;
550 UINT_8 aucIEBuf[MAX_IE_LENGTH];
553 ASSERT_BREAK(prAdapter != NULL);
555 prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
556 prBcnMsduInfo = prP2pBssInfo->prBeacon
558 ASSERT_BREAK(prBcnMsduInfo != NULL);
560 /* TODO: Find TIM IE pointer. */
561 prBcnFrame = prBcnMsduInfo->prPacket;
563 ASSERT_BREAK(prBcnFrame != NULL);
567 UINT_16 u2IELength = 0, u2Offset = 0;
568 PUINT_8 pucIEBuf = prBcnFrame->aucInfoElem;
570 u2IELength = prBcnMsduInfo->u2FrameLength - prBcnMsduInfo->ucMacHeaderLength;
572 IE_FOR_EACH(pucIEBuf, u2IELength, u2Offset) {
573 if ((IE_ID(pucIEBuf) == ELEM_ID_TIM) ||
574 ((IE_ID(pucIEBuf) > ELEM_ID_IBSS_PARAM_SET)) {
575 pucTIMBody = pucIEBuf;
578 u2FrameLength += IE_SIZE(pucIEBuf);
581 if (pucTIMBody == NULL) {
582 pucTIMBody = pucIEBuf;
585 /* Body not change. */
586 u2OldBodyLen = (UINT_16)((UINT_32)pucTIMBody - (UINT_32)prBcnFrame->aucInfoElem);
589 kalMemCmp(aucIEBuf, pucTIMBody, u2OldBodyLen);
594 kalMemCopy(prBcnMsduInfo->prPacket, pucBcnHdr, u4HdrLen);
596 pucTIMBody = (PUINT_8)((UINT_32)prBcnMsduInfo->prPacket + u4HdrLen);
598 prBcnMsduInfo->ucMacHeaderLength = (WLAN_MAC_MGMT_HEADER_LEN +
599 (TIMESTAMP_FIELD_LEN + BEACON_INTERVAL_FIELD_LEN + CAP_INFO_FIELD_LEN));
601 u2FrameLength = u4HdrLen; /* Header + Partial Body. */
605 /* Header not change. */
606 u2FrameLength += prBcnMsduInfo->ucMacHeaderLength;
611 kalMemCopy(pucTIMBody, pucBcnBody, u4BodyLen);
612 u2FrameLength += (UINT_16)u4BodyLen;
615 kalMemCopy(pucTIMBody, aucIEBuf, u2OldBodyLen);
616 u2FrameLength += u2OldBodyLen;
620 prBcnMsduInfo->u2FrameLength = u2FrameLength;
622 prBcnMsduInfo->fgIs802_11 = TRUE;
623 prBcnMsduInfo->ucNetworkType = NETWORK_TYPE_P2P_INDEX;
625 prP2pBssInfo->u2BeaconInterval = (UINT_16)u4BcnInterval;
626 prP2pBssInfo->ucDTIMPeriod = (UINT_8)u4DtimPeriod;
627 prP2pBssInfo->u2CapInfo = prBcnFrame->u2CapInfo;
628 prBcnMsduInfo->ucPacketType = 3;
630 rResultStatus = nicUpdateBeaconIETemplate(prAdapter,
631 IE_UPD_METHOD_UPDATE_ALL,
632 NETWORK_TYPE_P2P_INDEX,
633 prP2pBssInfo->u2CapInfo,
634 (PUINT_8)prBcnFrame->aucInfoElem,
635 prBcnMsduInfo->u2FrameLength - OFFSET_OF(WLAN_BEACON_FRAME_T, aucInfoElem));
637 if (prP2pBssInfo->eCurrentOPMode == OP_MODE_ACCESS_POINT) {
638 /* AP is created, Beacon Update. */
639 nicPmIndicateBssAbort(prAdapter, NETWORK_TYPE_P2P_INDEX);
641 nicPmIndicateBssCreated(prAdapter, NETWORK_TYPE_P2P_INDEX);
646 return rResultStatus;
647 } /* p2pFuncBeaconUpdate */
651 p2pFuncBeaconUpdate (
652 IN P_ADAPTER_T prAdapter,
653 IN P_BSS_INFO_T prP2pBssInfo,
654 IN P_P2P_BEACON_UPDATE_INFO_T prBcnUpdateInfo,
655 IN PUINT_8 pucNewBcnHdr,
656 IN UINT_32 u4NewHdrLen,
657 IN PUINT_8 pucNewBcnBody,
658 IN UINT_32 u4NewBodyLen
661 WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
662 P_WLAN_BEACON_FRAME_T prBcnFrame = (P_WLAN_BEACON_FRAME_T)NULL;
663 P_MSDU_INFO_T prBcnMsduInfo = (P_MSDU_INFO_T)NULL;
664 PUINT_8 pucIEBuf = (PUINT_8)NULL;
665 UINT_8 aucIEBuf[MAX_IE_LENGTH];
668 ASSERT_BREAK((prAdapter != NULL) &&
669 (prP2pBssInfo != NULL) &&
670 (prBcnUpdateInfo != NULL));
672 prBcnMsduInfo = prP2pBssInfo->prBeacon;
675 if (prBcnUpdateInfo->pucBcnHdr != NULL) {
676 ASSERT((UINT_32)prBcnUpdateInfo->pucBcnHdr == ((UINT_32)prBcnMsduInfo->prPacket + MAC_TX_RESERVED_FIELD));
679 if (prBcnUpdateInfo->pucBcnBody != NULL) {
680 ASSERT((UINT_32)prBcnUpdateInfo->pucBcnBody == ((UINT_32)prBcnUpdateInfo->pucBcnHdr + (UINT_32)prBcnUpdateInfo->u4BcnHdrLen));
683 prBcnFrame = (P_WLAN_BEACON_FRAME_T)((UINT_32)prBcnMsduInfo->prPacket + MAC_TX_RESERVED_FIELD);
685 if (!pucNewBcnBody) {
687 pucNewBcnBody = prBcnUpdateInfo->pucBcnBody;
688 ASSERT(u4NewBodyLen == 0);
689 u4NewBodyLen = prBcnUpdateInfo->u4BcnBodyLen;
692 prBcnUpdateInfo->u4BcnBodyLen = u4NewBodyLen;
695 /* Temp buffer body part. */
696 kalMemCopy(aucIEBuf, pucNewBcnBody, u4NewBodyLen);
699 kalMemCopy(prBcnFrame, pucNewBcnHdr, u4NewHdrLen);
700 prBcnUpdateInfo->pucBcnHdr = (PUINT_8)prBcnFrame;
701 prBcnUpdateInfo->u4BcnHdrLen = u4NewHdrLen;
704 pucIEBuf = (PUINT_8)((UINT_32)prBcnUpdateInfo->pucBcnHdr + (UINT_32)prBcnUpdateInfo->u4BcnHdrLen);
705 kalMemCopy(pucIEBuf, aucIEBuf, u4NewBodyLen);
706 prBcnUpdateInfo->pucBcnBody = pucIEBuf;
709 prBcnMsduInfo->u2FrameLength = (UINT_16)(prBcnUpdateInfo->u4BcnHdrLen + prBcnUpdateInfo->u4BcnBodyLen);
711 prBcnMsduInfo->ucPacketType = 3;
712 prBcnMsduInfo->fgIs802_11 = TRUE;
713 prBcnMsduInfo->ucNetworkType = NETWORK_TYPE_P2P_INDEX;
716 /* Update BSS INFO related information. */
717 COPY_MAC_ADDR(prP2pBssInfo->aucOwnMacAddr, prBcnFrame->aucSrcAddr);
718 COPY_MAC_ADDR(prP2pBssInfo->aucBSSID, prBcnFrame->aucBSSID);
719 prP2pBssInfo->u2CapInfo = prBcnFrame->u2CapInfo;
721 p2pFuncParseBeaconContent(prAdapter,
723 (PUINT_8)prBcnFrame->aucInfoElem,
724 (prBcnMsduInfo->u2FrameLength - OFFSET_OF(WLAN_BEACON_FRAME_T, aucInfoElem)));
727 //bssUpdateBeaconContent(prAdapter, NETWORK_TYPE_P2P_INDEX);
729 nicUpdateBeaconIETemplate(prAdapter,
730 IE_UPD_METHOD_UPDATE_ALL,
731 NETWORK_TYPE_P2P_INDEX,
732 prBcnFrame->u2CapInfo,
733 (PUINT_8)prBcnFrame->aucInfoElem,
734 (prBcnMsduInfo->u2FrameLength - OFFSET_OF(WLAN_BEACON_FRAME_T, aucInfoElem)));
739 } /* p2pFuncBeaconUpdate */
743 // TODO: We do not apply IE in deauth frame set from upper layer now.
746 IN P_ADAPTER_T prAdapter,
747 IN PUINT_8 pucPeerMacAddr,
748 IN UINT_16 u2ReasonCode,
751 IN BOOLEAN fgSendDeauth
754 WLAN_STATUS rWlanStatus = WLAN_STATUS_FAILURE;
755 P_STA_RECORD_T prCliStaRec = (P_STA_RECORD_T)NULL;
756 P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T)NULL;
757 BOOLEAN fgIsStaFound = FALSE;
760 ASSERT_BREAK((prAdapter != NULL) && (pucPeerMacAddr != NULL));
762 prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
764 prCliStaRec = cnmGetStaRecByAddress(prAdapter,
765 NETWORK_TYPE_P2P_INDEX,
768 switch (prP2pBssInfo->eCurrentOPMode) {
769 case OP_MODE_ACCESS_POINT:
771 P_LINK_T prStaRecOfClientList = (P_LINK_T)NULL;
772 P_LINK_ENTRY_T prLinkEntry = (P_LINK_ENTRY_T)NULL;
774 prStaRecOfClientList = &(prP2pBssInfo->rStaRecOfClientList);
776 LINK_FOR_EACH(prLinkEntry, prStaRecOfClientList) {
777 if ((UINT_32)prCliStaRec == (UINT_32)prLinkEntry) {
778 LINK_REMOVE_KNOWN_ENTRY(prStaRecOfClientList, &prCliStaRec->rLinkEntry);
786 case OP_MODE_INFRASTRUCTURE:
787 ASSERT(prCliStaRec == prP2pBssInfo->prStaRecOfAP);
788 if (prCliStaRec != prP2pBssInfo->prStaRecOfAP) {
791 prP2pBssInfo->prStaRecOfAP = NULL;
799 p2pFuncDisconnect(prAdapter, prCliStaRec, fgSendDeauth, u2ReasonCode);
802 rWlanStatus = WLAN_STATUS_SUCCESS;
806 } /* p2pFuncDeauth */
808 // TODO: We do not apply IE in disassoc frame set from upper layer now.
811 IN P_ADAPTER_T prAdapter,
812 IN PUINT_8 pucPeerMacAddr,
813 IN UINT_16 u2ReasonCode,
816 IN BOOLEAN fgSendDisassoc
819 WLAN_STATUS rWlanStatus = WLAN_STATUS_FAILURE;
820 P_STA_RECORD_T prCliStaRec = (P_STA_RECORD_T)NULL;
821 P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T)NULL;
822 BOOLEAN fgIsStaFound = FALSE;
825 ASSERT_BREAK((prAdapter != NULL) && (pucPeerMacAddr != NULL));
827 prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
829 prCliStaRec = cnmGetStaRecByAddress(prAdapter,
830 NETWORK_TYPE_P2P_INDEX,
833 switch (prP2pBssInfo->eCurrentOPMode) {
834 case OP_MODE_ACCESS_POINT:
836 P_LINK_T prStaRecOfClientList = (P_LINK_T)NULL;
837 P_LINK_ENTRY_T prLinkEntry = (P_LINK_ENTRY_T)NULL;
839 prStaRecOfClientList = &(prP2pBssInfo->rStaRecOfClientList);
841 LINK_FOR_EACH(prLinkEntry, prStaRecOfClientList) {
842 if ((UINT_32)prCliStaRec == (UINT_32)prLinkEntry) {
843 LINK_REMOVE_KNOWN_ENTRY(prStaRecOfClientList, &prCliStaRec->rLinkEntry);
845 //p2pFuncDisconnect(prAdapter, prCliStaRec, fgSendDisassoc, u2ReasonCode);
852 case OP_MODE_INFRASTRUCTURE:
853 ASSERT(prCliStaRec == prP2pBssInfo->prStaRecOfAP);
854 if (prCliStaRec != prP2pBssInfo->prStaRecOfAP) {
858 //p2pFuncDisconnect(prAdapter, prCliStaRec, fgSendDisassoc, u2ReasonCode);
859 prP2pBssInfo->prStaRecOfAP = NULL;
868 p2pFuncDisconnect(prAdapter, prCliStaRec, fgSendDisassoc, u2ReasonCode);
869 //20120830 moved into p2pFuncDisconnect().
870 //cnmStaRecFree(prAdapter, prCliStaRec, TRUE);
874 rWlanStatus = WLAN_STATUS_SUCCESS;
878 } /* p2pFuncDisassoc */
880 /*----------------------------------------------------------------------------*/
882 * @brief This function is called to dissolve from group or one group. (Would not change P2P FSM.)
883 * 1. GC: Disconnect from AP. (Send Deauth)
884 * 2. GO: Disconnect all STA
886 * @param[in] prAdapter Pointer to the adapter structure.
890 /*----------------------------------------------------------------------------*/
893 IN P_ADAPTER_T prAdapter,
894 IN P_BSS_INFO_T prP2pBssInfo,
895 IN BOOLEAN fgSendDeauth,
896 IN UINT_16 u2ReasonCode
899 DEBUGFUNC("p2pFuncDissolve()");
903 ASSERT_BREAK((prAdapter != NULL) && (prP2pBssInfo != NULL));
905 switch (prP2pBssInfo->eCurrentOPMode) {
906 case OP_MODE_INFRASTRUCTURE:
907 /* Reset station record status. */
908 if (prP2pBssInfo->prStaRecOfAP) {
909 kalP2PGCIndicateConnectionStatus(prAdapter->prGlueInfo,
913 REASON_CODE_DEAUTH_LEAVING_BSS);
915 // 2012/02/14 frog: After formation before join group, prStaRecOfAP is NULL.
916 p2pFuncDisconnect(prAdapter,
917 prP2pBssInfo->prStaRecOfAP,
922 /* Fix possible KE when RX Beacon & call nicPmIndicateBssConnected(). hit prStaRecOfAP == NULL. */
923 p2pChangeMediaState(prAdapter, PARAM_MEDIA_STATE_DISCONNECTED);
925 prP2pBssInfo->prStaRecOfAP = NULL;
928 case OP_MODE_ACCESS_POINT:
929 /* Under AP mode, we would net send deauthentication frame to each STA.
930 * We only stop the Beacon & let all stations timeout.
933 P_LINK_T prStaRecOfClientList = (P_LINK_T)NULL;
936 authSendDeauthFrame(prAdapter,
940 (PFN_TX_DONE_HANDLER)NULL);
942 prStaRecOfClientList = &prP2pBssInfo->rStaRecOfClientList;
944 while (!LINK_IS_EMPTY(prStaRecOfClientList)) {
945 P_STA_RECORD_T prCurrStaRec;
947 LINK_REMOVE_HEAD(prStaRecOfClientList, prCurrStaRec, P_STA_RECORD_T);
949 /* Indicate to Host. */
950 //kalP2PGOStationUpdate(prAdapter->prGlueInfo, prCurrStaRec, FALSE);
952 p2pFuncDisconnect(prAdapter, prCurrStaRec, TRUE, u2ReasonCode);
960 return; // 20110420 -- alreay in Device Mode.
963 /* Make the deauth frame send to FW ASAP. */
964 wlanAcquirePowerControl(prAdapter);
965 wlanProcessCommandQueue(prAdapter, &prAdapter->prGlueInfo->rCmdQueue);
966 wlanReleasePowerControl(prAdapter);
970 /* Change Connection Status. */
971 p2pChangeMediaState(prAdapter, PARAM_MEDIA_STATE_DISCONNECTED);
976 } /* p2pFuncDissolve */
979 /*----------------------------------------------------------------------------*/
981 * @brief This function is called to dissolve from group or one group. (Would not change P2P FSM.)
982 * 1. GC: Disconnect from AP. (Send Deauth)
983 * 2. GO: Disconnect all STA
985 * @param[in] prAdapter Pointer to the adapter structure.
989 /*----------------------------------------------------------------------------*/
992 IN P_ADAPTER_T prAdapter,
993 IN P_STA_RECORD_T prStaRec,
994 IN BOOLEAN fgSendDeauth,
995 IN UINT_16 u2ReasonCode
998 P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T)NULL;
999 ENUM_PARAM_MEDIA_STATE_T eOriMediaStatus;
1001 DBGLOG(P2P, TRACE, ("p2pFuncDisconnect()"));
1004 ASSERT_BREAK((prAdapter != NULL) && (prStaRec != NULL));
1006 prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
1007 eOriMediaStatus = prP2pBssInfo->eConnectionState;
1009 /* Indicate disconnect. */
1011 // kalP2PGOStationUpdate
1012 // kalP2PGCIndicateConnectionStatus
1013 //p2pIndicationOfMediaStateToHost(prAdapter, PARAM_MEDIA_STATE_DISCONNECTED, prStaRec->aucMacAddr);
1014 if (prP2pBssInfo->eCurrentOPMode == OP_MODE_ACCESS_POINT) {
1015 kalP2PGOStationUpdate(prAdapter->prGlueInfo, prStaRec, FALSE);
1020 authSendDeauthFrame(prAdapter,
1024 (PFN_TX_DONE_HANDLER)p2pFsmRunEventDeauthTxDone);
1025 /* Change station state. */
1026 cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
1028 /* Reset Station Record Status. */
1029 p2pFuncResetStaRecStatus(prAdapter, prStaRec);
1034 /* Change station state. */
1035 cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
1037 /* Reset Station Record Status. */
1038 p2pFuncResetStaRecStatus(prAdapter, prStaRec);
1040 cnmStaRecFree(prAdapter, prStaRec, TRUE);
1042 if ((prP2pBssInfo->eCurrentOPMode != OP_MODE_ACCESS_POINT) ||
1043 (prP2pBssInfo->rStaRecOfClientList.u4NumElem == 0)) {
1044 DBGLOG(P2P, TRACE, ("No More Client, Media Status DISCONNECTED\n"));
1045 p2pChangeMediaState(prAdapter, PARAM_MEDIA_STATE_DISCONNECTED);
1048 if (eOriMediaStatus != prP2pBssInfo->eConnectionState) {
1049 /* Update Disconnected state to FW. */
1050 nicUpdateBss(prAdapter, NETWORK_TYPE_P2P_INDEX);
1055 if (prP2pBssInfo->eCurrentOPMode != OP_MODE_ACCESS_POINT) {
1056 /* GO: It would stop Beacon TX. GC: Stop all BSS related PS function. */
1057 nicPmIndicateBssAbort(prAdapter, NETWORK_TYPE_P2P_INDEX);
1059 /* Reset RLM related field of BSSINFO. */
1060 rlmBssAborted(prAdapter, prP2pBssInfo);
1067 } /* p2pFuncDisconnect */
1075 p2pFuncTxMgmtFrame (
1076 IN P_ADAPTER_T prAdapter,
1077 IN P_P2P_MGMT_TX_REQ_INFO_T prMgmtTxReqInfo,
1078 IN P_MSDU_INFO_T prMgmtTxMsdu,
1082 WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
1083 P_MSDU_INFO_T prTxMsduInfo = (P_MSDU_INFO_T)NULL;
1084 P_WLAN_MAC_HEADER_T prWlanHdr = (P_WLAN_MAC_HEADER_T)NULL;
1085 P_STA_RECORD_T prStaRec = (P_STA_RECORD_T)NULL;
1088 ASSERT_BREAK((prAdapter != NULL) && (prMgmtTxReqInfo != NULL));
1090 if (prMgmtTxReqInfo->fgIsMgmtTxRequested) {
1092 // 1. prMgmtTxReqInfo->prMgmtTxMsdu != NULL
1093 /* Packet on driver, not done yet, drop it. */
1094 if ((prTxMsduInfo = prMgmtTxReqInfo->prMgmtTxMsdu) != NULL) {
1096 kalP2PIndicateMgmtTxStatus(prAdapter->prGlueInfo,
1097 prMgmtTxReqInfo->u8Cookie,
1099 prTxMsduInfo->prPacket,
1100 (UINT_32)prTxMsduInfo->u2FrameLength);
1102 // Leave it to TX Done handler.
1103 //cnmMgtPktFree(prAdapter, prTxMsduInfo);
1104 prMgmtTxReqInfo->prMgmtTxMsdu = NULL;
1107 // 2. prMgmtTxReqInfo->prMgmtTxMsdu == NULL
1108 /* Packet transmitted, wait tx done. (cookie issue) */
1109 // 20120105 frog - use another u8cookie to store this value.
1113 ASSERT(prMgmtTxReqInfo->prMgmtTxMsdu == NULL);
1117 prWlanHdr = (P_WLAN_MAC_HEADER_T)((UINT_32)prMgmtTxMsdu->prPacket + MAC_TX_RESERVED_FIELD);
1118 prStaRec = cnmGetStaRecByAddress(prAdapter, NETWORK_TYPE_P2P_INDEX, prWlanHdr->aucAddr1);
1119 prMgmtTxMsdu->ucNetworkType = (UINT_8)NETWORK_TYPE_P2P_INDEX;
1121 switch (prWlanHdr->u2FrameCtrl & MASK_FRAME_TYPE) {
1122 case MAC_FRAME_PROBE_RSP:
1123 DBGLOG(P2P, TRACE, ("p2pFuncTxMgmtFrame: TX MAC_FRAME_PROBE_RSP\n"));
1124 prMgmtTxMsdu = p2pFuncProcessP2pProbeRsp(prAdapter, prMgmtTxMsdu);
1131 prMgmtTxReqInfo->u8Cookie = u8Cookie;
1132 prMgmtTxReqInfo->prMgmtTxMsdu = prMgmtTxMsdu;
1133 prMgmtTxReqInfo->fgIsMgmtTxRequested = TRUE;
1135 prMgmtTxMsdu->eSrc = TX_PACKET_MGMT;
1136 prMgmtTxMsdu->ucPacketType = HIF_TX_PACKET_TYPE_MGMT;
1137 prMgmtTxMsdu->ucStaRecIndex = (prStaRec != NULL)?(prStaRec->ucIndex):(0xFF);
1138 if (prStaRec != NULL) {
1139 DBGLOG(P2P, TRACE, ("Mgmt with station record: "MACSTR" .\n", MAC2STR(prStaRec->aucMacAddr)));
1142 prMgmtTxMsdu->ucMacHeaderLength = WLAN_MAC_MGMT_HEADER_LEN; // TODO: undcertain.
1143 prMgmtTxMsdu->fgIs802_1x = FALSE;
1144 prMgmtTxMsdu->fgIs802_11 = TRUE;
1145 prMgmtTxMsdu->ucTxSeqNum = nicIncreaseTxSeqNum(prAdapter);
1146 prMgmtTxMsdu->pfTxDoneHandler = p2pFsmRunEventMgmtFrameTxDone;
1147 prMgmtTxMsdu->fgIsBasicRate = TRUE;
1148 DBGLOG(P2P, TRACE, ("Mgmt seq NO. %d .\n", prMgmtTxMsdu->ucTxSeqNum));
1150 nicTxEnqueueMsdu(prAdapter, prMgmtTxMsdu);
1155 } /* p2pFuncTxMgmtFrame */
1161 IN P_ADAPTER_T prAdapter,
1162 IN P_RF_CHANNEL_INFO_T prRfChannelInfo
1165 P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T)NULL;
1168 ASSERT_BREAK((prAdapter != NULL) && (prRfChannelInfo != NULL));
1170 prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
1172 prP2pConnSettings->ucOperatingChnl = prRfChannelInfo->ucChannelNum;
1173 prP2pConnSettings->eBand = prRfChannelInfo->eBand;
1180 /* p2pFuncSetChannel */
1184 /*----------------------------------------------------------------------------*/
1186 * @brief Retry JOIN for AUTH_MODE_AUTO_SWITCH
1188 * @param[in] prStaRec Pointer to the STA_RECORD_T
1190 * @retval TRUE We will retry JOIN
1191 * @retval FALSE We will not retry JOIN
1193 /*----------------------------------------------------------------------------*/
1196 IN P_ADAPTER_T prAdapter,
1197 IN P_STA_RECORD_T prStaRec,
1198 IN P_P2P_JOIN_INFO_T prJoinInfo
1201 P_MSG_JOIN_REQ_T prJoinReqMsg = (P_MSG_JOIN_REQ_T)NULL;
1202 BOOLEAN fgRetValue = FALSE;
1205 ASSERT_BREAK((prAdapter != NULL) &&
1206 (prStaRec != NULL) &&
1207 (prJoinInfo != NULL));
1209 /* Retry other AuthType if possible */
1210 if (!prJoinInfo->ucAvailableAuthTypes) {
1214 if (prJoinInfo->ucAvailableAuthTypes &
1215 (UINT_8)AUTH_TYPE_SHARED_KEY) {
1217 DBGLOG(P2P, INFO, ("RETRY JOIN INIT: Retry Authentication with AuthType == SHARED_KEY.\n"));
1219 prJoinInfo->ucAvailableAuthTypes &=
1220 ~(UINT_8)AUTH_TYPE_SHARED_KEY;
1222 prStaRec->ucAuthAlgNum = (UINT_8)AUTH_ALGORITHM_NUM_SHARED_KEY;
1225 DBGLOG(P2P, ERROR, ("RETRY JOIN INIT: Retry Authentication with Unexpected AuthType.\n"));
1230 prJoinInfo->ucAvailableAuthTypes = 0; /* No more available Auth Types */
1232 /* Trigger SAA to start JOIN process. */
1233 prJoinReqMsg = (P_MSG_JOIN_REQ_T)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_JOIN_REQ_T));
1234 if (!prJoinReqMsg) {
1235 ASSERT(0); // Can't trigger SAA FSM
1239 prJoinReqMsg->rMsgHdr.eMsgId = MID_P2P_SAA_FSM_START;
1240 prJoinReqMsg->ucSeqNum = ++prJoinInfo->ucSeqNumOfReqMsg;
1241 prJoinReqMsg->prStaRec = prStaRec;
1243 mboxSendMsg(prAdapter,
1245 (P_MSG_HDR_T) prJoinReqMsg,
1246 MSG_SEND_METHOD_BUF);
1256 }/* end of p2pFuncRetryJOIN() */
1262 /*----------------------------------------------------------------------------*/
1264 * @brief This function will update the contain of BSS_INFO_T for AIS network once
1265 * the association was completed.
1267 * @param[in] prStaRec Pointer to the STA_RECORD_T
1268 * @param[in] prAssocRspSwRfb Pointer to SW RFB of ASSOC RESP FRAME.
1272 /*----------------------------------------------------------------------------*/
1274 p2pFuncUpdateBssInfoForJOIN (
1275 IN P_ADAPTER_T prAdapter,
1276 IN P_BSS_DESC_T prBssDesc,
1277 IN P_STA_RECORD_T prStaRec,
1278 IN P_SW_RFB_T prAssocRspSwRfb
1281 P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T)NULL;
1282 P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T)NULL;
1283 P_WLAN_ASSOC_RSP_FRAME_T prAssocRspFrame = (P_WLAN_ASSOC_RSP_FRAME_T)NULL;
1287 DEBUGFUNC("p2pUpdateBssInfoForJOIN()");
1291 ASSERT(prAssocRspSwRfb);
1293 prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
1294 prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
1295 prAssocRspFrame = (P_WLAN_ASSOC_RSP_FRAME_T) prAssocRspSwRfb->pvHeader;
1297 DBGLOG(P2P, INFO, ("Update P2P_BSS_INFO_T and apply settings to MAC\n"));
1299 //3 <1> Update BSS_INFO_T from AIS_FSM_INFO_T or User Settings
1300 //4 <1.1> Setup Operation Mode
1301 prP2pBssInfo->eCurrentOPMode = OP_MODE_INFRASTRUCTURE;
1303 //4 <1.2> Setup SSID
1304 COPY_SSID(prP2pBssInfo->aucSSID,
1305 prP2pBssInfo->ucSSIDLen,
1306 prP2pConnSettings->aucSSID,
1307 prP2pConnSettings->ucSSIDLen);
1309 if (prBssDesc == NULL) {
1310 /* Target BSS NULL. */
1311 DBGLOG(P2P, TRACE,("Target BSS NULL\n"));
1316 if (UNEQUAL_MAC_ADDR(prBssDesc->aucBSSID, prAssocRspFrame->aucBSSID)) {
1320 //4 <1.3> Setup Channel, Band
1321 prP2pBssInfo->ucPrimaryChannel = prBssDesc->ucChannelNum;
1322 prP2pBssInfo->eBand = prBssDesc->eBand;
1325 //3 <2> Update BSS_INFO_T from STA_RECORD_T
1326 //4 <2.1> Save current AP's STA_RECORD_T and current AID
1327 prP2pBssInfo->prStaRecOfAP = prStaRec;
1328 prP2pBssInfo->u2AssocId = prStaRec->u2AssocId;
1330 //4 <2.2> Setup Capability
1331 prP2pBssInfo->u2CapInfo = prStaRec->u2CapInfo; /* Use AP's Cap Info as BSS Cap Info */
1333 if (prP2pBssInfo->u2CapInfo & CAP_INFO_SHORT_PREAMBLE) {
1334 prP2pBssInfo->fgIsShortPreambleAllowed = TRUE;
1337 prP2pBssInfo->fgIsShortPreambleAllowed = FALSE;
1340 //4 <2.3> Setup PHY Attributes and Basic Rate Set/Operational Rate Set
1341 prP2pBssInfo->ucPhyTypeSet = prStaRec->ucDesiredPhyTypeSet;
1343 prP2pBssInfo->ucNonHTBasicPhyType = prStaRec->ucNonHTBasicPhyType;
1345 prP2pBssInfo->u2OperationalRateSet = prStaRec->u2OperationalRateSet;
1346 prP2pBssInfo->u2BSSBasicRateSet = prStaRec->u2BSSBasicRateSet;
1349 //3 <3> Update BSS_INFO_T from SW_RFB_T (Association Resp Frame)
1350 //4 <3.1> Setup BSSID
1351 COPY_MAC_ADDR(prP2pBssInfo->aucBSSID, prAssocRspFrame->aucBSSID);
1354 u2IELength = (UINT_16) ((prAssocRspSwRfb->u2PacketLen - prAssocRspSwRfb->u2HeaderLen) -
1355 (OFFSET_OF(WLAN_ASSOC_RSP_FRAME_T, aucInfoElem[0]) - WLAN_MAC_MGMT_HEADER_LEN));
1356 pucIE = prAssocRspFrame->aucInfoElem;
1359 //4 <3.2> Parse WMM and setup QBSS flag
1360 /* Parse WMM related IEs and configure HW CRs accordingly */
1361 mqmProcessAssocRsp(prAdapter, prAssocRspSwRfb, pucIE, u2IELength);
1363 prP2pBssInfo->fgIsQBSS = prStaRec->fgIsQoS;
1365 //3 <4> Update BSS_INFO_T from BSS_DESC_T
1368 prBssDesc->fgIsConnecting = FALSE;
1369 prBssDesc->fgIsConnected = TRUE;
1371 //4 <4.1> Setup MIB for current BSS
1372 prP2pBssInfo->u2BeaconInterval = prBssDesc->u2BeaconInterval;
1373 /* NOTE: Defer ucDTIMPeriod updating to when beacon is received after connection */
1374 prP2pBssInfo->ucDTIMPeriod = 0;
1375 prP2pBssInfo->u2ATIMWindow = 0;
1377 prP2pBssInfo->ucBeaconTimeoutCount = AIS_BEACON_TIMEOUT_COUNT_INFRA;
1379 //4 <4.2> Update HT information and set channel
1380 /* Record HT related parameters in rStaRec and rBssInfo
1381 * Note: it shall be called before nicUpdateBss()
1383 rlmProcessAssocRsp(prAdapter, prAssocRspSwRfb, pucIE, u2IELength);
1385 //4 <4.3> Sync with firmware for BSS-INFO
1386 nicUpdateBss(prAdapter, NETWORK_TYPE_P2P_INDEX);
1388 //4 <4.4> *DEFER OPERATION* nicPmIndicateBssConnected() will be invoked
1389 //inside scanProcessBeaconAndProbeResp() after 1st beacon is received
1392 } /* end of p2pUpdateBssInfoForJOIN() */
1396 /*----------------------------------------------------------------------------*/
1398 * @brief This function will validate the Rx Auth Frame and then return
1399 * the status code to AAA to indicate if need to perform following actions
1400 * when the specified conditions were matched.
1402 * @param[in] prAdapter Pointer to the Adapter structure.
1403 * @param[in] prSwRfb Pointer to SW RFB data structure.
1404 * @param[in] pprStaRec Pointer to pointer of STA_RECORD_T structure.
1405 * @param[out] pu2StatusCode The Status Code of Validation Result
1407 * @retval TRUE Reply the Auth
1408 * @retval FALSE Don't reply the Auth
1410 /*----------------------------------------------------------------------------*/
1412 p2pFuncValidateAuth (
1413 IN P_ADAPTER_T prAdapter,
1414 IN P_SW_RFB_T prSwRfb,
1415 IN PP_STA_RECORD_T pprStaRec,
1416 OUT PUINT_16 pu2StatusCode
1419 BOOLEAN fgReplyAuth = TRUE;
1420 P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T)NULL;
1421 P_STA_RECORD_T prStaRec = (P_STA_RECORD_T)NULL;
1422 P_WLAN_AUTH_FRAME_T prAuthFrame = (P_WLAN_AUTH_FRAME_T)NULL;
1424 DBGLOG(P2P, TRACE, ("p2pValidate Authentication Frame\n"))
1427 ASSERT_BREAK((prAdapter != NULL) &&
1428 (prSwRfb != NULL) &&
1429 (pprStaRec != NULL) &&
1430 (pu2StatusCode != NULL));
1433 *pu2StatusCode = STATUS_CODE_REQ_DECLINED;
1435 prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
1436 prAuthFrame = (P_WLAN_AUTH_FRAME_T)prSwRfb->pvHeader;
1439 if (prP2pBssInfo->eCurrentOPMode != OP_MODE_ACCESS_POINT) {
1440 /* We are not under AP Mode yet. */
1441 fgReplyAuth = FALSE;
1442 DBGLOG(P2P, WARN, ("Current OP mode is not under AP mode. (%d)\n", prP2pBssInfo->eCurrentOPMode));
1446 prStaRec = cnmGetStaRecByAddress(prAdapter,
1447 (UINT_8) NETWORK_TYPE_P2P_INDEX,
1448 prAuthFrame->aucSrcAddr);
1451 prStaRec = cnmStaRecAlloc(prAdapter,
1452 (UINT_8) NETWORK_TYPE_P2P_INDEX);
1454 /* TODO(Kevin): Error handling of allocation of STA_RECORD_T for
1455 * exhausted case and do removal of unused STA_RECORD_T.
1457 /* Sent a message event to clean un-used STA_RECORD_T. */
1460 COPY_MAC_ADDR(prStaRec->aucMacAddr, prAuthFrame->aucSrcAddr);
1462 prSwRfb->ucStaRecIdx = prStaRec->ucIndex;
1464 prStaRec->u2BSSBasicRateSet = prP2pBssInfo->u2BSSBasicRateSet;
1466 prStaRec->u2DesiredNonHTRateSet = RATE_SET_ERP_P2P;
1468 prStaRec->u2OperationalRateSet = RATE_SET_ERP_P2P;
1469 prStaRec->ucPhyTypeSet = PHY_TYPE_SET_802_11GN;
1470 prStaRec->eStaType = STA_TYPE_P2P_GC;
1472 /* NOTE(Kevin): Better to change state here, not at TX Done */
1473 cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
1476 prSwRfb->ucStaRecIdx = prStaRec->ucIndex;
1478 if ((prStaRec->ucStaState > STA_STATE_1) && (IS_STA_IN_P2P(prStaRec))) {
1480 cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
1482 p2pFuncResetStaRecStatus(prAdapter, prStaRec);
1484 bssRemoveStaRecFromClientList(prAdapter, prP2pBssInfo, prStaRec);
1489 if (prP2pBssInfo->rStaRecOfClientList.u4NumElem > P2P_MAXIMUM_CLIENT_COUNT ||
1490 kalP2PMaxClients(prAdapter->prGlueInfo, prP2pBssInfo->rStaRecOfClientList.u4NumElem)) {
1491 /* GROUP limit full. */
1493 DBGLOG(P2P, WARN, ("Group Limit Full. (%d)\n", (INT_16)prP2pBssInfo->rStaRecOfClientList.u4NumElem));
1495 bssRemoveStaRecFromClientList(prAdapter, prP2pBssInfo, prStaRec);
1497 cnmStaRecFree(prAdapter, prStaRec, FALSE);
1501 /* Hotspot Blacklist */
1502 if(prAuthFrame->aucSrcAddr) {
1503 if(kalP2PCmpBlackList(prAdapter->prGlueInfo, prAuthFrame->aucSrcAddr)) {
1504 fgReplyAuth = FALSE;
1510 //prStaRec->eStaType = STA_TYPE_INFRA_CLIENT;
1511 prStaRec->eStaType = STA_TYPE_P2P_GC;
1513 prStaRec->ucNetTypeIndex = NETWORK_TYPE_P2P_INDEX;
1515 /* Update Station Record - Status/Reason Code */
1516 prStaRec->u2StatusCode = STATUS_CODE_SUCCESSFUL;
1518 prStaRec->ucJoinFailureCount = 0;
1520 *pprStaRec = prStaRec;
1522 *pu2StatusCode = STATUS_CODE_SUCCESSFUL;
1529 } /* p2pFuncValidateAuth */
1535 p2pFuncResetStaRecStatus (
1536 IN P_ADAPTER_T prAdapter,
1537 IN P_STA_RECORD_T prStaRec
1541 if ((prAdapter == NULL) || (prStaRec == NULL)) {
1547 prStaRec->u2StatusCode = STATUS_CODE_SUCCESSFUL;
1548 prStaRec->u2ReasonCode = REASON_CODE_RESERVED;
1549 prStaRec->ucJoinFailureCount = 0;
1550 prStaRec->fgTransmitKeyExist = FALSE;
1552 prStaRec->fgSetPwrMgtBit = FALSE;
1557 } /* p2pFuncResetStaRecStatus */
1561 /*----------------------------------------------------------------------------*/
1563 * @brief The function is used to initialize the value of the connection settings for
1570 /*----------------------------------------------------------------------------*/
1572 p2pFuncInitConnectionSettings (
1573 IN P_ADAPTER_T prAdapter,
1574 IN P_P2P_CONNECTION_SETTINGS_T prP2PConnSettings
1577 P_DEVICE_TYPE_T prDevType;
1578 UINT_8 aucDefaultDevName[] = P2P_DEFAULT_DEV_NAME;
1579 UINT_8 aucWfaOui[] = VENDOR_OUI_WFA;
1581 ASSERT(prP2PConnSettings);
1583 /* Setup Default Device Name */
1584 prP2PConnSettings->ucDevNameLen = P2P_DEFAULT_DEV_NAME_LEN;
1585 kalMemCopy(prP2PConnSettings->aucDevName, aucDefaultDevName, sizeof(aucDefaultDevName));
1587 /* Setup Primary Device Type (Big-Endian) */
1588 prDevType = &prP2PConnSettings->rPrimaryDevTypeBE;
1590 prDevType->u2CategoryId = HTONS(P2P_DEFAULT_PRIMARY_CATEGORY_ID);
1591 prDevType->u2SubCategoryId = HTONS(P2P_DEFAULT_PRIMARY_SUB_CATEGORY_ID);
1593 prDevType->aucOui[0] = aucWfaOui[0];
1594 prDevType->aucOui[1] = aucWfaOui[1];
1595 prDevType->aucOui[2] = aucWfaOui[2];
1596 prDevType->aucOui[3] = VENDOR_OUI_TYPE_WPS;
1598 /* Setup Secondary Device Type */
1599 prP2PConnSettings->ucSecondaryDevTypeCount = 0;
1601 /* Setup Default Config Method */
1602 prP2PConnSettings->eConfigMethodSelType = ENUM_CONFIG_METHOD_SEL_AUTO;
1603 prP2PConnSettings->u2ConfigMethodsSupport = P2P_DEFAULT_CONFIG_METHOD;
1604 prP2PConnSettings->u2TargetConfigMethod = 0;
1605 prP2PConnSettings->u2LocalConfigMethod = 0;
1606 prP2PConnSettings->fgIsPasswordIDRdy = FALSE;
1608 /* For Device Capability */
1609 prP2PConnSettings->fgSupportServiceDiscovery = FALSE;
1610 prP2PConnSettings->fgSupportClientDiscoverability = TRUE;
1611 prP2PConnSettings->fgSupportConcurrentOperation = TRUE;
1612 prP2PConnSettings->fgSupportInfraManaged = FALSE;
1613 prP2PConnSettings->fgSupportInvitationProcedure = FALSE;
1615 /* For Group Capability */
1616 #if CFG_SUPPORT_PERSISTENT_GROUP
1617 prP2PConnSettings->fgSupportPersistentP2PGroup = TRUE;
1619 prP2PConnSettings->fgSupportPersistentP2PGroup = FALSE;
1621 prP2PConnSettings->fgSupportIntraBSSDistribution = TRUE;
1622 prP2PConnSettings->fgSupportCrossConnection = TRUE;
1623 prP2PConnSettings->fgSupportPersistentReconnect = FALSE;
1625 prP2PConnSettings->fgSupportOppPS = FALSE;
1626 prP2PConnSettings->u2CTWindow = P2P_CTWINDOW_DEFAULT;
1628 /* For Connection Settings. */
1629 prP2PConnSettings->eAuthMode = AUTH_MODE_OPEN;
1631 prP2PConnSettings->prTargetP2pDesc = NULL;
1632 prP2PConnSettings->ucSSIDLen = 0;
1635 prP2PConnSettings->fgIsScanReqIssued = FALSE;
1636 prP2PConnSettings->fgIsServiceDiscoverIssued = FALSE;
1637 prP2PConnSettings->fgP2pGroupLimit = FALSE;
1638 prP2PConnSettings->ucOperatingChnl = 0;
1639 prP2PConnSettings->ucListenChnl = 0;
1640 prP2PConnSettings->ucTieBreaker = (UINT_8)(kalRandomNumber() & 0x1);
1642 prP2PConnSettings->eFormationPolicy = ENUM_P2P_FORMATION_POLICY_AUTO;
1645 } /* p2pFuncInitConnectionSettings */
1651 /*----------------------------------------------------------------------------*/
1653 * @brief This function will validate the Rx Assoc Req Frame and then return
1654 * the status code to AAA to indicate if need to perform following actions
1655 * when the specified conditions were matched.
1657 * @param[in] prAdapter Pointer to the Adapter structure.
1658 * @param[in] prSwRfb Pointer to SW RFB data structure.
1659 * @param[out] pu2StatusCode The Status Code of Validation Result
1661 * @retval TRUE Reply the Assoc Resp
1662 * @retval FALSE Don't reply the Assoc Resp
1664 /*----------------------------------------------------------------------------*/
1666 p2pFuncValidateAssocReq (
1667 IN P_ADAPTER_T prAdapter,
1668 IN P_SW_RFB_T prSwRfb,
1669 OUT PUINT_16 pu2StatusCode
1672 BOOLEAN fgReplyAssocResp = TRUE;
1673 P_WLAN_ASSOC_REQ_FRAME_T prAssocReqFrame = (P_WLAN_ASSOC_REQ_FRAME_T)NULL;
1674 P_STA_RECORD_T prStaRec = (P_STA_RECORD_T)NULL;
1675 P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T)NULL;
1677 P_WFD_CFG_SETTINGS_T prWfdCfgSettings = (P_WFD_CFG_SETTINGS_T)NULL;
1678 P_WFD_ATTRIBUTE_T prWfdAttribute = (P_WFD_ATTRIBUTE_T)NULL;
1679 BOOLEAN fgNeedFree = FALSE;
1683 /* TODO(Kevin): Call P2P functions to check ..
1684 2. Check we can accept connection from thsi peer
1685 a. If we are in PROVISION state, only accept the peer we do the GO formation previously.
1686 b. If we are in OPERATION state, only accept the other peer when P2P_GROUP_LIMIT is 0.
1687 3. Check Black List here.
1691 ASSERT_BREAK((prAdapter != NULL) &&
1692 (prSwRfb != NULL) &&
1693 (pu2StatusCode != NULL));
1695 *pu2StatusCode = STATUS_CODE_REQ_DECLINED;
1696 prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
1697 prAssocReqFrame = (P_WLAN_ASSOC_REQ_FRAME_T)prSwRfb->pvHeader;
1699 prStaRec = cnmGetStaRecByIndex(prAdapter, prSwRfb->ucStaRecIdx);
1701 if (prStaRec == NULL) {
1702 /* Station record should be ready while RX AUTH frame. */
1703 fgReplyAssocResp = FALSE;
1708 prStaRec->ucRCPI = prSwRfb->prHifRxHdr->ucRcpi;
1711 prStaRec->u2DesiredNonHTRateSet &= prP2pBssInfo->u2OperationalRateSet;
1712 prStaRec->ucDesiredPhyTypeSet = prStaRec->ucPhyTypeSet & prP2pBssInfo->ucPhyTypeSet;
1714 if (prStaRec->ucDesiredPhyTypeSet == 0) {
1715 /* The station only support 11B rate. */
1716 *pu2StatusCode = STATUS_CODE_ASSOC_DENIED_RATE_NOT_SUPPORTED;
1720 #if CFG_SUPPORT_WFD && 1
1721 //LOG_FUNC("Skip check WFD IE becasue some API is not ready\n"); /* Eddie */
1722 if (!prAdapter->rWifiVar.prP2pFsmInfo) {
1723 fgReplyAssocResp = FALSE;
1728 prWfdCfgSettings = &prAdapter->rWifiVar.prP2pFsmInfo->rWfdConfigureSettings;
1729 DBGLOG(P2P, INFO,("Current WfdCfgSettings wfd_en %u wfd_info 0x%x wfd_policy 0x%x wfd_flag 0x%x\n",
1730 prWfdCfgSettings->ucWfdEnable, prWfdCfgSettings->u2WfdDevInfo,
1731 prWfdCfgSettings->u4WfdPolicy, prWfdCfgSettings->u4WfdFlag)); /* Eddie */
1732 if (prWfdCfgSettings->ucWfdEnable) {
1733 if (prWfdCfgSettings->u4WfdPolicy & BIT(6)) {
1739 //UINT_16 u2AttriListLen = 0;
1740 UINT_16 u2WfdDevInfo = 0;
1741 P_WFD_DEVICE_INFORMATION_IE_T prAttriWfdDevInfo = (P_WFD_DEVICE_INFORMATION_IE_T)NULL;
1743 //fgNeedFree = p2pFuncGetAttriList(prAdapter,
1744 // VENDOR_OUI_TYPE_WFD,
1745 // (PUINT_8)prAssocReqFrame->aucInfoElem,
1746 // (prSwRfb->u2PacketLen - OFFSET_OF(WLAN_ASSOC_REQ_FRAME_T, aucInfoElem)),
1747 // (PPUINT_8)&prWfdAttribute,
1748 // &u2AttriListLen);
1750 prAttriWfdDevInfo = (P_WFD_DEVICE_INFORMATION_IE_T)
1751 p2pFuncGetSpecAttri(prAdapter,
1752 VENDOR_OUI_TYPE_WFD,
1753 (PUINT_8)prAssocReqFrame->aucInfoElem,
1754 (prSwRfb->u2PacketLen - OFFSET_OF(WLAN_ASSOC_REQ_FRAME_T, aucInfoElem)),
1755 WFD_ATTRI_ID_DEV_INFO);
1757 if ((prWfdCfgSettings->u4WfdPolicy & BIT(5)) && (prAttriWfdDevInfo != NULL)) {
1758 /* Rejected with WFD IE. */
1762 if ((prWfdCfgSettings->u4WfdPolicy & BIT(0)) && (prAttriWfdDevInfo == NULL)) {
1763 /* Rejected without WFD IE. */
1767 if (prAttriWfdDevInfo != NULL) {
1769 //prAttriWfdDevInfo = (P_WFD_DEVICE_INFORMATION_IE_T)p2pFuncGetSpecAttri(prAdapter,
1770 // VENDOR_OUI_TYPE_WFD,
1771 // (PUINT_8)prWfdAttribute,
1773 // WFD_ATTRI_ID_DEV_INFO);
1774 //if (prAttriWfdDevInfo == NULL) {
1775 // /* No such attribute. */
1779 WLAN_GET_FIELD_BE16(&prAttriWfdDevInfo->u2WfdDevInfo, &u2WfdDevInfo);
1780 DBGLOG(P2P, INFO,("RX Assoc Req WFD Info:0x%x.\n", u2WfdDevInfo));
1782 if ((prWfdCfgSettings->u4WfdPolicy & BIT(1)) && ((u2WfdDevInfo & 0x3) == 0x0)) {
1783 /* Rejected because of SOURCE. */
1787 if ((prWfdCfgSettings->u4WfdPolicy & BIT(2)) && ((u2WfdDevInfo & 0x3) == 0x1)) {
1788 /* Rejected because of Primary Sink. */
1792 if ((prWfdCfgSettings->u4WfdPolicy & BIT(3)) && ((u2WfdDevInfo & 0x3) == 0x2)) {
1793 /* Rejected because of Secondary Sink. */
1797 if ((prWfdCfgSettings->u4WfdPolicy & BIT(4)) && ((u2WfdDevInfo & 0x3) == 0x3)) {
1798 /* Rejected because of Source & Primary Sink. */
1804 if(prWfdCfgSettings->u4WfdFlag & WFD_FLAGS_DEV_INFO_VALID) {
1806 if((prWfdCfgSettings->u2WfdDevInfo & BITS(0,1)) == 0x3) {
1807 //P_MSG_WFD_CONFIG_SETTINGS_CHANGED_T prMsgWfdCfgUpdate = (P_MSG_WFD_CONFIG_SETTINGS_CHANGED_T)NULL;
1808 UINT_16 u2DevInfo = prWfdCfgSettings->u2WfdDevInfo;
1810 /* We may change role here if we are dual role */
1812 if((u2WfdDevInfo & BITS(0,1)) == 0x00 /* Peer is Source*/) {
1813 DBGLOG(P2P, INFO,("WFD: Switch role to primary sink\n"));
1815 prWfdCfgSettings->u2WfdDevInfo &= ~BITS(0,1);
1816 prWfdCfgSettings->u2WfdDevInfo |= 0x1;
1818 /* event to annonce the role is chanaged to P-Sink */
1821 else if((u2WfdDevInfo & BITS(0,1)) == 0x01 /* Peer is P-Sink */) {
1823 DBGLOG(P2P, INFO,("WFD: Switch role to source\n"));
1824 prWfdCfgSettings->u2WfdDevInfo &= ~BITS(0,1);
1825 /* event to annonce the role is chanaged to Source */
1829 DBGLOG(P2P, INFO,("WFD: Peer role is wrong type(dev 0x%x)\n", (u2DevInfo)));
1830 DBGLOG(P2P, INFO,("WFD: Switch role to source\n"));
1831 prWfdCfgSettings->u2WfdDevInfo &= ~BITS(0,1);
1832 /* event to annonce the role is chanaged to Source */
1835 p2pFsmRunEventWfdSettingUpdate (prAdapter,NULL);
1837 } /* Dual role p2p->wfd_params->WfdDevInfo */
1838 } /* WFD_FLAG_DEV_INFO_VALID */
1844 * Do nothing. Accept the connection request.
1853 *pu2StatusCode = STATUS_CODE_SUCCESSFUL;
1858 if ((prWfdAttribute) && (fgNeedFree)) {
1859 kalMemFree(prWfdAttribute, VIR_MEM_TYPE, WPS_MAXIMUM_ATTRIBUTES_CACHE_SIZE);
1863 return fgReplyAssocResp;
1865 } /* p2pFuncValidateAssocReq */
1870 /*----------------------------------------------------------------------------*/
1872 * @brief This function is used to check the P2P IE
1877 /*----------------------------------------------------------------------------*/
1879 p2pFuncParseCheckForP2PInfoElem (
1880 IN P_ADAPTER_T prAdapter,
1882 OUT PUINT_8 pucOuiType
1885 UINT_8 aucWfaOui[] = VENDOR_OUI_WFA_SPECIFIC;
1886 P_IE_WFA_T prWfaIE = (P_IE_WFA_T)NULL;
1889 ASSERT_BREAK((prAdapter != NULL) && (pucBuf != NULL) && (pucOuiType != NULL));
1891 prWfaIE = (P_IE_WFA_T)pucBuf;
1893 if (IE_LEN(pucBuf) <= ELEM_MIN_LEN_WFA_OUI_TYPE_SUBTYPE) {
1896 else if (prWfaIE->aucOui[0] != aucWfaOui[0] ||
1897 prWfaIE->aucOui[1] != aucWfaOui[1] ||
1898 prWfaIE->aucOui[2] != aucWfaOui[2]) {
1902 *pucOuiType = prWfaIE->ucOuiType;
1908 } /* p2pFuncParseCheckForP2PInfoElem */
1913 /*----------------------------------------------------------------------------*/
1915 * @brief This function will validate the Rx Probe Request Frame and then return
1916 * result to BSS to indicate if need to send the corresponding Probe Response
1917 * Frame if the specified conditions were matched.
1919 * @param[in] prAdapter Pointer to the Adapter structure.
1920 * @param[in] prSwRfb Pointer to SW RFB data structure.
1921 * @param[out] pu4ControlFlags Control flags for replying the Probe Response
1923 * @retval TRUE Reply the Probe Response
1924 * @retval FALSE Don't reply the Probe Response
1926 /*----------------------------------------------------------------------------*/
1928 p2pFuncValidateProbeReq (
1929 IN P_ADAPTER_T prAdapter,
1930 IN P_SW_RFB_T prSwRfb,
1931 OUT PUINT_32 pu4ControlFlags
1934 BOOLEAN fgIsReplyProbeRsp = FALSE;
1935 P_P2P_FSM_INFO_T prP2pFsmInfo = (P_P2P_FSM_INFO_T)NULL;
1937 DEBUGFUNC("p2pFuncValidateProbeReq");
1938 DBGLOG(P2P, TRACE, ("p2pFuncValidateProbeReq\n"));
1942 ASSERT_BREAK((prAdapter != NULL) && (prSwRfb != NULL));
1944 prP2pFsmInfo = prAdapter->rWifiVar.prP2pFsmInfo;
1946 if (prP2pFsmInfo->u4P2pPacketFilter & PARAM_PACKET_FILTER_PROBE_REQ) {
1948 printk("p2pFuncValidateProbeReq\n");
1950 /* Leave the probe response to p2p_supplicant. */
1951 kalP2PIndicateRxMgmtFrame(prAdapter->prGlueInfo, prSwRfb);
1956 return fgIsReplyProbeRsp;
1958 } /* end of p2pFuncValidateProbeReq() */
1962 /*----------------------------------------------------------------------------*/
1964 * @brief This function will validate the Rx Probe Request Frame and then return
1965 * result to BSS to indicate if need to send the corresponding Probe Response
1966 * Frame if the specified conditions were matched.
1968 * @param[in] prAdapter Pointer to the Adapter structure.
1969 * @param[in] prSwRfb Pointer to SW RFB data structure.
1970 * @param[out] pu4ControlFlags Control flags for replying the Probe Response
1972 * @retval TRUE Reply the Probe Response
1973 * @retval FALSE Don't reply the Probe Response
1975 /*----------------------------------------------------------------------------*/
1977 p2pFuncValidateRxActionFrame (
1978 IN P_ADAPTER_T prAdapter,
1979 IN P_SW_RFB_T prSwRfb
1982 P_P2P_FSM_INFO_T prP2pFsmInfo = (P_P2P_FSM_INFO_T)NULL;
1984 DEBUGFUNC("p2pFuncValidateProbeReq");
1988 ASSERT_BREAK((prAdapter != NULL) && (prSwRfb != NULL));
1990 prP2pFsmInfo = prAdapter->rWifiVar.prP2pFsmInfo;
1992 if (prP2pFsmInfo->u4P2pPacketFilter & PARAM_PACKET_FILTER_ACTION_FRAME) {
1993 /* Leave the probe response to p2p_supplicant. */
1994 kalP2PIndicateRxMgmtFrame(prAdapter->prGlueInfo, prSwRfb);
2001 } /* p2pFuncValidateRxMgmtFrame */
2007 IN P_P2P_FSM_INFO_T prP2pFsmInfo
2011 if(prP2pFsmInfo->fgIsWPSMode == 1){
2014 return prP2pFsmInfo->fgIsApMode;
2020 /* p2pFuncIsAPMode */
2025 p2pFuncParseBeaconContent (
2026 IN P_ADAPTER_T prAdapter,
2027 IN P_BSS_INFO_T prP2pBssInfo,
2028 IN PUINT_8 pucIEInfo,
2032 PUINT_8 pucIE = (PUINT_8)NULL;
2033 UINT_16 u2Offset = 0;
2034 P_P2P_SPECIFIC_BSS_INFO_T prP2pSpecificBssInfo = (P_P2P_SPECIFIC_BSS_INFO_T)NULL;
2035 BOOL ucNewSecMode = FALSE;
2036 BOOL ucOldSecMode = FALSE;
2039 ASSERT_BREAK((prAdapter != NULL) &&
2040 (prP2pBssInfo != NULL));
2046 prP2pSpecificBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;
2047 prP2pSpecificBssInfo->u2AttributeLen = 0;
2049 ASSERT_BREAK(pucIEInfo != NULL);
2053 ucOldSecMode = kalP2PGetCipher(prAdapter->prGlueInfo);
2055 IE_FOR_EACH(pucIE, u4IELen, u2Offset) {
2056 switch (IE_ID(pucIE)) {
2057 case ELEM_ID_SSID: /* 0 */ /* V */ /* Done */
2059 DBGLOG(P2P, TRACE, ("SSID update\n"));
2061 /* Update when starting GO. */
2062 COPY_SSID(prP2pBssInfo->aucSSID,
2063 prP2pBssInfo->ucSSIDLen,
2064 SSID_IE(pucIE)->aucSSID,
2065 SSID_IE(pucIE)->ucLength);
2067 COPY_SSID(prP2pSpecificBssInfo->aucGroupSsid,
2068 prP2pSpecificBssInfo->u2GroupSsidLen,
2069 SSID_IE(pucIE)->aucSSID,
2070 SSID_IE(pucIE)->ucLength);
2074 case ELEM_ID_SUP_RATES: /* 1 */ /* V */ /* Done */
2076 DBGLOG(P2P, TRACE, ("Support Rate IE\n"));
2077 kalMemCopy(prP2pBssInfo->aucAllSupportedRates,
2078 SUP_RATES_IE(pucIE)->aucSupportedRates,
2079 SUP_RATES_IE(pucIE)->ucLength);
2081 prP2pBssInfo->ucAllSupportedRatesLen = SUP_RATES_IE(pucIE)->ucLength;
2083 DBGLOG_MEM8(P2P, TRACE, SUP_RATES_IE(pucIE)->aucSupportedRates, SUP_RATES_IE(pucIE)->ucLength);
2086 case ELEM_ID_DS_PARAM_SET: /* 3 */ /* V */ /* Done */
2088 P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
2090 DBGLOG(P2P, TRACE, ("DS PARAM IE\n"));
2092 ASSERT(prP2pConnSettings->ucOperatingChnl == DS_PARAM_IE(pucIE)->ucCurrChnl);
2094 if (prP2pConnSettings->eBand != BAND_2G4) {
2099 //prP2pBssInfo->ucPrimaryChannel = DS_PARAM_IE(pucIE)->ucCurrChnl;
2101 //prP2pBssInfo->eBand = BAND_2G4;
2104 case ELEM_ID_TIM: /* 5 */ /* V */
2105 DBGLOG(P2P, TRACE, ("TIM IE\n"));
2106 TIM_IE(pucIE)->ucDTIMPeriod = prP2pBssInfo->ucDTIMPeriod;
2108 case ELEM_ID_ERP_INFO: /* 42 */ /* V */
2111 /* This IE would dynamic change due to FW detection change is required. */
2112 DBGLOG(P2P, TRACE, ("ERP IE will be over write by driver\n"));
2113 DBGLOG(P2P, TRACE, (" ucERP: %x. \n", ERP_INFO_IE(pucIE)->ucERP));
2116 /* This IE would dynamic change due to FW detection change is required. */
2117 DBGLOG(P2P, TRACE, ("ERP IE.\n"));
2119 prP2pBssInfo->ucPhyTypeSet |= PHY_TYPE_SET_802_11GN;
2121 ASSERT(prP2pBssInfo->eBand == BAND_2G4);
2123 prP2pBssInfo->fgObssErpProtectMode = ((ERP_INFO_IE(pucIE)->ucERP & ERP_INFO_USE_PROTECTION)? TRUE : FALSE);
2125 prP2pBssInfo->fgErpProtectMode = ((ERP_INFO_IE(pucIE)->ucERP & (ERP_INFO_USE_PROTECTION | ERP_INFO_NON_ERP_PRESENT))? TRUE : FALSE);
2130 case ELEM_ID_HT_CAP: /* 45 */ /* V */
2133 DBGLOG(P2P, TRACE, ("HT CAP IE would be overwritten by driver\n"));
2135 DBGLOG(P2P, TRACE, ("HT Cap Info:%x, AMPDU Param:%x\n", HT_CAP_IE(pucIE)->u2HtCapInfo, HT_CAP_IE(pucIE)->ucAmpduParam));
2137 DBGLOG(P2P, TRACE, ("HT Extended Cap Info:%x, TX Beamforming Cap Info:%lx, Ant Selection Cap Info%x \n",
2138 HT_CAP_IE(pucIE)->u2HtExtendedCap,
2139 HT_CAP_IE(pucIE)->u4TxBeamformingCap,
2140 HT_CAP_IE(pucIE)->ucAselCap));
2142 prP2pBssInfo->ucPhyTypeSet |= PHY_TYPE_SET_802_11N;
2145 if ((HT_CAP_IE(pucIE)->u2HtCapInfo &
2146 (HT_CAP_INFO_SUP_CHNL_WIDTH | HT_CAP_INFO_SHORT_GI_40M | HT_CAP_INFO_DSSS_CCK_IN_40M)) == 0) {
2147 prP2pBssInfo->fgAssoc40mBwAllowed = FALSE;
2150 prP2pBssInfo->fgAssoc40mBwAllowed = TRUE;
2153 if ((HT_CAP_IE(pucIE)->u2HtCapInfo &
2154 (HT_CAP_INFO_SHORT_GI_20M | HT_CAP_INFO_SHORT_GI_40M)) == 0) {
2155 prAdapter->rWifiVar.rConnSettings.fgRxShortGIDisabled = TRUE;
2158 prAdapter->rWifiVar.rConnSettings.fgRxShortGIDisabled = FALSE;
2162 DBGLOG(P2P, TRACE, ("AMPDU setting from supplicant:0x%x, & default value:0x%x\n", (UINT_8)HT_CAP_IE(pucIE)->ucAmpduParam, (UINT_8)AMPDU_PARAM_DEFAULT_VAL));
2165 /* Can do nothing. the field is default value from other configuration. */
2166 //HT_CAP_IE(pucIE)->rSupMcsSet;
2168 /* u2HtExtendedCap */
2169 ASSERT(HT_CAP_IE(pucIE)->u2HtExtendedCap == (HT_EXT_CAP_DEFAULT_VAL & ~(HT_EXT_CAP_PCO | HT_EXT_CAP_PCO_TRANS_TIME_NONE)));
2171 /* u4TxBeamformingCap */
2172 ASSERT(HT_CAP_IE(pucIE)->u4TxBeamformingCap == TX_BEAMFORMING_CAP_DEFAULT_VAL);
2175 ASSERT(HT_CAP_IE(pucIE)->ucAselCap == ASEL_CAP_DEFAULT_VAL);
2179 case ELEM_ID_RSN: /* 48 */ /* V */
2183 DBGLOG(P2P, TRACE, ("RSN IE\n"));
2184 kalP2PSetCipher(prAdapter->prGlueInfo, IW_AUTH_CIPHER_CCMP);
2185 ucNewSecMode = TRUE;
2187 if (rsnParseRsnIE(prAdapter, RSN_IE(pucIE), &rRsnIe)) {
2188 prP2pBssInfo = &prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX];
2189 prP2pBssInfo->u4RsnSelectedGroupCipher = RSN_CIPHER_SUITE_CCMP;
2190 prP2pBssInfo->u4RsnSelectedPairwiseCipher = RSN_CIPHER_SUITE_CCMP;
2191 prP2pBssInfo->u4RsnSelectedAKMSuite = RSN_AKM_SUITE_PSK;
2192 prP2pBssInfo->u2RsnSelectedCapInfo = rRsnIe.u2RsnCap;
2196 case ELEM_ID_EXTENDED_SUP_RATES: /* 50 */ /* V */
2197 /* Be attention, ELEM_ID_SUP_RATES should be placed before ELEM_ID_EXTENDED_SUP_RATES. */
2198 DBGLOG(P2P, TRACE, ("Ex Support Rate IE\n"));
2199 kalMemCopy(&(prP2pBssInfo->aucAllSupportedRates[prP2pBssInfo->ucAllSupportedRatesLen]),
2200 EXT_SUP_RATES_IE(pucIE)->aucExtSupportedRates,
2201 EXT_SUP_RATES_IE(pucIE)->ucLength);
2203 DBGLOG_MEM8(P2P, TRACE, EXT_SUP_RATES_IE(pucIE)->aucExtSupportedRates, EXT_SUP_RATES_IE(pucIE)->ucLength);
2205 prP2pBssInfo->ucAllSupportedRatesLen += EXT_SUP_RATES_IE(pucIE)->ucLength;
2207 case ELEM_ID_HT_OP: /* 61 */ /* V */ // TODO:
2210 DBGLOG(P2P, TRACE, ("HT OP IE would be overwritten by driver\n"));
2212 DBGLOG(P2P, TRACE, (" Primary Channel: %x, Info1: %x, Info2: %x, Info3: %x\n",
2213 HT_OP_IE(pucIE)->ucPrimaryChannel,
2214 HT_OP_IE(pucIE)->ucInfo1,
2215 HT_OP_IE(pucIE)->u2Info2,
2216 HT_OP_IE(pucIE)->u2Info3));
2218 UINT_16 u2Info2 = 0;
2219 prP2pBssInfo->ucPhyTypeSet |= PHY_TYPE_SET_802_11N;
2221 DBGLOG(P2P, TRACE, ("HT OP IE\n"));
2223 /* ucPrimaryChannel. */
2224 ASSERT(HT_OP_IE(pucIE)->ucPrimaryChannel == prP2pBssInfo->ucPrimaryChannel);
2227 prP2pBssInfo->ucHtOpInfo1 = HT_OP_IE(pucIE)->ucInfo1;
2230 u2Info2 = HT_OP_IE(pucIE)->u2Info2;
2232 if (u2Info2 & HT_OP_INFO2_NON_GF_HT_STA_PRESENT) {
2233 ASSERT(prP2pBssInfo->eGfOperationMode != GF_MODE_NORMAL);
2234 u2Info2 &= ~HT_OP_INFO2_NON_GF_HT_STA_PRESENT;
2237 if (u2Info2 & HT_OP_INFO2_OBSS_NON_HT_STA_PRESENT) {
2238 prP2pBssInfo->eObssHtProtectMode = HT_PROTECT_MODE_NON_MEMBER;
2239 u2Info2 &= ~HT_OP_INFO2_OBSS_NON_HT_STA_PRESENT;
2242 switch (u2Info2 & HT_OP_INFO2_HT_PROTECTION) {
2243 case HT_PROTECT_MODE_NON_HT:
2244 prP2pBssInfo->eHtProtectMode = HT_PROTECT_MODE_NON_HT;
2246 case HT_PROTECT_MODE_NON_MEMBER:
2247 prP2pBssInfo->eHtProtectMode = HT_PROTECT_MODE_NONE;
2248 prP2pBssInfo->eObssHtProtectMode = HT_PROTECT_MODE_NON_MEMBER;
2251 prP2pBssInfo->eHtProtectMode = HT_OP_IE(pucIE)->u2Info2;
2256 prP2pBssInfo->u2HtOpInfo3 = HT_OP_IE(pucIE)->u2Info3;
2258 /* aucBasicMcsSet */
2259 DBGLOG_MEM8(P2P, TRACE, HT_OP_IE(pucIE)->aucBasicMcsSet, 16);
2263 case ELEM_ID_OBSS_SCAN_PARAMS: /* 74 */ /* V */
2265 DBGLOG(P2P, TRACE, ("ELEM_ID_OBSS_SCAN_PARAMS IE would be replaced by driver\n"));
2268 case ELEM_ID_EXTENDED_CAP: /* 127 */ /* V */
2270 DBGLOG(P2P, TRACE, ("ELEM_ID_EXTENDED_CAP IE would be replaced by driver\n"));
2273 case ELEM_ID_VENDOR: /* 221 */ /* V */
2274 DBGLOG(P2P, TRACE, ("Vender Specific IE\n"));
2277 UINT_16 u2SubTypeVersion;
2278 if (rsnParseCheckForWFAInfoElem(prAdapter, pucIE, &ucOuiType, &u2SubTypeVersion)) {
2279 if ((ucOuiType == VENDOR_OUI_TYPE_WPA) &&
2280 (u2SubTypeVersion == VERSION_WPA)) {
2281 kalP2PSetCipher(prAdapter->prGlueInfo, IW_AUTH_CIPHER_TKIP);
2282 ucNewSecMode = TRUE;
2284 else if ((ucOuiType == VENDOR_OUI_TYPE_WPS)) {
2285 kalP2PUpdateWSC_IE(prAdapter->prGlueInfo, 0, pucIE, IE_SIZE(pucIE));
2290 else if (p2pFuncParseCheckForP2PInfoElem(prAdapter, pucIE, &ucOuiType)) {
2291 // TODO Store the whole P2P IE & generate later.
2292 // Be aware that there may be one or more P2P IE.
2293 if (ucOuiType == VENDOR_OUI_TYPE_P2P) {
2294 kalMemCopy(&prP2pSpecificBssInfo->aucAttributesCache[prP2pSpecificBssInfo->u2AttributeLen],
2298 prP2pSpecificBssInfo->u2AttributeLen += IE_SIZE(pucIE);
2300 else if(ucOuiType == VENDOR_OUI_TYPE_WFD) {
2302 kalMemCopy(&prP2pSpecificBssInfo->aucAttributesCache[prP2pSpecificBssInfo->u2AttributeLen],
2306 prP2pSpecificBssInfo->u2AttributeLen += IE_SIZE(pucIE);
2311 kalMemCopy(&prP2pSpecificBssInfo->aucAttributesCache[prP2pSpecificBssInfo->u2AttributeLen],
2315 prP2pSpecificBssInfo->u2AttributeLen += IE_SIZE(pucIE);
2316 DBGLOG(P2P, TRACE, ("Driver unprocessed Vender Specific IE\n"));
2320 // TODO: Store other Vender IE except for WMM Param.
2324 DBGLOG(P2P, TRACE, ("Unprocessed element ID:%d \n", IE_ID(pucIE)));
2329 if (!ucNewSecMode && ucOldSecMode)
2330 kalP2PSetCipher(prAdapter->prGlueInfo, IW_AUTH_CIPHER_NONE);
2335 } /* p2pFuncParseBeaconContent */
2341 p2pFuncKeepOnConnection (
2342 IN P_ADAPTER_T prAdapter,
2343 IN P_P2P_CONNECTION_REQ_INFO_T prConnReqInfo,
2344 IN P_P2P_CHNL_REQ_INFO_T prChnlReqInfo,
2345 IN P_P2P_SCAN_REQ_INFO_T prScanReqInfo
2348 P_BSS_DESC_T prTargetBss = (P_BSS_DESC_T)NULL;
2349 P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T)NULL;
2352 ASSERT_BREAK((prAdapter != NULL) &&
2353 (prConnReqInfo != NULL) &&
2354 (prChnlReqInfo != NULL) &&
2355 (prScanReqInfo != NULL));
2357 prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
2359 if (prP2pBssInfo->eCurrentOPMode != OP_MODE_INFRASTRUCTURE) {
2363 // Update connection request information.
2364 ASSERT(prConnReqInfo->fgIsConnRequest == TRUE);
2366 /* Find BSS Descriptor first. */
2367 prTargetBss = scanP2pSearchDesc(prAdapter,
2371 if (prTargetBss == NULL) {
2372 /* Update scan parameter... to scan target device. */
2373 prScanReqInfo->ucNumChannelList = 1;
2374 prScanReqInfo->eScanType = SCAN_TYPE_ACTIVE_SCAN;
2375 prScanReqInfo->eChannelSet = SCAN_CHANNEL_FULL;
2376 prScanReqInfo->u4BufLength = 0; /* Prevent other P2P ID in IE. */
2377 prScanReqInfo->fgIsAbort = TRUE;
2380 prChnlReqInfo->u8Cookie = 0;
2381 prChnlReqInfo->ucReqChnlNum = prTargetBss->ucChannelNum;
2382 prChnlReqInfo->eBand = prTargetBss->eBand;
2383 prChnlReqInfo->eChnlSco = prTargetBss->eSco;
2384 prChnlReqInfo->u4MaxInterval = AIS_JOIN_CH_REQUEST_INTERVAL;
2385 prChnlReqInfo->eChannelReqType = CHANNEL_REQ_TYPE_GC_JOIN_REQ;
2391 } /* p2pFuncKeepOnConnection */
2393 /* Currently Only for ASSOC Response Frame. */
2395 p2pFuncStoreAssocRspIEBuffer (
2396 IN P_ADAPTER_T prAdapter,
2397 IN P_SW_RFB_T prSwRfb
2400 P_P2P_FSM_INFO_T prP2pFsmInfo = (P_P2P_FSM_INFO_T)NULL;
2401 P_P2P_JOIN_INFO_T prJoinInfo = (P_P2P_JOIN_INFO_T)NULL;
2402 P_WLAN_ASSOC_RSP_FRAME_T prAssocRspFrame = (P_WLAN_ASSOC_RSP_FRAME_T)NULL;
2406 ASSERT_BREAK((prAdapter != NULL) && (prSwRfb != NULL));
2408 prAssocRspFrame = (P_WLAN_ASSOC_RSP_FRAME_T)prSwRfb->pvHeader;
2410 if (prAssocRspFrame->u2FrameCtrl != MAC_FRAME_ASSOC_RSP) {
2414 i2IELen = prSwRfb->u2PacketLen - (WLAN_MAC_HEADER_LEN +
2415 CAP_INFO_FIELD_LEN +
2416 STATUS_CODE_FIELD_LEN +
2424 prP2pFsmInfo = prAdapter->rWifiVar.prP2pFsmInfo;
2425 prJoinInfo = &(prP2pFsmInfo->rJoinInfo);
2426 prJoinInfo->u4BufLength = (UINT_32)i2IELen;
2428 kalMemCopy(prJoinInfo->aucIEBuf, prAssocRspFrame->aucInfoElem, prJoinInfo->u4BufLength);
2434 } /* p2pFuncStoreAssocRspIEBuffer */
2439 /*----------------------------------------------------------------------------*/
2441 * \brief This routine is called to set Packet Filter.
2443 * \param[in] prAdapter Pointer to the Adapter structure.
2444 * \param[in] pvSetBuffer Pointer to the buffer that holds the data to be set.
2445 * \param[in] u4SetBufferLen The length of the set buffer.
2446 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
2447 * bytes read from the set buffer. If the call failed
2448 * due to invalid length of the set buffer, returns
2449 * the amount of storage needed.
2451 * \retval WLAN_STATUS_SUCCESS
2452 * \retval WLAN_STATUS_INVALID_LENGTH
2453 * \retval WLAN_STATUS_NOT_SUPPORTED
2454 * \retval WLAN_STATUS_ADAPTER_NOT_READY
2456 /*----------------------------------------------------------------------------*/
2458 p2pFuncMgmtFrameRegister (
2459 IN P_ADAPTER_T prAdapter,
2460 IN UINT_16 u2FrameType,
2461 IN BOOLEAN fgIsRegistered,
2462 OUT PUINT_32 pu4P2pPacketFilter
2465 UINT_32 u4NewPacketFilter = 0;
2467 DEBUGFUNC("p2pFuncMgmtFrameRegister");
2470 ASSERT_BREAK(prAdapter != NULL);
2472 if (pu4P2pPacketFilter) {
2473 u4NewPacketFilter = *pu4P2pPacketFilter;
2476 switch (u2FrameType) {
2477 case MAC_FRAME_PROBE_REQ:
2478 if (fgIsRegistered) {
2479 u4NewPacketFilter |= PARAM_PACKET_FILTER_PROBE_REQ;
2480 DBGLOG(P2P, TRACE, ("Open packet filer probe request\n"));
2483 u4NewPacketFilter &= ~PARAM_PACKET_FILTER_PROBE_REQ;
2484 DBGLOG(P2P, TRACE, ("Close packet filer probe request\n"));
2487 case MAC_FRAME_ACTION:
2488 if (fgIsRegistered) {
2489 u4NewPacketFilter |= PARAM_PACKET_FILTER_ACTION_FRAME;
2490 DBGLOG(P2P, TRACE, ("Open packet filer action frame.\n"));
2493 u4NewPacketFilter &= ~PARAM_PACKET_FILTER_ACTION_FRAME;
2494 DBGLOG(P2P, TRACE, ("Close packet filer action frame.\n"));
2498 DBGLOG(P2P, TRACE, ("Ask frog to add code for mgmt:%x\n", u2FrameType));
2502 if (pu4P2pPacketFilter) {
2503 *pu4P2pPacketFilter = u4NewPacketFilter;
2506 // u4NewPacketFilter |= prAdapter->u4OsPacketFilter;
2508 prAdapter->u4OsPacketFilter &= ~PARAM_PACKET_FILTER_P2P_MASK;
2509 prAdapter->u4OsPacketFilter |= u4NewPacketFilter;
2511 DBGLOG(P2P, TRACE, ("P2P Set PACKET filter:0x%lx\n", prAdapter->u4OsPacketFilter));
2513 wlanSendSetQueryCmd(prAdapter,
2514 CMD_ID_SET_RX_FILTER,
2518 nicCmdEventSetCommon,
2519 nicOidCmdTimeoutCommon,
2521 (PUINT_8)&prAdapter->u4OsPacketFilter,
2523 sizeof(u4NewPacketFilter)
2529 } /* p2pFuncMgmtFrameRegister */
2533 p2pFuncUpdateMgmtFrameRegister (
2534 IN P_ADAPTER_T prAdapter,
2535 IN UINT_32 u4OsFilter
2541 prAdapter->rWifiVar.prP2pFsmInfo->u4P2pPacketFilter = u4OsFilter;
2543 if ((prAdapter->u4OsPacketFilter & PARAM_PACKET_FILTER_P2P_MASK) ^ u4OsFilter) {
2545 prAdapter->u4OsPacketFilter &= ~PARAM_PACKET_FILTER_P2P_MASK;
2547 prAdapter->u4OsPacketFilter |= (u4OsFilter & PARAM_PACKET_FILTER_P2P_MASK);
2549 wlanSendSetQueryCmd(prAdapter,
2550 CMD_ID_SET_RX_FILTER,
2554 nicCmdEventSetCommon,
2555 nicOidCmdTimeoutCommon,
2557 (PUINT_8)&prAdapter->u4OsPacketFilter,
2561 DBGLOG(P2P, TRACE, ("P2P Set PACKET filter:0x%lx\n", prAdapter->u4OsPacketFilter));
2570 } /* p2pFuncUpdateMgmtFrameRegister */
2574 p2pFuncGetStationInfo (
2575 IN P_ADAPTER_T prAdapter,
2576 IN PUINT_8 pucMacAddr,
2577 OUT P_P2P_STATION_INFO_T prStaInfo
2582 ASSERT_BREAK((prAdapter != NULL) &&
2583 (pucMacAddr != NULL) &&
2584 (prStaInfo != NULL));
2586 prStaInfo->u4InactiveTime = 0;
2587 prStaInfo->u4RxBytes = 0;
2588 prStaInfo->u4TxBytes = 0;
2589 prStaInfo->u4RxPackets = 0;
2590 prStaInfo->u4TxPackets = 0;
2596 } /* p2pFuncGetStationInfo */
2600 p2pFuncGetAttriList (
2601 IN P_ADAPTER_T prAdapter,
2602 IN UINT_8 ucOuiType,
2604 IN UINT_16 u2IELength,
2605 OUT PPUINT_8 ppucAttriList,
2606 OUT PUINT_16 pu2AttriListLen
2609 BOOLEAN fgIsAllocMem = FALSE;
2610 UINT_8 aucWfaOui[] = VENDOR_OUI_WFA_SPECIFIC;
2611 UINT_16 u2Offset = 0;
2612 P_IE_P2P_T prIe = (P_IE_P2P_T)NULL;
2613 PUINT_8 pucAttriListStart = (PUINT_8)NULL;
2614 UINT_16 u2AttriListLen = 0, u2BufferSize = 0;
2615 BOOLEAN fgBackupAttributes = FALSE;
2618 ASSERT_BREAK((prAdapter != NULL) &&
2620 (u2IELength != 0) &&
2621 (ppucAttriList != NULL) &&
2622 (pu2AttriListLen != NULL));
2625 *ppucAttriList = NULL;
2627 if(pu2AttriListLen) {
2628 *pu2AttriListLen = 0;
2631 if (ucOuiType == VENDOR_OUI_TYPE_WPS){
2632 aucWfaOui[0] = 0x00;
2633 aucWfaOui[1] = 0x50;
2634 aucWfaOui[2] = 0xF2;
2636 else if ((ucOuiType != VENDOR_OUI_TYPE_P2P)
2638 && (ucOuiType != VENDOR_OUI_TYPE_WFD)
2641 DBGLOG(P2P, INFO, ("Not supported OUI Type to parsing 0x%x\n", ucOuiType));
2646 IE_FOR_EACH(pucIE, u2IELength, u2Offset) {
2647 if (ELEM_ID_VENDOR == IE_ID(pucIE)) {
2648 prIe = (P_IE_P2P_T)pucIE;
2650 if (prIe->ucLength <= P2P_OUI_TYPE_LEN) {
2655 if ((prIe->aucOui[0] == aucWfaOui[0]) &&
2656 (prIe->aucOui[1] == aucWfaOui[1]) &&
2657 (prIe->aucOui[2] == aucWfaOui[2]) &&
2658 (ucOuiType == prIe->ucOuiType)) {
2660 if (!pucAttriListStart) {
2661 pucAttriListStart = &prIe->aucP2PAttributes[0];
2662 if (prIe->ucLength > P2P_OUI_TYPE_LEN) {
2663 u2AttriListLen = (UINT_16)(prIe->ucLength - P2P_OUI_TYPE_LEN);
2670 /* More than 2 attributes. */
2673 if (FALSE == fgBackupAttributes) {
2674 P_P2P_SPECIFIC_BSS_INFO_T prP2pSpecificBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;;
2676 fgBackupAttributes = TRUE;
2677 if (ucOuiType == VENDOR_OUI_TYPE_P2P) {
2678 kalMemCopy(&prP2pSpecificBssInfo->aucAttributesCache[0],
2682 pucAttriListStart = &prP2pSpecificBssInfo->aucAttributesCache[0];
2684 u2BufferSize = P2P_MAXIMUM_ATTRIBUTE_LEN;
2686 else if (ucOuiType == VENDOR_OUI_TYPE_WPS) {
2687 kalMemCopy(&prP2pSpecificBssInfo->aucWscAttributesCache[0],
2690 pucAttriListStart = &prP2pSpecificBssInfo->aucWscAttributesCache[0];
2692 u2BufferSize = WPS_MAXIMUM_ATTRIBUTES_CACHE_SIZE;
2695 else if (ucOuiType == VENDOR_OUI_TYPE_WFD) {
2696 PUINT_8 pucTmpBuf = (PUINT_8)NULL;
2697 pucTmpBuf = (PUINT_8)kalMemAlloc(WPS_MAXIMUM_ATTRIBUTES_CACHE_SIZE, VIR_MEM_TYPE);
2699 if (pucTmpBuf != NULL) {
2700 fgIsAllocMem = TRUE;
2703 /* Can't alloca memory for WFD IE relocate. */
2708 kalMemCopy(pucTmpBuf,
2712 pucAttriListStart = pucTmpBuf;
2714 u2BufferSize = WPS_MAXIMUM_ATTRIBUTES_CACHE_SIZE;
2718 fgBackupAttributes = FALSE;
2722 u2CopyLen = (UINT_16)(prIe->ucLength - P2P_OUI_TYPE_LEN);
2724 if ((u2AttriListLen + u2CopyLen) > u2BufferSize) {
2726 u2CopyLen = u2BufferSize - u2AttriListLen;
2728 DBGLOG(P2P, WARN, ("Length of received P2P attributes > maximum cache size.\n"));
2733 kalMemCopy((PUINT_8)((UINT_32)pucAttriListStart + (UINT_32)u2AttriListLen),
2734 &prIe->aucP2PAttributes[0],
2737 u2AttriListLen += u2CopyLen;
2742 } /* prIe->aucOui */
2743 } /* ELEM_ID_VENDOR */
2749 if (pucAttriListStart) {
2750 PUINT_8 pucAttribute = pucAttriListStart;
2751 DBGLOG(P2P, LOUD, ("Checking Attribute Length.\n"));
2752 if (ucOuiType == VENDOR_OUI_TYPE_P2P) {
2753 P2P_ATTRI_FOR_EACH(pucAttribute, u2AttriListLen, u2Offset);
2755 else if (ucOuiType == VENDOR_OUI_TYPE_WFD) {
2757 else if (ucOuiType == VENDOR_OUI_TYPE_WPS) {
2758 /* Big Endian: WSC, WFD. */
2759 WSC_ATTRI_FOR_EACH(pucAttribute, u2AttriListLen, u2Offset) {
2760 DBGLOG(P2P, LOUD, ("Attribute ID:%d, Length:%d.\n",
2761 WSC_ATTRI_ID(pucAttribute),
2762 WSC_ATTRI_LEN(pucAttribute)));
2768 ASSERT(u2Offset == u2AttriListLen);
2770 *ppucAttriList = pucAttriListStart;
2771 *pu2AttriListLen = u2AttriListLen;
2775 *ppucAttriList = (PUINT_8)NULL;
2776 *pu2AttriListLen = 0;
2779 return fgIsAllocMem;
2780 } /* p2pFuncGetAttriList */
2784 p2pFuncProcessP2pProbeRsp (
2785 IN P_ADAPTER_T prAdapter,
2786 IN P_MSDU_INFO_T prMgmtTxMsdu
2789 P_MSDU_INFO_T prRetMsduInfo = prMgmtTxMsdu;
2790 P_WLAN_PROBE_RSP_FRAME_T prProbeRspFrame = (P_WLAN_PROBE_RSP_FRAME_T)NULL;
2791 PUINT_8 pucIEBuf = (PUINT_8)NULL;
2792 UINT_16 u2Offset = 0, u2IELength = 0, u2ProbeRspHdrLen = 0;
2793 BOOLEAN fgIsP2PIE = FALSE, fgIsWSCIE = FALSE;
2794 P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T)NULL;
2795 UINT_16 u2EstimateSize = 0, u2EstimatedExtraIELen = 0;
2796 UINT_32 u4IeArraySize = 0, u4Idx = 0;
2800 ASSERT_BREAK((prAdapter != NULL) && (prMgmtTxMsdu != NULL));
2802 prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
2804 //3 Make sure this is probe response frame.
2805 prProbeRspFrame = (P_WLAN_PROBE_RSP_FRAME_T)((UINT_32)prMgmtTxMsdu->prPacket + MAC_TX_RESERVED_FIELD);
2806 ASSERT_BREAK((prProbeRspFrame->u2FrameCtrl & MASK_FRAME_TYPE) == MAC_FRAME_PROBE_RSP);
2808 //3 Get the importent P2P IE.
2809 u2ProbeRspHdrLen = (WLAN_MAC_MGMT_HEADER_LEN + TIMESTAMP_FIELD_LEN + BEACON_INTERVAL_FIELD_LEN + CAP_INFO_FIELD_LEN);
2810 pucIEBuf = prProbeRspFrame->aucInfoElem;
2811 u2IELength = prMgmtTxMsdu->u2FrameLength - u2ProbeRspHdrLen;
2814 prAdapter->prGlueInfo->prP2PInfo->u2VenderIELen = 0;
2817 IE_FOR_EACH(pucIEBuf, u2IELength, u2Offset) {
2818 switch (IE_ID(pucIEBuf)) {
2822 COPY_SSID(prP2pBssInfo->aucSSID,
2823 prP2pBssInfo->ucSSIDLen,
2824 SSID_IE(pucIEBuf)->aucSSID,
2825 SSID_IE(pucIEBuf)->ucLength);
2828 case ELEM_ID_VENDOR:
2830 UINT_8 ucOuiType = 0;
2831 UINT_16 u2SubTypeVersion = 0;
2832 #if! CFG_SUPPORT_WFD
2835 if (rsnParseCheckForWFAInfoElem(prAdapter, pucIEBuf, &ucOuiType, &u2SubTypeVersion)) {
2836 if (ucOuiType == VENDOR_OUI_TYPE_WPS) {
2837 kalP2PUpdateWSC_IE(prAdapter->prGlueInfo, 2, pucIEBuf, IE_SIZE(pucIEBuf));
2843 else if (p2pFuncParseCheckForP2PInfoElem(prAdapter, pucIEBuf, &ucOuiType)) {
2844 if (ucOuiType == VENDOR_OUI_TYPE_P2P) {
2845 //2 Note(frog): I use WSC IE buffer for Probe Request to store the P2P IE for Probe Response.
2846 kalP2PUpdateWSC_IE(prAdapter->prGlueInfo, 1, pucIEBuf, IE_SIZE(pucIEBuf));
2855 if((prAdapter->prGlueInfo->prP2PInfo->u2VenderIELen+IE_SIZE(pucIEBuf))<512) {
2856 kalMemCopy(prAdapter->prGlueInfo->prP2PInfo->aucVenderIE, pucIEBuf, IE_SIZE(pucIEBuf));
2857 prAdapter->prGlueInfo->prP2PInfo->u2VenderIELen += IE_SIZE(pucIEBuf);
2861 /* Eddie May be WFD */
2862 if (rsnParseCheckForWFAInfoElem(prAdapter, pucIEBuf, &ucOuiType, &u2SubTypeVersion)) {
2863 if(ucOuiType == VENDOR_OUI_TYPE_WMM) {
2868 if((prAdapter->prGlueInfo->prP2PInfo->u2VenderIELen+IE_SIZE(pucIEBuf))<1024) {
2869 kalMemCopy(prAdapter->prGlueInfo->prP2PInfo->aucVenderIE + prAdapter->prGlueInfo->prP2PInfo->u2VenderIELen
2870 , pucIEBuf, IE_SIZE(pucIEBuf));
2871 prAdapter->prGlueInfo->prP2PInfo->u2VenderIELen += IE_SIZE(pucIEBuf);
2885 //3 Check the total size & current frame.
2886 u2EstimateSize = WLAN_MAC_MGMT_HEADER_LEN + \
2887 TIMESTAMP_FIELD_LEN + \
2888 BEACON_INTERVAL_FIELD_LEN + \
2889 CAP_INFO_FIELD_LEN + \
2890 (ELEM_HDR_LEN + ELEM_MAX_LEN_SSID) + \
2891 (ELEM_HDR_LEN + ELEM_MAX_LEN_SUP_RATES) + \
2892 (ELEM_HDR_LEN + ELEM_MAX_LEN_DS_PARAMETER_SET);
2894 u2EstimatedExtraIELen = 0;
2896 u4IeArraySize = sizeof(txProbeRspIETable)/sizeof(APPEND_VAR_IE_ENTRY_T);
2897 for (u4Idx = 0; u4Idx < u4IeArraySize; u4Idx++) {
2898 if (txProbeRspIETable[u4Idx].u2EstimatedFixedIELen) {
2899 u2EstimatedExtraIELen += txProbeRspIETable[u4Idx].u2EstimatedFixedIELen;
2903 ASSERT(txProbeRspIETable[u4Idx].pfnCalculateVariableIELen);
2905 u2EstimatedExtraIELen += (UINT_16)(txProbeRspIETable[u4Idx].pfnCalculateVariableIELen(prAdapter,
2906 NETWORK_TYPE_P2P_INDEX,
2914 u2EstimatedExtraIELen += kalP2PCalWSC_IELen(prAdapter->prGlueInfo, 2);
2918 u2EstimatedExtraIELen += kalP2PCalWSC_IELen(prAdapter->prGlueInfo, 1);
2922 u2EstimatedExtraIELen += prAdapter->prGlueInfo->prP2PInfo->u2VenderIELen;
2927 if ((u2EstimateSize += u2EstimatedExtraIELen) > (prRetMsduInfo->u2FrameLength)) {
2928 prRetMsduInfo = cnmMgtPktAlloc(prAdapter, u2EstimateSize);
2930 if (prRetMsduInfo == NULL) {
2931 DBGLOG(P2P, WARN, ("No packet for sending new probe response, use original one\n"));
2932 prRetMsduInfo = prMgmtTxMsdu;
2937 prRetMsduInfo->ucNetworkType = NETWORK_TYPE_P2P_INDEX;
2941 //3 Compose / Re-compose probe response frame.
2942 bssComposeBeaconProbeRespFrameHeaderAndFF(
2943 (PUINT_8)((UINT_32)(prRetMsduInfo->prPacket) + MAC_TX_RESERVED_FIELD),
2944 prProbeRspFrame->aucDestAddr,
2945 prProbeRspFrame->aucSrcAddr,
2946 prProbeRspFrame->aucBSSID,
2947 prProbeRspFrame->u2BeaconInterval,
2948 prProbeRspFrame->u2CapInfo);
2950 prRetMsduInfo->u2FrameLength = (WLAN_MAC_MGMT_HEADER_LEN + TIMESTAMP_FIELD_LEN + BEACON_INTERVAL_FIELD_LEN + CAP_INFO_FIELD_LEN);
2952 bssBuildBeaconProbeRespFrameCommonIEs(prRetMsduInfo,
2954 prProbeRspFrame->aucDestAddr);
2957 for (u4Idx = 0; u4Idx < u4IeArraySize; u4Idx++) {
2958 if (txProbeRspIETable[u4Idx].pfnAppendIE) {
2959 txProbeRspIETable[u4Idx].pfnAppendIE(prAdapter, prRetMsduInfo);
2966 kalP2PGenWSC_IE(prAdapter->prGlueInfo,
2968 (PUINT_8)((UINT_32)prRetMsduInfo->prPacket + (UINT_32)prRetMsduInfo->u2FrameLength));
2970 prRetMsduInfo->u2FrameLength += (UINT_16)kalP2PCalWSC_IELen(prAdapter->prGlueInfo, 2);
2974 kalP2PGenWSC_IE(prAdapter->prGlueInfo,
2976 (PUINT_8)((UINT_32)prRetMsduInfo->prPacket + (UINT_32)prRetMsduInfo->u2FrameLength));
2978 prRetMsduInfo->u2FrameLength += (UINT_16)kalP2PCalWSC_IELen(prAdapter->prGlueInfo, 1);
2982 if(prAdapter->prGlueInfo->prP2PInfo->u2VenderIELen>0) {
2983 kalMemCopy((PUINT_8)((UINT_32)prRetMsduInfo->prPacket + (UINT_32)prRetMsduInfo->u2FrameLength),
2984 prAdapter->prGlueInfo->prP2PInfo->aucVenderIE, prAdapter->prGlueInfo->prP2PInfo->u2VenderIELen);
2985 prRetMsduInfo->u2FrameLength += (UINT_16) prAdapter->prGlueInfo->prP2PInfo->u2VenderIELen;
2992 if (prRetMsduInfo != prMgmtTxMsdu) {
2993 cnmMgtPktFree(prAdapter, prMgmtTxMsdu);
2997 return prRetMsduInfo;
2998 } /* p2pFuncProcessP2pProbeRsp */
3001 #if 0 //LINUX_VERSION_CODE >= KERNEL_VERSION(3, 2, 0)
3003 p2pFuncCalculateExtra_IELenForBeacon (
3004 IN P_ADAPTER_T prAdapter,
3005 IN ENUM_NETWORK_TYPE_INDEX_T eNetTypeIndex,
3006 IN P_STA_RECORD_T prStaRec
3010 P_P2P_SPECIFIC_BSS_INFO_T prP2pSpeBssInfo = (P_P2P_SPECIFIC_BSS_INFO_T)NULL;
3011 UINT_32 u4IELen = 0;
3014 ASSERT_BREAK((prAdapter != NULL) && (eNetTypeIndex == NETWORK_TYPE_P2P_INDEX));
3016 if (p2pFuncIsAPMode(prAdapter->rWifiVar.prP2pFsmInfo)) {
3020 prP2pSpeBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;
3022 u4IELen = prP2pSpeBssInfo->u2IELenForBCN;
3027 } /* p2pFuncCalculateP2p_IELenForBeacon */
3030 p2pFuncGenerateExtra_IEForBeacon (
3031 IN P_ADAPTER_T prAdapter,
3032 IN P_MSDU_INFO_T prMsduInfo
3035 P_P2P_SPECIFIC_BSS_INFO_T prP2pSpeBssInfo = (P_P2P_SPECIFIC_BSS_INFO_T)NULL;
3036 PUINT_8 pucIEBuf = (PUINT_8)NULL;
3039 ASSERT_BREAK((prAdapter != NULL) && (prMsduInfo != NULL));
3041 prP2pSpeBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;
3043 if (p2pFuncIsAPMode(prAdapter->rWifiVar.prP2pFsmInfo)) {
3048 pucIEBuf = (PUINT_8)((UINT_32)prMsduInfo->prPacket + (UINT_32)prMsduInfo->u2FrameLength);
3050 kalMemCopy(pucIEBuf, prP2pSpeBssInfo->aucBeaconIECache, prP2pSpeBssInfo->u2IELenForBCN);
3052 prMsduInfo->u2FrameLength += prP2pSpeBssInfo->u2IELenForBCN;
3057 } /* p2pFuncGenerateExtra_IEForBeacon */
3062 p2pFuncCalculateP2p_IELenForBeacon (
3063 IN P_ADAPTER_T prAdapter,
3064 IN ENUM_NETWORK_TYPE_INDEX_T eNetTypeIndex,
3065 IN P_STA_RECORD_T prStaRec
3068 P_P2P_SPECIFIC_BSS_INFO_T prP2pSpeBssInfo = (P_P2P_SPECIFIC_BSS_INFO_T)NULL;
3069 UINT_32 u4IELen = 0;
3072 ASSERT_BREAK((prAdapter != NULL) && (eNetTypeIndex == NETWORK_TYPE_P2P_INDEX));
3074 if (!prAdapter->fgIsP2PRegistered) {
3079 if (p2pFuncIsAPMode(prAdapter->rWifiVar.prP2pFsmInfo)) {
3083 prP2pSpeBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;
3085 u4IELen = prP2pSpeBssInfo->u2AttributeLen;
3090 } /* p2pFuncCalculateP2p_IELenForBeacon */
3094 p2pFuncGenerateP2p_IEForBeacon (
3095 IN P_ADAPTER_T prAdapter,
3096 IN P_MSDU_INFO_T prMsduInfo
3099 P_P2P_SPECIFIC_BSS_INFO_T prP2pSpeBssInfo = (P_P2P_SPECIFIC_BSS_INFO_T)NULL;
3100 PUINT_8 pucIEBuf = (PUINT_8)NULL;
3103 ASSERT_BREAK((prAdapter != NULL) && (prMsduInfo != NULL));
3105 if (!prAdapter->fgIsP2PRegistered) {
3109 prP2pSpeBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;
3111 if (p2pFuncIsAPMode(prAdapter->rWifiVar.prP2pFsmInfo)) {
3116 pucIEBuf = (PUINT_8)((UINT_32)prMsduInfo->prPacket + (UINT_32)prMsduInfo->u2FrameLength);
3118 kalMemCopy(pucIEBuf, prP2pSpeBssInfo->aucAttributesCache, prP2pSpeBssInfo->u2AttributeLen);
3120 prMsduInfo->u2FrameLength += prP2pSpeBssInfo->u2AttributeLen;
3125 } /* p2pFuncGenerateP2p_IEForBeacon */
3132 p2pFuncCalculateWSC_IELenForBeacon (
3133 IN P_ADAPTER_T prAdapter,
3134 IN ENUM_NETWORK_TYPE_INDEX_T eNetTypeIndex,
3135 IN P_STA_RECORD_T prStaRec
3138 if (eNetTypeIndex != NETWORK_TYPE_P2P_INDEX) {
3142 return kalP2PCalWSC_IELen(prAdapter->prGlueInfo, 0);
3143 } /* p2pFuncCalculateP2p_IELenForBeacon */
3147 p2pFuncGenerateWSC_IEForBeacon (
3148 IN P_ADAPTER_T prAdapter,
3149 IN P_MSDU_INFO_T prMsduInfo
3153 UINT_16 u2IELen = 0;
3157 if (prMsduInfo->ucNetworkType != NETWORK_TYPE_P2P_INDEX) {
3161 u2IELen = (UINT_16)kalP2PCalWSC_IELen(prAdapter->prGlueInfo, 0);
3163 pucBuffer = (PUINT_8)((UINT_32)prMsduInfo->prPacket +
3164 (UINT_32)prMsduInfo->u2FrameLength);
3168 // TODO: Check P2P FSM State.
3169 kalP2PGenWSC_IE(prAdapter->prGlueInfo,
3173 prMsduInfo->u2FrameLength += u2IELen;
3176 } /* p2pFuncGenerateP2p_IEForBeacon */
3179 /*----------------------------------------------------------------------------*/
3181 * @brief This function is used to calculate P2P IE length for Beacon frame.
3183 * @param[in] eNetTypeIndex Specify which network
3184 * @param[in] prStaRec Pointer to the STA_RECORD_T
3186 * @return The length of P2P IE added
3188 /*----------------------------------------------------------------------------*/
3190 p2pFuncCalculateP2p_IELenForAssocRsp (
3191 IN P_ADAPTER_T prAdapter,
3192 IN ENUM_NETWORK_TYPE_INDEX_T eNetTypeIndex,
3193 IN P_STA_RECORD_T prStaRec
3197 if (eNetTypeIndex != NETWORK_TYPE_P2P_INDEX) {
3201 return p2pFuncCalculateP2P_IELen(prAdapter,
3204 txAssocRspAttributesTable,
3205 sizeof(txAssocRspAttributesTable)/sizeof(APPEND_VAR_ATTRI_ENTRY_T));
3207 } /* p2pFuncCalculateP2p_IELenForAssocRsp */
3214 /*----------------------------------------------------------------------------*/
3216 * @brief This function is used to generate P2P IE for Beacon frame.
3218 * @param[in] prMsduInfo Pointer to the composed MSDU_INFO_T.
3222 /*----------------------------------------------------------------------------*/
3224 p2pFuncGenerateP2p_IEForAssocRsp (
3225 IN P_ADAPTER_T prAdapter,
3226 IN P_MSDU_INFO_T prMsduInfo
3229 P_P2P_FSM_INFO_T prP2pFsmInfo = (P_P2P_FSM_INFO_T)NULL;
3230 P_STA_RECORD_T prStaRec = (P_STA_RECORD_T)NULL;
3233 ASSERT_BREAK((prAdapter != NULL) && (prMsduInfo != NULL));
3235 prP2pFsmInfo = prAdapter->rWifiVar.prP2pFsmInfo;
3237 prStaRec = cnmGetStaRecByIndex(prAdapter, prMsduInfo->ucStaRecIndex);
3239 if (IS_STA_P2P_TYPE(prStaRec)) {
3240 DBGLOG(P2P, TRACE, ("Generate NULL P2P IE for Assoc Rsp.\n"));
3242 p2pFuncGenerateP2P_IE(prAdapter,
3244 &prMsduInfo->u2FrameLength,
3245 prMsduInfo->prPacket,
3247 txAssocRspAttributesTable,
3248 sizeof(txAssocRspAttributesTable)/sizeof(APPEND_VAR_ATTRI_ENTRY_T));
3252 DBGLOG(P2P, TRACE, ("Legacy device, no P2P IE.\n"));
3259 } /* p2pFuncGenerateP2p_IEForAssocRsp */
3263 p2pFuncCalculateWSC_IELenForAssocRsp (
3264 IN P_ADAPTER_T prAdapter,
3265 IN ENUM_NETWORK_TYPE_INDEX_T eNetTypeIndex,
3266 IN P_STA_RECORD_T prStaRec
3269 DBGLOG(P2P, TRACE, ("p2pFuncCalculateWSC_IELenForAssocRsp\n"));
3270 if (eNetTypeIndex != NETWORK_TYPE_P2P_INDEX) {
3274 return kalP2PCalWSC_IELen(prAdapter->prGlueInfo, 0);
3275 } /* p2pFuncCalculateP2p_IELenForAssocRsp */
3279 p2pFuncGenerateWSC_IEForAssocRsp (
3280 IN P_ADAPTER_T prAdapter,
3281 IN P_MSDU_INFO_T prMsduInfo
3285 UINT_16 u2IELen = 0;
3289 if (prMsduInfo->ucNetworkType != NETWORK_TYPE_P2P_INDEX) {
3292 DBGLOG(P2P, TRACE, ("p2pFuncGenerateWSC_IEForAssocRsp\n"));
3294 u2IELen = (UINT_16)kalP2PCalWSC_IELen(prAdapter->prGlueInfo, 0);
3296 pucBuffer = (PUINT_8)((UINT_32)prMsduInfo->prPacket +
3297 (UINT_32)prMsduInfo->u2FrameLength);
3301 // TODO: Check P2P FSM State.
3302 kalP2PGenWSC_IE(prAdapter->prGlueInfo,
3306 prMsduInfo->u2FrameLength += u2IELen;
3310 /* p2pFuncGenerateP2p_IEForAssocRsp */
3316 p2pFuncCalculateP2P_IELen (
3317 IN P_ADAPTER_T prAdapter,
3318 IN ENUM_NETWORK_TYPE_INDEX_T eNetTypeIndex,
3319 IN P_STA_RECORD_T prStaRec,
3320 IN APPEND_VAR_ATTRI_ENTRY_T arAppendAttriTable[],
3321 IN UINT_32 u4AttriTableSize
3325 UINT_32 u4OverallAttriLen, u4Dummy;
3326 UINT_16 u2EstimatedFixedAttriLen;
3330 /* Overall length of all Attributes */
3331 u4OverallAttriLen = 0;
3333 for (i = 0; i < u4AttriTableSize; i++) {
3334 u2EstimatedFixedAttriLen = arAppendAttriTable[i].u2EstimatedFixedAttriLen;
3336 if (u2EstimatedFixedAttriLen) {
3337 u4OverallAttriLen += u2EstimatedFixedAttriLen;
3340 ASSERT(arAppendAttriTable[i].pfnCalculateVariableAttriLen);
3342 u4OverallAttriLen +=
3343 arAppendAttriTable[i].pfnCalculateVariableAttriLen(prAdapter, prStaRec);
3347 u4Dummy = u4OverallAttriLen;
3348 u4OverallAttriLen += P2P_IE_OUI_HDR;
3350 for (;(u4Dummy > P2P_MAXIMUM_ATTRIBUTE_LEN);) {
3351 u4OverallAttriLen += P2P_IE_OUI_HDR;
3352 u4Dummy -= P2P_MAXIMUM_ATTRIBUTE_LEN;
3355 return u4OverallAttriLen;
3356 } /* p2pFuncCalculateP2P_IELen */
3360 p2pFuncGenerateP2P_IE (
3361 IN P_ADAPTER_T prAdapter,
3362 IN BOOLEAN fgIsAssocFrame,
3363 IN PUINT_16 pu2Offset,
3365 IN UINT_16 u2BufSize,
3366 IN APPEND_VAR_ATTRI_ENTRY_T arAppendAttriTable[],
3367 IN UINT_32 u4AttriTableSize
3370 PUINT_8 pucBuffer = (PUINT_8)NULL;
3371 P_IE_P2P_T prIeP2P = (P_IE_P2P_T)NULL;
3372 UINT_32 u4OverallAttriLen;
3374 UINT_8 aucWfaOui[] = VENDOR_OUI_WFA_SPECIFIC;
3375 UINT_8 aucTempBuffer[P2P_MAXIMUM_ATTRIBUTE_LEN];
3380 ASSERT_BREAK((prAdapter != NULL) && (pucBuf != NULL));
3382 pucBuffer = (PUINT_8)((UINT_32)pucBuf + (*pu2Offset));
3384 ASSERT_BREAK(pucBuffer != NULL);
3386 /* Check buffer length is still enough. */
3387 ASSERT_BREAK((u2BufSize - (*pu2Offset)) >= P2P_IE_OUI_HDR);
3389 prIeP2P = (P_IE_P2P_T)pucBuffer;
3391 prIeP2P->ucId = ELEM_ID_P2P;
3393 prIeP2P->aucOui[0] = aucWfaOui[0];
3394 prIeP2P->aucOui[1] = aucWfaOui[1];
3395 prIeP2P->aucOui[2] = aucWfaOui[2];
3396 prIeP2P->ucOuiType = VENDOR_OUI_TYPE_P2P;
3398 (*pu2Offset) += P2P_IE_OUI_HDR;
3400 /* Overall length of all Attributes */
3401 u4OverallAttriLen = 0;
3404 for (i = 0; i < u4AttriTableSize; i++) {
3406 if (arAppendAttriTable[i].pfnAppendAttri) {
3407 u4AttriLen = arAppendAttriTable[i].pfnAppendAttri(prAdapter, fgIsAssocFrame, pu2Offset, pucBuf, u2BufSize);
3409 u4OverallAttriLen += u4AttriLen;
3411 if (u4OverallAttriLen > P2P_MAXIMUM_ATTRIBUTE_LEN) {
3412 u4OverallAttriLen -= P2P_MAXIMUM_ATTRIBUTE_LEN;
3414 prIeP2P->ucLength = (VENDOR_OUI_TYPE_LEN + P2P_MAXIMUM_ATTRIBUTE_LEN);
3416 pucBuffer = (PUINT_8)((UINT_32)prIeP2P + (VENDOR_OUI_TYPE_LEN + P2P_MAXIMUM_ATTRIBUTE_LEN));
3418 prIeP2P = (P_IE_P2P_T)((UINT_32)prIeP2P +
3419 (ELEM_HDR_LEN + (VENDOR_OUI_TYPE_LEN + P2P_MAXIMUM_ATTRIBUTE_LEN)));
3421 kalMemCopy(aucTempBuffer, pucBuffer, u4OverallAttriLen);
3423 prIeP2P->ucId = ELEM_ID_P2P;
3425 prIeP2P->aucOui[0] = aucWfaOui[0];
3426 prIeP2P->aucOui[1] = aucWfaOui[1];
3427 prIeP2P->aucOui[2] = aucWfaOui[2];
3428 prIeP2P->ucOuiType = VENDOR_OUI_TYPE_P2P;
3430 kalMemCopy(prIeP2P->aucP2PAttributes, aucTempBuffer, u4OverallAttriLen);
3431 (*pu2Offset) += P2P_IE_OUI_HDR;
3438 prIeP2P->ucLength = (UINT_8)(VENDOR_OUI_TYPE_LEN + u4OverallAttriLen);
3444 } /* p2pFuncGenerateP2P_IE */
3447 p2pFuncAppendAttriStatusForAssocRsp (
3448 IN P_ADAPTER_T prAdapter,
3449 IN BOOLEAN fgIsAssocFrame,
3450 IN PUINT_16 pu2Offset,
3452 IN UINT_16 u2BufSize
3456 P_P2P_ATTRI_STATUS_T prAttriStatus;
3457 P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T)NULL;
3458 UINT_32 u4AttriLen = 0;
3463 prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
3465 if (fgIsAssocFrame) {
3469 // TODO: For assoc request P2P IE check in driver & return status in P2P IE.
3471 pucBuffer = (PUINT_8)((UINT_32)pucBuf +
3472 (UINT_32)(*pu2Offset));
3475 prAttriStatus = (P_P2P_ATTRI_STATUS_T)pucBuffer;
3477 ASSERT(u2BufSize >= ((*pu2Offset) + (UINT_16)u4AttriLen));
3482 prAttriStatus->ucId = P2P_ATTRI_ID_STATUS;
3483 WLAN_SET_FIELD_16(&prAttriStatus->u2Length, P2P_ATTRI_MAX_LEN_STATUS);
3485 prAttriStatus->ucStatusCode = P2P_STATUS_FAIL_PREVIOUS_PROTOCOL_ERR;
3487 u4AttriLen = (P2P_ATTRI_HDR_LEN + P2P_ATTRI_MAX_LEN_STATUS);
3489 (*pu2Offset) += (UINT_16)u4AttriLen;
3492 } /* p2pFuncAppendAttriStatusForAssocRsp */
3495 p2pFuncAppendAttriExtListenTiming (
3496 IN P_ADAPTER_T prAdapter,
3497 IN BOOLEAN fgIsAssocFrame,
3498 IN PUINT_16 pu2Offset,
3500 IN UINT_16 u2BufSize
3503 UINT_32 u4AttriLen = 0;
3504 P_P2P_ATTRI_EXT_LISTEN_TIMING_T prP2pExtListenTiming = (P_P2P_ATTRI_EXT_LISTEN_TIMING_T)NULL;
3505 P_P2P_SPECIFIC_BSS_INFO_T prP2pSpecificBssInfo = (P_P2P_SPECIFIC_BSS_INFO_T)NULL;
3506 PUINT_8 pucBuffer = NULL;
3511 if (fgIsAssocFrame) {
3515 // TODO: For extend listen timing.
3517 prP2pSpecificBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;
3519 u4AttriLen = (P2P_ATTRI_HDR_LEN + P2P_ATTRI_MAX_LEN_EXT_LISTEN_TIMING);
3521 ASSERT(u2BufSize >= ((*pu2Offset) + (UINT_16)u4AttriLen));
3523 pucBuffer = (PUINT_8)((UINT_32)pucBuf +
3524 (UINT_32)(*pu2Offset));
3528 prP2pExtListenTiming = (P_P2P_ATTRI_EXT_LISTEN_TIMING_T)pucBuffer;
3530 prP2pExtListenTiming->ucId = P2P_ATTRI_ID_EXT_LISTEN_TIMING;
3531 WLAN_SET_FIELD_16(&prP2pExtListenTiming->u2Length, P2P_ATTRI_MAX_LEN_EXT_LISTEN_TIMING);
3532 WLAN_SET_FIELD_16(&prP2pExtListenTiming->u2AvailInterval, prP2pSpecificBssInfo->u2AvailabilityInterval);
3533 WLAN_SET_FIELD_16(&prP2pExtListenTiming->u2AvailPeriod, prP2pSpecificBssInfo->u2AvailabilityPeriod);
3535 (*pu2Offset) += (UINT_16)u4AttriLen;
3538 } /* p2pFuncAppendAttriExtListenTiming */
3543 IN P_ADAPTER_T prAdapter,
3544 IN PUINT_8 pucIEBuf,
3545 IN UINT_16 u2BufferLen,
3547 IN PBOOLEAN pfgIsMore
3550 P_IE_HDR_T prTargetIE = (P_IE_HDR_T)NULL;
3551 PUINT_8 pucIE = (PUINT_8)NULL;
3552 UINT_16 u2Offset = 0;
3559 ASSERT_BREAK((prAdapter != NULL)
3560 && (pucIEBuf != NULL));
3564 IE_FOR_EACH(pucIE, u2BufferLen, u2Offset) {
3565 if (IE_ID(pucIE) == ucElemID) {
3566 if ((prTargetIE) && (pfgIsMore)) {
3572 prTargetIE = (P_IE_HDR_T)pucIE;
3574 if (pfgIsMore == NULL) {
3586 } /* p2pFuncGetSpecIE */
3591 p2pFuncGetSpecAttri (
3592 IN P_ADAPTER_T prAdapter,
3593 IN UINT_8 ucOuiType,
3594 IN PUINT_8 pucIEBuf,
3595 IN UINT_16 u2BufferLen,
3596 IN UINT_16 u2AttriID
3599 P_IE_P2P_T prP2pIE = (P_IE_P2P_T)NULL;
3600 P_ATTRIBUTE_HDR_T prTargetAttri = (P_ATTRIBUTE_HDR_T)NULL;
3601 BOOLEAN fgIsMore = FALSE;
3602 PUINT_8 pucIE = (PUINT_8)NULL, pucAttri = (PUINT_8)NULL;
3603 UINT_16 u2OffsetAttri = 0;
3604 UINT_16 u2BufferLenLeft = 0;
3605 UINT_8 aucWfaOui[] = VENDOR_OUI_WFA_SPECIFIC;
3608 DBGLOG(P2P, INFO, ("Check AssocReq Oui type %u attri %u for len %u\n",ucOuiType, u2AttriID, u2BufferLen));
3611 ASSERT_BREAK((prAdapter != NULL)
3612 && (pucIEBuf != NULL));
3614 u2BufferLenLeft = u2BufferLen;
3618 prP2pIE = (P_IE_P2P_T)p2pFuncGetSpecIE(prAdapter,
3626 ASSERT(prP2pIE>pucIE);
3628 u2BufferLenLeft = u2BufferLen - (UINT_16)( ((UINT_32)prP2pIE) - ((UINT_32)pucIEBuf));
3630 DBGLOG(P2P, INFO, ("Find vendor id %u len %u oui %u more %u LeftLen %u\n",
3631 IE_ID(prP2pIE), IE_LEN(prP2pIE), prP2pIE->ucOuiType, fgIsMore, u2BufferLenLeft));
3633 if(IE_LEN(prP2pIE) > P2P_OUI_TYPE_LEN) {
3635 if (prP2pIE->ucOuiType == ucOuiType) {
3636 switch (ucOuiType) {
3637 case VENDOR_OUI_TYPE_WPS:
3638 aucWfaOui[0] = 0x00;
3639 aucWfaOui[1] = 0x50;
3640 aucWfaOui[2] = 0xF2;
3642 case VENDOR_OUI_TYPE_P2P:
3644 case VENDOR_OUI_TYPE_WPA:
3645 case VENDOR_OUI_TYPE_WMM:
3646 case VENDOR_OUI_TYPE_WFD:
3652 if ((prP2pIE->aucOui[0] == aucWfaOui[0])
3653 && (prP2pIE->aucOui[1] == aucWfaOui[1])
3654 && (prP2pIE->aucOui[2] == aucWfaOui[2])
3658 pucAttri = prP2pIE->aucP2PAttributes;
3660 if (ucOuiType == VENDOR_OUI_TYPE_WPS) {
3661 WSC_ATTRI_FOR_EACH(pucAttri, (IE_LEN(prP2pIE) - P2P_OUI_TYPE_LEN), u2OffsetAttri) {
3662 //LOG_FUNC("WSC: attri id=%u len=%u\n",WSC_ATTRI_ID(pucAttri), WSC_ATTRI_LEN(pucAttri));
3663 if (WSC_ATTRI_ID(pucAttri) == u2AttriID) {
3664 prTargetAttri = (P_ATTRIBUTE_HDR_T)pucAttri;
3672 else if (ucOuiType == VENDOR_OUI_TYPE_P2P) {
3673 P2P_ATTRI_FOR_EACH(pucAttri, (IE_LEN(prP2pIE) - P2P_OUI_TYPE_LEN), u2OffsetAttri) {
3674 //LOG_FUNC("P2P: attri id=%u len=%u\n",ATTRI_ID(pucAttri), ATTRI_LEN(pucAttri));
3675 if (ATTRI_ID(pucAttri) == (UINT_8)u2AttriID) {
3676 prTargetAttri = (P_ATTRIBUTE_HDR_T)pucAttri;
3683 else if (ucOuiType == VENDOR_OUI_TYPE_WFD) {
3684 WFD_ATTRI_FOR_EACH(pucAttri, (IE_LEN(prP2pIE) - P2P_OUI_TYPE_LEN), u2OffsetAttri) {
3685 //DBGLOG(P2P, INFO, ("WFD: attri id=%u len=%u\n",WFD_ATTRI_ID(pucAttri), WFD_ATTRI_LEN(pucAttri)));
3686 if (ATTRI_ID(pucAttri) == (UINT_8)u2AttriID) {
3687 prTargetAttri = (P_ATTRIBUTE_HDR_T)pucAttri;
3694 // Possible or else.
3699 } /* P2P_OUI_TYPE_LEN */
3701 pucIE = (PUINT_8)(((UINT_32)prP2pIE) + IE_SIZE(prP2pIE));
3705 } while (prP2pIE && fgIsMore && u2BufferLenLeft);
3709 return prTargetAttri;
3711 /* p2pFuncGetSpecAttri */
3715 p2pFuncGenerateBeaconProbeRsp (
3716 IN P_ADAPTER_T prAdapter,
3717 IN P_BSS_INFO_T prBssInfo,
3718 IN P_MSDU_INFO_T prMsduInfo,
3719 IN BOOLEAN fgIsProbeRsp
3722 WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
3723 P_WLAN_BEACON_FRAME_T prBcnFrame = (P_WLAN_BEACON_FRAME_T)NULL;
3724 // P_APPEND_VAR_IE_ENTRY_T prAppendIeTable = (P_APPEND_VAR_IE_ENTRY_T)NULL;
3729 ASSERT_BREAK((prAdapter != NULL) &&
3730 (prBssInfo != NULL) &&
3731 (prMsduInfo != NULL));
3736 // txProbeRspIETable
3740 prBcnFrame = (P_WLAN_BEACON_FRAME_T)prMsduInfo->prPacket;
3742 return nicUpdateBeaconIETemplate(prAdapter,
3743 IE_UPD_METHOD_UPDATE_ALL,
3744 NETWORK_TYPE_P2P_INDEX,
3745 prBssInfo->u2CapInfo,
3746 (PUINT_8)prBcnFrame->aucInfoElem,
3747 prMsduInfo->u2FrameLength - OFFSET_OF(WLAN_BEACON_FRAME_T, aucInfoElem));
3752 } /* p2pFuncGenerateBeaconProbeRsp */
3756 p2pFuncComposeBeaconProbeRspTemplate (
3757 IN P_ADAPTER_T prAdapter,
3758 IN PUINT_8 pucBcnBuffer,
3759 IN UINT_32 u4BcnBufLen,
3760 IN BOOLEAN fgIsProbeRsp,
3761 IN P_P2P_PROBE_RSP_UPDATE_INFO_T prP2pProbeRspInfo,
3762 IN BOOLEAN fgSynToFW
3765 WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
3766 P_MSDU_INFO_T prMsduInfo = (P_MSDU_INFO_T)NULL;
3767 P_WLAN_MAC_HEADER_T prWlanBcnFrame = (P_WLAN_MAC_HEADER_T)NULL;
3768 P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T)NULL;
3770 PUINT_8 pucBuffer = (PUINT_8)NULL;
3773 ASSERT_BREAK((prAdapter != NULL) && (pucBcnBuffer != NULL));
3775 prWlanBcnFrame = (P_WLAN_MAC_HEADER_T)pucBcnBuffer;
3777 if ((prWlanBcnFrame->u2FrameCtrl != MAC_FRAME_BEACON) && (!fgIsProbeRsp)) {
3778 rWlanStatus = WLAN_STATUS_INVALID_DATA;
3782 else if (prWlanBcnFrame->u2FrameCtrl != MAC_FRAME_PROBE_RSP) {
3783 rWlanStatus = WLAN_STATUS_INVALID_DATA;
3790 ASSERT_BREAK(prP2pProbeRspInfo != NULL);
3792 if (!prP2pProbeRspInfo->prProbeRspMsduTemplate) {
3793 cnmMgtPktFree(prAdapter, prP2pProbeRspInfo->prProbeRspMsduTemplate);
3796 prP2pProbeRspInfo->prProbeRspMsduTemplate = cnmMgtPktAlloc(prAdapter, u4BcnBufLen);
3798 prMsduInfo = prP2pProbeRspInfo->prProbeRspMsduTemplate;
3800 prMsduInfo->eSrc = TX_PACKET_MGMT;
3801 prMsduInfo->ucStaRecIndex = 0xFF;
3802 prMsduInfo->ucNetworkType = NETWORK_TYPE_P2P_INDEX;
3806 prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
3807 prMsduInfo = prP2pBssInfo->prBeacon;
3809 if (prMsduInfo == NULL) {
3810 rWlanStatus = WLAN_STATUS_FAILURE;
3814 if (u4BcnBufLen > (OFFSET_OF(WLAN_BEACON_FRAME_T, aucInfoElem[0]) + MAX_IE_LENGTH)) {
3815 /* Unexpected error, buffer overflow. */
3823 pucBuffer = (PUINT_8)((UINT_32)(prMsduInfo->prPacket) + MAC_TX_RESERVED_FIELD);
3825 kalMemCopy(pucBuffer, pucBcnBuffer, u4BcnBufLen);
3827 prMsduInfo->fgIs802_11 = TRUE;
3828 prMsduInfo->u2FrameLength = (UINT_16)u4BcnBufLen;
3831 rWlanStatus = p2pFuncGenerateBeaconProbeRsp(prAdapter, prP2pBssInfo, prMsduInfo, fgIsProbeRsp);
3838 } /* p2pFuncComposeBeaconTemplate */
3841 WLAN_STATUS wfdAdjustResource(
3842 IN P_ADAPTER_T prAdapter,
3846 /* The API shall be called in tx_thread */
3847 P_QUE_MGT_T prQM = &prAdapter->rQM;
3848 DBGLOG(P2P, INFO, ("wfdAdjustResource %d\n", fgEnable));
3850 prQM->au4MinReservedTcResource[TC2_INDEX] = QM_GUARANTEED_TC2_RESOURCE;
3851 if(QM_GUARANTEED_TC0_RESOURCE>2) {
3852 prQM->au4GuaranteedTcResource[TC0_INDEX] = QM_GUARANTEED_TC0_RESOURCE - 2;
3853 prQM->au4GuaranteedTcResource[TC2_INDEX] += 2;
3855 if(QM_GUARANTEED_TC1_RESOURCE>2) {
3856 prQM->au4GuaranteedTcResource[TC1_INDEX] = QM_GUARANTEED_TC1_RESOURCE - 2;
3857 prQM->au4GuaranteedTcResource[TC2_INDEX] += 2;
3861 prQM->au4MinReservedTcResource[TC2_INDEX] = QM_MIN_RESERVED_TC2_RESOURCE;
3862 prQM->au4GuaranteedTcResource[TC0_INDEX] = QM_GUARANTEED_TC0_RESOURCE;
3863 prQM->au4GuaranteedTcResource[TC1_INDEX] = QM_GUARANTEED_TC1_RESOURCE;
3864 prQM->au4GuaranteedTcResource[TC2_INDEX] = QM_GUARANTEED_TC2_RESOURCE;
3867 return WLAN_STATUS_SUCCESS;
3870 WLAN_STATUS wfdAdjustThread(
3871 IN P_ADAPTER_T prAdapter,
3874 #define WFD_TX_THREAD_PRIORITY 70
3875 DBGLOG(P2P, INFO, ("wfdAdjustResource %d\n", fgEnable));
3878 /* TODO the change schedule API shall be provided by OS glue layer */
3879 /* Or the API shall be put in os glue layer */
3880 struct sched_param param = { .sched_priority = WFD_TX_THREAD_PRIORITY };
3881 sched_setscheduler(prAdapter->prGlueInfo->main_thread , SCHED_RR, ¶m);
3886 /* TODO the change schedule API shall be provided by OS glue layer */
3887 struct sched_param param = { .sched_priority = 0 };
3888 sched_setscheduler(prAdapter->prGlueInfo->main_thread , SCHED_NORMAL, ¶m);
3891 return WLAN_STATUS_SUCCESS;
3895 #endif /* CFG_SUPPORT_WFD */
3897 WLAN_STATUS wfdChangeMediaState(
3898 IN P_ADAPTER_T prAdapter,
3899 IN ENUM_NETWORK_TYPE_INDEX_T eNetworkTypeIdx,
3900 ENUM_PARAM_MEDIA_STATE_T eConnectionState) {
3903 P_WFD_CFG_SETTINGS_T prWfdCfgSettings = (P_WFD_CFG_SETTINGS_T)NULL;
3904 prWfdCfgSettings = &prAdapter->rWifiVar.prP2pFsmInfo->rWfdConfigureSettings;
3906 if ((prWfdCfgSettings->ucWfdEnable) &&
3907 ((prWfdCfgSettings->u4WfdFlag & WFD_FLAGS_DEV_INFO_VALID))) {
3909 if(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX].eConnectionState == PARAM_MEDIA_STATE_CONNECTED ) {
3910 wfdAdjustResource(prAdapter, TRUE);
3911 wfdAdjustThread(prAdapter, TRUE);
3914 wfdAdjustResource(prAdapter, FALSE);
3915 wfdAdjustThread(prAdapter, FALSE);
3920 return WLAN_STATUS_SUCCESS;
3932 p2pFuncIsChannelGrant (
3933 IN P_ADAPTER_T prAdapter
3936 P_P2P_FSM_INFO_T prP2pFsmInfo = (P_P2P_FSM_INFO_T)NULL;
3938 if (prAdapter == NULL)
3941 prP2pFsmInfo = prAdapter->rWifiVar.prP2pFsmInfo;
3944 if (prP2pFsmInfo == NULL)
3947 return (prP2pFsmInfo->eCurrentState == P2P_STATE_CHNL_ON_HAND);
3949 } /* p2pFuncIsChannelGrant */