drivers/net/wireless/combo_mt66xx/mt6628/wlan/mgmt/p2p_func.c

   1 #include "precomp.h"
   2
   3 #ifdef __GNUC__
   4 #pragma GCC diagnostic ignored "-Wformat"
   5 #endif
   6
   7
   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 */
  11 };
  12
  13
  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 */
  24 };
  25
  26 /*----------------------------------------------------------------------------*/
  27 /*!
  28 * @brief Function for requesting scan. There is an option to do ACTIVE or PASSIVE scan.
  29 *
  30 * @param eScanType - Specify the scan type of the scan request. It can be an ACTIVE/PASSIVE
  31 *                                  Scan.
  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)
  38 *
  39 *
  40 * @return (none)
  41 */
  42 /*----------------------------------------------------------------------------*/
  43 VOID
  44 p2pFuncRequestScan (
  45     IN P_ADAPTER_T prAdapter,
  46     IN P_P2P_SCAN_REQ_INFO_T prScanReqInfo
  47     )
  48 {
  49
  50     P_MSG_SCN_SCAN_REQ prScanReq = (P_MSG_SCN_SCAN_REQ)NULL;
  51
  52     DEBUGFUNC("p2pFuncRequestScan()");
  53
  54     do {
  55         ASSERT_BREAK((prAdapter != NULL) &&
  56                         (prScanReqInfo != NULL));
  57
  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));
  61         }
  62
  63         prScanReq = (P_MSG_SCN_SCAN_REQ)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_SCN_SCAN_REQ));
  64         if (!prScanReq) {
  65             ASSERT(0); // Can't trigger SCAN FSM
  66             break;
  67         }
  68
  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;
  75
  76         /* Copy IE for Probe Request. */
  77         kalMemCopy(prScanReq->aucIE, prScanReqInfo->aucIEBuf, prScanReqInfo->u4BufLength);
  78         prScanReq->u2IELen = (UINT_16)prScanReqInfo->u4BufLength;
  79
  80         prScanReq->u2ChannelDwellTime = prScanReqInfo->u2PassiveDewellTime;
  81
  82         switch (prScanReqInfo->eChannelSet) {
  83         case SCAN_CHANNEL_SPECIFIED:
  84             {
  85                 UINT_32 u4Idx = 0;
  86                 P_RF_CHANNEL_INFO_T prDomainInfo = (P_RF_CHANNEL_INFO_T)prScanReqInfo->arScanChannelList;
  87
  88                 if (prScanReqInfo->ucNumChannelList > MAXIMUM_OPERATION_CHANNEL_LIST) {
  89                     prScanReqInfo->ucNumChannelList = MAXIMUM_OPERATION_CHANNEL_LIST;
  90                 }
  91
  92
  93                 for (u4Idx = 0; u4Idx < prScanReqInfo->ucNumChannelList; u4Idx++) {
  94                     prScanReq->arChnlInfoList[u4Idx].ucChannelNum = prDomainInfo->ucChannelNum;
  95                     prScanReq->arChnlInfoList[u4Idx].eBand = prDomainInfo->eBand;
  96                     prDomainInfo++;
  97                 }
  98
  99                 prScanReq->ucChannelListNum = prScanReqInfo->ucNumChannelList;
 100             }
 101         case SCAN_CHANNEL_FULL:
 102         case SCAN_CHANNEL_2G4:
 103         case SCAN_CHANNEL_P2P_SOCIAL:
 104             {
 105                 UINT_8 aucP2pSsid[] = P2P_WILDCARD_SSID;
 106
 107                 COPY_SSID(prScanReq->aucSSID,
 108                                     prScanReq->ucSSIDLength,
 109                                     prScanReqInfo->rSsidStruct.aucSsid,
 110                                     prScanReqInfo->rSsidStruct.ucSsidLen);
 111
 112                 /* For compatible. */
 113                 if (EQUAL_SSID(aucP2pSsid, P2P_WILDCARD_SSID_LEN, prScanReq->aucSSID, prScanReq->ucSSIDLength)) {
 114                     prScanReq->ucSSIDType = SCAN_REQ_SSID_P2P_WILDCARD;
 115                 }
 116                 else if (prScanReq->ucSSIDLength != 0) {
 117                     prScanReq->ucSSIDType = SCAN_REQ_SSID_SPECIFIED;
 118                 }
 119             }
 120             break;
 121         default:
 122             /* Currently there is no other scan channel set. */
 123             ASSERT(FALSE);
 124             break;
 125         }
 126
 127         mboxSendMsg(prAdapter,
 128                     MBOX_ID_0,
 129                     (P_MSG_HDR_T)prScanReq,
 130                     MSG_SEND_METHOD_BUF);
 131
 132     } while (FALSE);
 133
 134     return;
 135 } /* p2pFuncRequestScan */
 136
 137 VOID
 138 p2pFuncCancelScan (
 139     IN P_ADAPTER_T prAdapter,
 140     IN P_P2P_SCAN_REQ_INFO_T prScanInfo
 141     )
 142 {
 143     P_MSG_SCN_SCAN_CANCEL prScanCancelMsg = (P_MSG_SCN_SCAN_CANCEL)NULL;
 144
 145     do {
 146         ASSERT_BREAK((prAdapter != NULL) && (prScanInfo != NULL));
 147
 148         if (!prScanInfo->fgIsScanRequest) {
 149             break;
 150         }
 151
 152
 153         if (prScanInfo->ucSeqNumOfScnMsg) {
 154             /* There is a channel privilege on hand. */
 155             DBGLOG(P2P, TRACE, ("P2P Cancel Scan\n"));
 156
 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"));
 161                 ASSERT(FALSE);
 162                 break;
 163             }
 164
 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;
 170
 171             mboxSendMsg(prAdapter,
 172                                 MBOX_ID_0,
 173                                 (P_MSG_HDR_T)prScanCancelMsg,
 174                                 MSG_SEND_METHOD_BUF);
 175
 176
 177         }
 178
 179
 180     } while (FALSE);
 181
 182     return;
 183 } /* p2pFuncCancelScan */
 184
 185
 186 VOID
 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
 192     )
 193 {
 194     do {
 195         ASSERT_BREAK((prAdapter != NULL) &&
 196                                             (prP2pBssInfo != NULL) &&
 197                                             (eOpMode < OP_MODE_NUM));
 198
 199         if (prP2pBssInfo->eCurrentOPMode != eOpMode) {
 200             DBGLOG(P2P, TRACE, ("p2pFuncSwitchOPMode: Switch to from %d, to %d.\n", prP2pBssInfo->eCurrentOPMode, eOpMode));
 201
 202             switch (prP2pBssInfo->eCurrentOPMode) {
 203             case OP_MODE_ACCESS_POINT:
 204                 p2pFuncDissolve(prAdapter, prP2pBssInfo, TRUE, REASON_CODE_DEAUTH_LEAVING_BSS);
 205
 206                 p2pFsmRunEventStopAP(prAdapter, NULL);
 207                 break;
 208             default:
 209                 break;
 210             }
 211
 212
 213             prP2pBssInfo->eIntendOPMode = eOpMode;
 214             prP2pBssInfo->eCurrentOPMode = eOpMode;
 215             switch (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);
 222 //                }
 223
 224                 /* Change interface address. */
 225                 if (eOpMode == OP_MODE_ACCESS_POINT) {
 226                     DBGLOG(P2P, TRACE, ("p2pFuncSwitchOPMode: Switch to AP.\n"));
 227                     prP2pBssInfo->ucSSIDLen = 0;
 228                 }
 229
 230                 COPY_MAC_ADDR(prP2pBssInfo->aucOwnMacAddr, prAdapter->rWifiVar.aucInterfaceAddress);
 231                 COPY_MAC_ADDR(prP2pBssInfo->aucBSSID, prAdapter->rWifiVar.aucInterfaceAddress);
 232
 233
 234                 break;
 235             case OP_MODE_P2P_DEVICE:
 236                 {
 237                     /* Change device address. */
 238                     DBGLOG(P2P, TRACE, ("p2pFuncSwitchOPMode: Switch back to P2P Device.\n"));
 239
 240 //                    if (!IS_BSS_ACTIVE(prP2pBssInfo)) {
 241 //                        SET_NET_ACTIVE(prAdapter, NETWORK_TYPE_P2P_INDEX);
 242 //                        nicActivateNetwork(prAdapter, NETWORK_TYPE_P2P_INDEX);
 243 //                    }
 244
 245                     p2pChangeMediaState(prAdapter, PARAM_MEDIA_STATE_DISCONNECTED);
 246
 247                     COPY_MAC_ADDR(prP2pBssInfo->aucOwnMacAddr, prAdapter->rWifiVar.aucDeviceAddress);
 248                     COPY_MAC_ADDR(prP2pBssInfo->aucBSSID, prAdapter->rWifiVar.aucDeviceAddress);
 249
 250
 251                 }
 252                 break;
 253             default:
 254 //                if (IS_BSS_ACTIVE(prP2pBssInfo)) {
 255 //                    UNSET_NET_ACTIVE(prAdapter, NETWORK_TYPE_P2P_INDEX);
 256
 257 //                    nicDeactivateNetwork(prAdapter, NETWORK_TYPE_P2P_INDEX);
 258 //                }
 259                 ASSERT(FALSE);
 260                 break;
 261             }
 262
 263             if (1) {
 264                 P2P_DISCONNECT_INFO rP2PDisInfo;
 265
 266                 rP2PDisInfo.ucRole = 2;
 267                 wlanSendSetQueryCmd(prAdapter,
 268                                 CMD_ID_P2P_ABORT,
 269                                 TRUE,
 270                                 FALSE,
 271                                 FALSE,
 272                                 NULL,
 273                                 NULL,
 274                                 sizeof(P2P_DISCONNECT_INFO),
 275                                 (PUINT_8)&rP2PDisInfo,
 276                                 NULL,
 277                                 0);
 278             }
 279
 280
 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)));
 283
 284             /* Update BSS INFO to FW. */
 285             if ((fgSyncToFW) && (eOpMode != OP_MODE_ACCESS_POINT)) {
 286                 nicUpdateBss(prAdapter, NETWORK_TYPE_P2P_INDEX);
 287             }
 288         }
 289
 290     } while (FALSE);
 291
 292     return;
 293 } /* p2pFuncSwitchOPMode */
 294
 295
 296
 297 /*----------------------------------------------------------------------------*/
 298 /*!
 299 * @brief This function will start a P2P Group Owner and send Beacon Frames.
 300 *
 301 * @param (none)
 302 *
 303 * @return (none)
 304 */
 305 /*----------------------------------------------------------------------------*/
 306 VOID
 307 p2pFuncStartGO (
 308     IN P_ADAPTER_T prAdapter,
 309     IN P_BSS_INFO_T prBssInfo,
 310     IN PUINT_8 pucSsidBuf,
 311     IN UINT_8 ucSsidLen,
 312     IN UINT_8 ucChannelNum,
 313     IN ENUM_BAND_T eBand,
 314     IN ENUM_CHNL_EXT_T eSco,
 315     IN BOOLEAN fgIsPureAP
 316     )
 317 {
 318     do {
 319         ASSERT_BREAK((prAdapter != NULL) && (prBssInfo != NULL));
 320
 321         ASSERT(prBssInfo->eCurrentOPMode == OP_MODE_ACCESS_POINT);
 322
 323         DBGLOG(P2P, TRACE, ("p2pFuncStartGO:\n"));
 324
 325         /* AP mode started. */
 326         p2pFuncSwitchOPMode(prAdapter, prBssInfo, prBssInfo->eIntendOPMode, FALSE);
 327
 328         prBssInfo->eIntendOPMode = OP_MODE_NUM;
 329
 330         //4 <1.1> Assign SSID
 331         COPY_SSID(prBssInfo->aucSSID,
 332                         prBssInfo->ucSSIDLen,
 333                         pucSsidBuf,
 334                         ucSsidLen);
 335
 336         DBGLOG(P2P, TRACE, ("GO SSID:%s \n", prBssInfo->aucSSID));
 337
 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;
 341
 342
 343         //4 <1.3> Setup Channel, Band and Phy Attributes
 344         prBssInfo->ucPrimaryChannel = ucChannelNum;
 345         prBssInfo->eBand = eBand;
 346         prBssInfo->eBssSCO = eSco;
 347
 348         DBGLOG(P2P, TRACE, ("GO Channel:%d \n", ucChannelNum));
 349
 350
 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 */
 354         }
 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 */
 358         }
 359         else {
 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 */
 362         }
 363
 364
 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;
 371
 372         if (prBssInfo->ucAllSupportedRatesLen == 0) {
 373             rateGetDataRatesFromRateSet(prBssInfo->u2OperationalRateSet,
 374                                         prBssInfo->u2BSSBasicRateSet,
 375                                         prBssInfo->aucAllSupportedRates,
 376                                         &prBssInfo->ucAllSupportedRatesLen);
 377         }
 378
 379         //4 <1.5> Setup MIB for current BSS
 380         prBssInfo->u2ATIMWindow = 0;
 381         prBssInfo->ucBeaconTimeoutCount = 0;
 382
 383         //3 <2> Update BSS_INFO_T common part
 384 #if CFG_SUPPORT_AAA
 385         if (!fgIsPureAP) {
 386             prBssInfo->fgIsProtection = TRUE; /* Always enable protection at P2P GO */
 387             kalP2PSetCipher(prAdapter->prGlueInfo, IW_AUTH_CIPHER_CCMP);
 388         }
 389         else {
 390             if (kalP2PGetCipher(prAdapter->prGlueInfo))
 391                 prBssInfo->fgIsProtection = TRUE;
 392         }
 393
 394         // 20120106 frog: I want separate OP_Mode & Beacon TX Function.
 395         //p2pFuncSwitchOPMode(prAdapter, prBssInfo, OP_MODE_ACCESS_POINT, FALSE);
 396
 397         bssInitForAP(prAdapter, prBssInfo, FALSE);
 398
 399         nicQmUpdateWmmParms(prAdapter, NETWORK_TYPE_P2P_INDEX);
 400 #endif /* CFG_SUPPORT_AAA */
 401
 402
 403         //3 <3> Set MAC HW
 404         //4 <3.1> Setup channel and bandwidth
 405         rlmBssInitForAPandIbss(prAdapter, prBssInfo);
 406
 407         //4 <3.2> Reset HW TSF Update Mode and Beacon Mode
 408         nicUpdateBss(prAdapter, NETWORK_TYPE_P2P_INDEX);
 409
 410         //4 <3.3> Update Beacon again for network phy type confirmed.
 411         bssUpdateBeaconContent(prAdapter, NETWORK_TYPE_P2P_INDEX);
 412
 413         //4 <3.4> Setup BSSID
 414         nicPmIndicateBssCreated(prAdapter, NETWORK_TYPE_P2P_INDEX);
 415
 416     } while (FALSE);
 417
 418     return;
 419 } /* p2pFuncStartGO() */
 420
 421
 422
 423
 424 /*----------------------------------------------------------------------------*/
 425 /*!
 426 * \brief    This function is to inform CNM that channel privilege
 427 *           has been released
 428 *
 429 * \param[in] prAdapter  Pointer of ADAPTER_T
 430 *
 431 * \return none
 432 */
 433 /*----------------------------------------------------------------------------*/
 434 VOID
 435 p2pFuncReleaseCh (
 436     IN P_ADAPTER_T prAdapter,
 437     IN P_P2P_CHNL_REQ_INFO_T prChnlReqInfo
 438     )
 439 {
 440     P_MSG_CH_ABORT_T prMsgChRelease = (P_MSG_CH_ABORT_T)NULL;
 441
 442     DEBUGFUNC("p2pFuncReleaseCh()");
 443
 444     do {
 445         ASSERT_BREAK((prAdapter != NULL) && (prChnlReqInfo != NULL));
 446
 447         if (!prChnlReqInfo->fgIsChannelRequested) {
 448             break;
 449         }
 450         else {
 451             DBGLOG(P2P, TRACE, ("P2P Release Channel\n"));
 452             prChnlReqInfo->fgIsChannelRequested = FALSE;
 453         }
 454
 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
 459             break;
 460         }
 461
 462         prMsgChRelease->rMsgHdr.eMsgId  = MID_MNY_CNM_CH_ABORT;
 463         prMsgChRelease->ucNetTypeIndex  = NETWORK_TYPE_P2P_INDEX;
 464         prMsgChRelease->ucTokenID       = prChnlReqInfo->ucSeqNumOfChReq++;
 465
 466         mboxSendMsg(prAdapter,
 467                     MBOX_ID_0,
 468                     (P_MSG_HDR_T) prMsgChRelease,
 469                     MSG_SEND_METHOD_BUF);
 470
 471     } while (FALSE);
 472
 473     return;
 474 } /* p2pFuncReleaseCh */
 475
 476
 477 /*----------------------------------------------------------------------------*/
 478 /*!
 479 * @brief Process of CHANNEL_REQ_JOIN Initial. Enter CHANNEL_REQ_JOIN State.
 480 *
 481 * @param (none)
 482 *
 483 * @return (none)
 484 */
 485 /*----------------------------------------------------------------------------*/
 486 VOID
 487 p2pFuncAcquireCh (
 488     IN P_ADAPTER_T prAdapter,
 489     IN P_P2P_CHNL_REQ_INFO_T prChnlReqInfo
 490     )
 491 {
 492     P_MSG_CH_REQ_T prMsgChReq = (P_MSG_CH_REQ_T)NULL;
 493
 494     do {
 495         ASSERT_BREAK((prAdapter != NULL) && (prChnlReqInfo != NULL));
 496
 497         p2pFuncReleaseCh(prAdapter, prChnlReqInfo);
 498
 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));
 501
 502         if (!prMsgChReq) {
 503             ASSERT(0); // Can't indicate CNM for channel acquiring
 504             break;
 505         }
 506
 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;
 512
 513         prMsgChReq->ucPrimaryChannel    = prChnlReqInfo->ucReqChnlNum;
 514         prMsgChReq->eRfSco              = prChnlReqInfo->eChnlSco;
 515         prMsgChReq->eRfBand             = prChnlReqInfo->eBand;
 516
 517         kalMemZero(prMsgChReq->aucBSSID, MAC_ADDR_LEN);
 518
 519         /* Channel request join BSSID. */
 520
 521         mboxSendMsg(prAdapter,
 522                     MBOX_ID_0,
 523                     (P_MSG_HDR_T) prMsgChReq,
 524                     MSG_SEND_METHOD_BUF);
 525
 526         prChnlReqInfo->fgIsChannelRequested = TRUE;
 527
 528     } while (FALSE);
 529
 530     return;
 531 } /* p2pFuncAcquireCh */
 532
 533 #if 0
 534 WLAN_STATUS
 535 p2pFuncBeaconUpdate(
 536     IN P_ADAPTER_T prAdapter,
 537     IN PUINT_8 pucBcnHdr,
 538     IN UINT_32 u4HdrLen,
 539     IN PUINT_8 pucBcnBody,
 540     IN UINT_32 u4BodyLen,
 541     IN UINT_32 u4DtimPeriod,
 542     IN UINT_32 u4BcnInterval)
 543 {
 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];
 551
 552     do {
 553         ASSERT_BREAK(prAdapter != NULL);
 554
 555         prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
 556         prBcnMsduInfo = prP2pBssInfo->prBeacon
 557
 558         ASSERT_BREAK(prBcnMsduInfo != NULL);
 559
 560         /* TODO: Find TIM IE pointer. */
 561         prBcnFrame = prBcnMsduInfo->prPacket;
 562
 563         ASSERT_BREAK(prBcnFrame != NULL);
 564
 565         do {
 566             /* Ori header. */
 567             UINT_16 u2IELength = 0, u2Offset = 0;
 568             PUINT_8 pucIEBuf = prBcnFrame->aucInfoElem;
 569
 570             u2IELength = prBcnMsduInfo->u2FrameLength - prBcnMsduInfo->ucMacHeaderLength;
 571
 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;
 576                     break
 577                 }
 578                 u2FrameLength += IE_SIZE(pucIEBuf);
 579             }
 580
 581             if (pucTIMBody == NULL) {
 582                 pucTIMBody = pucIEBuf;
 583             }
 584
 585              /* Body not change. */
 586             u2OldBodyLen = (UINT_16)((UINT_32)pucTIMBody - (UINT_32)prBcnFrame->aucInfoElem);
 587
 588             // Move body.
 589             kalMemCmp(aucIEBuf, pucTIMBody, u2OldBodyLen);
 590         } while (FALSE);
 591
 592
 593         if (pucBcnHdr) {
 594             kalMemCopy(prBcnMsduInfo->prPacket, pucBcnHdr, u4HdrLen);
 595
 596             pucTIMBody = (PUINT_8)((UINT_32)prBcnMsduInfo->prPacket + u4HdrLen);
 597
 598             prBcnMsduInfo->ucMacHeaderLength = (WLAN_MAC_MGMT_HEADER_LEN +
 599                 (TIMESTAMP_FIELD_LEN + BEACON_INTERVAL_FIELD_LEN + CAP_INFO_FIELD_LEN));
 600
 601             u2FrameLength = u4HdrLen; /* Header + Partial Body. */
 602
 603         }
 604         else {
 605             /* Header not change. */
 606             u2FrameLength += prBcnMsduInfo->ucMacHeaderLength;
 607         }
 608
 609
 610         if (pucBcnBody) {
 611             kalMemCopy(pucTIMBody, pucBcnBody, u4BodyLen);
 612             u2FrameLength += (UINT_16)u4BodyLen;
 613         }
 614         else {
 615             kalMemCopy(pucTIMBody, aucIEBuf, u2OldBodyLen);
 616             u2FrameLength += u2OldBodyLen;
 617         }
 618
 619         /* Frame Length */
 620         prBcnMsduInfo->u2FrameLength = u2FrameLength;
 621
 622         prBcnMsduInfo->fgIs802_11 = TRUE;
 623         prBcnMsduInfo->ucNetworkType = NETWORK_TYPE_P2P_INDEX;
 624
 625         prP2pBssInfo->u2BeaconInterval = (UINT_16)u4BcnInterval;
 626         prP2pBssInfo->ucDTIMPeriod = (UINT_8)u4DtimPeriod;
 627         prP2pBssInfo->u2CapInfo = prBcnFrame->u2CapInfo;
 628         prBcnMsduInfo->ucPacketType = 3;
 629
 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));
 636
 637         if (prP2pBssInfo->eCurrentOPMode == OP_MODE_ACCESS_POINT) {
 638             /* AP is created, Beacon Update. */
 639             nicPmIndicateBssAbort(prAdapter, NETWORK_TYPE_P2P_INDEX);
 640
 641             nicPmIndicateBssCreated(prAdapter, NETWORK_TYPE_P2P_INDEX);
 642         }
 643
 644     } while (FALSE);
 645
 646     return rResultStatus;
 647 } /* p2pFuncBeaconUpdate */
 648
 649 #else
 650 WLAN_STATUS
 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
 659     )
 660 {
 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];
 666
 667     do {
 668         ASSERT_BREAK((prAdapter != NULL) &&
 669                 (prP2pBssInfo != NULL) &&
 670                 (prBcnUpdateInfo != NULL));
 671
 672         prBcnMsduInfo = prP2pBssInfo->prBeacon;
 673
 674 #if DBG
 675         if (prBcnUpdateInfo->pucBcnHdr != NULL) {
 676             ASSERT((UINT_32)prBcnUpdateInfo->pucBcnHdr == ((UINT_32)prBcnMsduInfo->prPacket + MAC_TX_RESERVED_FIELD));
 677         }
 678
 679         if (prBcnUpdateInfo->pucBcnBody != NULL) {
 680             ASSERT((UINT_32)prBcnUpdateInfo->pucBcnBody == ((UINT_32)prBcnUpdateInfo->pucBcnHdr + (UINT_32)prBcnUpdateInfo->u4BcnHdrLen));
 681         }
 682 #endif
 683         prBcnFrame = (P_WLAN_BEACON_FRAME_T)((UINT_32)prBcnMsduInfo->prPacket + MAC_TX_RESERVED_FIELD);
 684
 685         if (!pucNewBcnBody) {
 686             /* Old body. */
 687             pucNewBcnBody = prBcnUpdateInfo->pucBcnBody;
 688             ASSERT(u4NewBodyLen == 0);
 689             u4NewBodyLen = prBcnUpdateInfo->u4BcnBodyLen;
 690         }
 691         else {
 692             prBcnUpdateInfo->u4BcnBodyLen = u4NewBodyLen;
 693         }
 694
 695         /* Temp buffer body part. */
 696         kalMemCopy(aucIEBuf, pucNewBcnBody, u4NewBodyLen);
 697
 698         if (pucNewBcnHdr) {
 699             kalMemCopy(prBcnFrame, pucNewBcnHdr, u4NewHdrLen);
 700             prBcnUpdateInfo->pucBcnHdr = (PUINT_8)prBcnFrame;
 701             prBcnUpdateInfo->u4BcnHdrLen = u4NewHdrLen;
 702         }
 703
 704         pucIEBuf = (PUINT_8)((UINT_32)prBcnUpdateInfo->pucBcnHdr + (UINT_32)prBcnUpdateInfo->u4BcnHdrLen);
 705         kalMemCopy(pucIEBuf, aucIEBuf, u4NewBodyLen);
 706         prBcnUpdateInfo->pucBcnBody = pucIEBuf;
 707
 708         /* Frame Length */
 709         prBcnMsduInfo->u2FrameLength = (UINT_16)(prBcnUpdateInfo->u4BcnHdrLen + prBcnUpdateInfo->u4BcnBodyLen);
 710
 711         prBcnMsduInfo->ucPacketType = 3;
 712         prBcnMsduInfo->fgIs802_11 = TRUE;
 713         prBcnMsduInfo->ucNetworkType = NETWORK_TYPE_P2P_INDEX;
 714
 715
 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;
 720
 721         p2pFuncParseBeaconContent(prAdapter,
 722                             prP2pBssInfo,
 723                             (PUINT_8)prBcnFrame->aucInfoElem,
 724                             (prBcnMsduInfo->u2FrameLength - OFFSET_OF(WLAN_BEACON_FRAME_T, aucInfoElem)));
 725
 726 #if 1
 727         //bssUpdateBeaconContent(prAdapter, NETWORK_TYPE_P2P_INDEX);
 728 #else
 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)));
 735 #endif
 736     } while (FALSE);
 737
 738     return rWlanStatus;
 739 } /* p2pFuncBeaconUpdate */
 740
 741 #endif
 742
 743 // TODO: We do not apply IE in deauth frame set from upper layer now.
 744 WLAN_STATUS
 745 p2pFuncDeauth (
 746     IN P_ADAPTER_T prAdapter,
 747     IN PUINT_8 pucPeerMacAddr,
 748     IN UINT_16 u2ReasonCode,
 749     IN PUINT_8 pucIEBuf,
 750     IN UINT_16 u2IELen,
 751     IN BOOLEAN fgSendDeauth
 752     )
 753 {
 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;
 758
 759     do {
 760         ASSERT_BREAK((prAdapter != NULL) && (pucPeerMacAddr != NULL));
 761
 762         prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
 763
 764         prCliStaRec = cnmGetStaRecByAddress(prAdapter,
 765                                                     NETWORK_TYPE_P2P_INDEX,
 766                                                     pucPeerMacAddr);
 767
 768         switch (prP2pBssInfo->eCurrentOPMode) {
 769         case OP_MODE_ACCESS_POINT:
 770             {
 771                 P_LINK_T prStaRecOfClientList = (P_LINK_T)NULL;
 772                 P_LINK_ENTRY_T prLinkEntry = (P_LINK_ENTRY_T)NULL;
 773
 774                 prStaRecOfClientList = &(prP2pBssInfo->rStaRecOfClientList);
 775
 776                 LINK_FOR_EACH(prLinkEntry, prStaRecOfClientList) {
 777                     if ((UINT_32)prCliStaRec == (UINT_32)prLinkEntry) {
 778                         LINK_REMOVE_KNOWN_ENTRY(prStaRecOfClientList, &prCliStaRec->rLinkEntry);
 779                         fgIsStaFound = TRUE;
 780                         break;
 781                     }
 782                 }
 783
 784             }
 785             break;
 786         case OP_MODE_INFRASTRUCTURE:
 787             ASSERT(prCliStaRec == prP2pBssInfo->prStaRecOfAP);
 788             if (prCliStaRec != prP2pBssInfo->prStaRecOfAP) {
 789                 break;
 790             }
 791             prP2pBssInfo->prStaRecOfAP = NULL;
 792             fgIsStaFound = TRUE;
 793             break;
 794         default:
 795             break;
 796         }
 797
 798         if (fgIsStaFound) {
 799             p2pFuncDisconnect(prAdapter, prCliStaRec, fgSendDeauth, u2ReasonCode);
 800         }
 801
 802         rWlanStatus = WLAN_STATUS_SUCCESS;
 803     } while (FALSE);
 804
 805     return rWlanStatus;
 806 } /* p2pFuncDeauth */
 807
 808 // TODO: We do not apply IE in disassoc frame set from upper layer now.
 809 WLAN_STATUS
 810 p2pFuncDisassoc (
 811     IN P_ADAPTER_T prAdapter,
 812     IN PUINT_8 pucPeerMacAddr,
 813     IN UINT_16 u2ReasonCode,
 814     IN PUINT_8 pucIEBuf,
 815     IN UINT_16 u2IELen,
 816     IN BOOLEAN fgSendDisassoc
 817     )
 818 {
 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;
 823
 824     do {
 825         ASSERT_BREAK((prAdapter != NULL) && (pucPeerMacAddr != NULL));
 826
 827         prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
 828
 829         prCliStaRec = cnmGetStaRecByAddress(prAdapter,
 830                                                     NETWORK_TYPE_P2P_INDEX,
 831                                                     pucPeerMacAddr);
 832
 833         switch (prP2pBssInfo->eCurrentOPMode) {
 834         case OP_MODE_ACCESS_POINT:
 835             {
 836                 P_LINK_T prStaRecOfClientList = (P_LINK_T)NULL;
 837                 P_LINK_ENTRY_T prLinkEntry = (P_LINK_ENTRY_T)NULL;
 838
 839                 prStaRecOfClientList = &(prP2pBssInfo->rStaRecOfClientList);
 840
 841                 LINK_FOR_EACH(prLinkEntry, prStaRecOfClientList) {
 842                     if ((UINT_32)prCliStaRec == (UINT_32)prLinkEntry) {
 843                         LINK_REMOVE_KNOWN_ENTRY(prStaRecOfClientList, &prCliStaRec->rLinkEntry);
 844                         fgIsStaFound = TRUE;
 845                         //p2pFuncDisconnect(prAdapter, prCliStaRec, fgSendDisassoc, u2ReasonCode);
 846                         break;
 847                     }
 848                 }
 849
 850             }
 851             break;
 852         case OP_MODE_INFRASTRUCTURE:
 853             ASSERT(prCliStaRec == prP2pBssInfo->prStaRecOfAP);
 854             if (prCliStaRec != prP2pBssInfo->prStaRecOfAP) {
 855                 break;
 856             }
 857
 858             //p2pFuncDisconnect(prAdapter, prCliStaRec, fgSendDisassoc, u2ReasonCode);
 859             prP2pBssInfo->prStaRecOfAP = NULL;
 860             fgIsStaFound = TRUE;
 861             break;
 862         default:
 863             break;
 864         }
 865
 866         if (fgIsStaFound) {
 867
 868             p2pFuncDisconnect(prAdapter, prCliStaRec, fgSendDisassoc, u2ReasonCode);
 869             //20120830 moved into p2pFuncDisconnect().
 870             //cnmStaRecFree(prAdapter, prCliStaRec, TRUE);
 871
 872         }
 873
 874         rWlanStatus = WLAN_STATUS_SUCCESS;
 875     } while (FALSE);
 876
 877     return rWlanStatus;
 878 } /* p2pFuncDisassoc */
 879
 880 /*----------------------------------------------------------------------------*/
 881 /*!
 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
 885 *
 886 * @param[in] prAdapter   Pointer to the adapter structure.
 887 *
 888 * @return (none)
 889 */
 890 /*----------------------------------------------------------------------------*/
 891 VOID
 892 p2pFuncDissolve (
 893     IN P_ADAPTER_T prAdapter,
 894     IN P_BSS_INFO_T prP2pBssInfo,
 895     IN BOOLEAN fgSendDeauth,
 896     IN UINT_16 u2ReasonCode
 897     )
 898 {
 899     DEBUGFUNC("p2pFuncDissolve()");
 900
 901     do {
 902
 903         ASSERT_BREAK((prAdapter != NULL) && (prP2pBssInfo != NULL));
 904
 905         switch (prP2pBssInfo->eCurrentOPMode) {
 906         case OP_MODE_INFRASTRUCTURE:
 907             /* Reset station record status. */
 908             if (prP2pBssInfo->prStaRecOfAP) {
 909                 kalP2PGCIndicateConnectionStatus(prAdapter->prGlueInfo,
 910                                 NULL,
 911                                 NULL,
 912                                 0,
 913                                 REASON_CODE_DEAUTH_LEAVING_BSS);
 914
 915                 // 2012/02/14 frog: After formation before join group, prStaRecOfAP is NULL.
 916                 p2pFuncDisconnect(prAdapter,
 917                             prP2pBssInfo->prStaRecOfAP,
 918                             fgSendDeauth,
 919                             u2ReasonCode);
 920             }
 921
 922             /* Fix possible KE when RX Beacon & call nicPmIndicateBssConnected(). hit prStaRecOfAP == NULL. */
 923             p2pChangeMediaState(prAdapter, PARAM_MEDIA_STATE_DISCONNECTED);
 924
 925             prP2pBssInfo->prStaRecOfAP = NULL;
 926
 927             break;
 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.
 931               */
 932             {
 933                 P_LINK_T prStaRecOfClientList = (P_LINK_T)NULL;
 934
 935                 /* Send deauth. */
 936                 authSendDeauthFrame(prAdapter,
 937                                 NULL,
 938                                 (P_SW_RFB_T)NULL,
 939                                 u2ReasonCode,
 940                                 (PFN_TX_DONE_HANDLER)NULL);
 941
 942                 prStaRecOfClientList = &prP2pBssInfo->rStaRecOfClientList;
 943
 944                 while (!LINK_IS_EMPTY(prStaRecOfClientList)) {
 945                     P_STA_RECORD_T prCurrStaRec;
 946
 947                     LINK_REMOVE_HEAD(prStaRecOfClientList, prCurrStaRec, P_STA_RECORD_T);
 948
 949                     /* Indicate to Host. */
 950                     //kalP2PGOStationUpdate(prAdapter->prGlueInfo, prCurrStaRec, FALSE);
 951
 952                     p2pFuncDisconnect(prAdapter, prCurrStaRec, TRUE, u2ReasonCode);
 953
 954                 }
 955
 956             }
 957
 958             break;
 959         default:
 960             return;  // 20110420 -- alreay in Device Mode.
 961         }
 962
 963         /* Make the deauth frame send to FW ASAP. */
 964         wlanAcquirePowerControl(prAdapter);
 965         wlanProcessCommandQueue(prAdapter, &prAdapter->prGlueInfo->rCmdQueue);
 966         wlanReleasePowerControl(prAdapter);
 967
 968         kalMdelay(100);
 969
 970         /* Change Connection Status. */
 971         p2pChangeMediaState(prAdapter, PARAM_MEDIA_STATE_DISCONNECTED);
 972
 973     } while (FALSE);
 974
 975     return;
 976 } /* p2pFuncDissolve */
 977
 978
 979 /*----------------------------------------------------------------------------*/
 980 /*!
 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
 984 *
 985 * @param[in] prAdapter   Pointer to the adapter structure.
 986 *
 987 * @return (none)
 988 */
 989 /*----------------------------------------------------------------------------*/
 990 VOID
 991 p2pFuncDisconnect (
 992     IN P_ADAPTER_T prAdapter,
 993     IN P_STA_RECORD_T prStaRec,
 994     IN BOOLEAN fgSendDeauth,
 995     IN UINT_16 u2ReasonCode
 996     )
 997 {
 998     P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T)NULL;
 999     ENUM_PARAM_MEDIA_STATE_T eOriMediaStatus;
1000
1001     DBGLOG(P2P, TRACE, ("p2pFuncDisconnect()"));
1002
1003     do {
1004         ASSERT_BREAK((prAdapter != NULL) && (prStaRec != NULL));
1005
1006         prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
1007         eOriMediaStatus = prP2pBssInfo->eConnectionState;
1008
1009         /* Indicate disconnect. */
1010         // TODO:
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);
1016         }
1017
1018         if (fgSendDeauth) {
1019             /* Send deauth. */
1020             authSendDeauthFrame(prAdapter,
1021                         prStaRec,
1022                         (P_SW_RFB_T)NULL,
1023                         u2ReasonCode,
1024                         (PFN_TX_DONE_HANDLER)p2pFsmRunEventDeauthTxDone);
1025                     /* Change station state. */
1026             cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
1027
1028             /* Reset Station Record Status. */
1029             p2pFuncResetStaRecStatus(prAdapter, prStaRec);
1030
1031
1032         }
1033         else {
1034             /* Change station state. */
1035             cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
1036
1037             /* Reset Station Record Status. */
1038             p2pFuncResetStaRecStatus(prAdapter, prStaRec);
1039
1040             cnmStaRecFree(prAdapter, prStaRec, TRUE);
1041
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);
1046             }
1047
1048             if (eOriMediaStatus != prP2pBssInfo->eConnectionState) {
1049                 /* Update Disconnected state to FW. */
1050                 nicUpdateBss(prAdapter, NETWORK_TYPE_P2P_INDEX);
1051             }
1052
1053         }
1054
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);
1058
1059             /* Reset RLM related field of BSSINFO. */
1060             rlmBssAborted(prAdapter, prP2pBssInfo);
1061         }
1062
1063     } while (FALSE);
1064
1065     return;
1066
1067 } /* p2pFuncDisconnect */
1068
1069
1070
1071
1072
1073
1074 WLAN_STATUS
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,
1079     IN UINT_64 u8Cookie
1080     )
1081 {
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;
1086
1087     do {
1088         ASSERT_BREAK((prAdapter != NULL) && (prMgmtTxReqInfo != NULL));
1089
1090         if (prMgmtTxReqInfo->fgIsMgmtTxRequested) {
1091
1092             // 1. prMgmtTxReqInfo->prMgmtTxMsdu != NULL
1093             /* Packet on driver, not done yet, drop it. */
1094             if ((prTxMsduInfo = prMgmtTxReqInfo->prMgmtTxMsdu) != NULL) {
1095
1096                 kalP2PIndicateMgmtTxStatus(prAdapter->prGlueInfo,
1097                                 prMgmtTxReqInfo->u8Cookie,
1098                                 FALSE,
1099                                 prTxMsduInfo->prPacket,
1100                                 (UINT_32)prTxMsduInfo->u2FrameLength);
1101
1102                 // Leave it to TX Done handler.
1103                 //cnmMgtPktFree(prAdapter, prTxMsduInfo);
1104                 prMgmtTxReqInfo->prMgmtTxMsdu = NULL;
1105             }
1106
1107             // 2. prMgmtTxReqInfo->prMgmtTxMsdu == NULL
1108             /* Packet transmitted, wait tx done. (cookie issue) */
1109             // 20120105 frog - use another u8cookie to store this value.
1110
1111         }
1112
1113         ASSERT(prMgmtTxReqInfo->prMgmtTxMsdu == NULL);
1114
1115
1116
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;
1120
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);
1125             break;
1126         default:
1127             break;
1128         }
1129
1130
1131         prMgmtTxReqInfo->u8Cookie = u8Cookie;
1132         prMgmtTxReqInfo->prMgmtTxMsdu = prMgmtTxMsdu;
1133         prMgmtTxReqInfo->fgIsMgmtTxRequested = TRUE;
1134
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)));
1140         }
1141
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));
1149
1150         nicTxEnqueueMsdu(prAdapter, prMgmtTxMsdu);
1151
1152     } while (FALSE);
1153
1154     return rWlanStatus;
1155 } /* p2pFuncTxMgmtFrame */
1156
1157
1158
1159 VOID
1160 p2pFuncSetChannel (
1161     IN P_ADAPTER_T prAdapter,
1162     IN P_RF_CHANNEL_INFO_T prRfChannelInfo
1163     )
1164 {
1165     P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T)NULL;
1166
1167     do {
1168         ASSERT_BREAK((prAdapter != NULL) && (prRfChannelInfo != NULL));
1169
1170         prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
1171
1172         prP2pConnSettings->ucOperatingChnl = prRfChannelInfo->ucChannelNum;
1173         prP2pConnSettings->eBand = prRfChannelInfo->eBand;
1174
1175
1176     } while (FALSE);
1177
1178     return;
1179 }
1180 /* p2pFuncSetChannel */
1181
1182
1183
1184 /*----------------------------------------------------------------------------*/
1185 /*!
1186 * @brief Retry JOIN for AUTH_MODE_AUTO_SWITCH
1187 *
1188 * @param[in] prStaRec       Pointer to the STA_RECORD_T
1189 *
1190 * @retval TRUE      We will retry JOIN
1191 * @retval FALSE     We will not retry JOIN
1192 */
1193 /*----------------------------------------------------------------------------*/
1194 BOOLEAN
1195 p2pFuncRetryJOIN (
1196     IN P_ADAPTER_T prAdapter,
1197     IN P_STA_RECORD_T prStaRec,
1198     IN P_P2P_JOIN_INFO_T prJoinInfo
1199     )
1200 {
1201     P_MSG_JOIN_REQ_T prJoinReqMsg = (P_MSG_JOIN_REQ_T)NULL;
1202     BOOLEAN fgRetValue = FALSE;
1203
1204     do {
1205         ASSERT_BREAK((prAdapter != NULL) &&
1206                             (prStaRec != NULL) &&
1207                             (prJoinInfo != NULL));
1208
1209         /* Retry other AuthType if possible */
1210         if (!prJoinInfo->ucAvailableAuthTypes) {
1211             break;
1212         }
1213
1214         if (prJoinInfo->ucAvailableAuthTypes &
1215             (UINT_8)AUTH_TYPE_SHARED_KEY) {
1216
1217             DBGLOG(P2P, INFO, ("RETRY JOIN INIT: Retry Authentication with AuthType == SHARED_KEY.\n"));
1218
1219             prJoinInfo->ucAvailableAuthTypes &=
1220                 ~(UINT_8)AUTH_TYPE_SHARED_KEY;
1221
1222             prStaRec->ucAuthAlgNum = (UINT_8)AUTH_ALGORITHM_NUM_SHARED_KEY;
1223         }
1224         else {
1225             DBGLOG(P2P, ERROR, ("RETRY JOIN INIT: Retry Authentication with Unexpected AuthType.\n"));
1226             ASSERT(0);
1227             break;
1228         }
1229
1230         prJoinInfo->ucAvailableAuthTypes = 0; /* No more available Auth Types */
1231
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
1236             break;
1237         }
1238
1239         prJoinReqMsg->rMsgHdr.eMsgId = MID_P2P_SAA_FSM_START;
1240         prJoinReqMsg->ucSeqNum = ++prJoinInfo->ucSeqNumOfReqMsg;
1241         prJoinReqMsg->prStaRec = prStaRec;
1242
1243         mboxSendMsg(prAdapter,
1244                 MBOX_ID_0,
1245                 (P_MSG_HDR_T) prJoinReqMsg,
1246                 MSG_SEND_METHOD_BUF);
1247
1248
1249         fgRetValue = TRUE;
1250     } while (FALSE);
1251
1252     return fgRetValue;
1253
1254
1255
1256 }/* end of p2pFuncRetryJOIN() */
1257
1258
1259
1260
1261
1262 /*----------------------------------------------------------------------------*/
1263 /*!
1264 * @brief This function will update the contain of BSS_INFO_T for AIS network once
1265 *        the association was completed.
1266 *
1267 * @param[in] prStaRec               Pointer to the STA_RECORD_T
1268 * @param[in] prAssocRspSwRfb        Pointer to SW RFB of ASSOC RESP FRAME.
1269 *
1270 * @return (none)
1271 */
1272 /*----------------------------------------------------------------------------*/
1273 VOID
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
1279     )
1280 {
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;
1284     UINT_16 u2IELength;
1285     PUINT_8 pucIE;
1286
1287     DEBUGFUNC("p2pUpdateBssInfoForJOIN()");
1288
1289     ASSERT(prAdapter);
1290     ASSERT(prStaRec);
1291     ASSERT(prAssocRspSwRfb);
1292
1293     prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
1294     prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
1295     prAssocRspFrame = (P_WLAN_ASSOC_RSP_FRAME_T) prAssocRspSwRfb->pvHeader;
1296
1297     DBGLOG(P2P, INFO, ("Update P2P_BSS_INFO_T and apply settings to MAC\n"));
1298
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;
1302
1303     //4 <1.2> Setup SSID
1304     COPY_SSID(prP2pBssInfo->aucSSID,
1305               prP2pBssInfo->ucSSIDLen,
1306               prP2pConnSettings->aucSSID,
1307               prP2pConnSettings->ucSSIDLen);
1308
1309     if (prBssDesc == NULL) {
1310         /* Target BSS NULL. */
1311         DBGLOG(P2P, TRACE,("Target BSS NULL\n"));
1312         return;
1313     }
1314
1315
1316     if (UNEQUAL_MAC_ADDR(prBssDesc->aucBSSID, prAssocRspFrame->aucBSSID)) {
1317         ASSERT(FALSE);
1318     }
1319
1320     //4 <1.3> Setup Channel, Band
1321     prP2pBssInfo->ucPrimaryChannel = prBssDesc->ucChannelNum;
1322     prP2pBssInfo->eBand = prBssDesc->eBand;
1323
1324
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;
1329
1330     //4 <2.2> Setup Capability
1331     prP2pBssInfo->u2CapInfo = prStaRec->u2CapInfo; /* Use AP's Cap Info as BSS Cap Info */
1332
1333     if (prP2pBssInfo->u2CapInfo & CAP_INFO_SHORT_PREAMBLE) {
1334         prP2pBssInfo->fgIsShortPreambleAllowed = TRUE;
1335     }
1336     else {
1337         prP2pBssInfo->fgIsShortPreambleAllowed = FALSE;
1338     }
1339
1340     //4 <2.3> Setup PHY Attributes and Basic Rate Set/Operational Rate Set
1341     prP2pBssInfo->ucPhyTypeSet = prStaRec->ucDesiredPhyTypeSet;
1342
1343     prP2pBssInfo->ucNonHTBasicPhyType = prStaRec->ucNonHTBasicPhyType;
1344
1345     prP2pBssInfo->u2OperationalRateSet = prStaRec->u2OperationalRateSet;
1346     prP2pBssInfo->u2BSSBasicRateSet = prStaRec->u2BSSBasicRateSet;
1347
1348
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);
1352
1353
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;
1357
1358
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);
1362
1363     prP2pBssInfo->fgIsQBSS = prStaRec->fgIsQoS;
1364
1365     //3 <4> Update BSS_INFO_T from BSS_DESC_T
1366     ASSERT(prBssDesc);
1367
1368     prBssDesc->fgIsConnecting = FALSE;
1369     prBssDesc->fgIsConnected = TRUE;
1370
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;
1376
1377     prP2pBssInfo->ucBeaconTimeoutCount = AIS_BEACON_TIMEOUT_COUNT_INFRA;
1378
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()
1382      */
1383     rlmProcessAssocRsp(prAdapter, prAssocRspSwRfb, pucIE, u2IELength);
1384
1385     //4 <4.3> Sync with firmware for BSS-INFO
1386     nicUpdateBss(prAdapter, NETWORK_TYPE_P2P_INDEX);
1387
1388     //4 <4.4> *DEFER OPERATION* nicPmIndicateBssConnected() will be invoked
1389     //inside scanProcessBeaconAndProbeResp() after 1st beacon is received
1390
1391     return;
1392 } /* end of p2pUpdateBssInfoForJOIN() */
1393
1394
1395
1396 /*----------------------------------------------------------------------------*/
1397 /*!
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.
1401 *
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
1406 *
1407 * @retval TRUE      Reply the Auth
1408 * @retval FALSE     Don't reply the Auth
1409 */
1410 /*----------------------------------------------------------------------------*/
1411 BOOLEAN
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
1417     )
1418 {
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;
1423
1424    DBGLOG(P2P, TRACE, ("p2pValidate Authentication Frame\n"))
1425
1426     do {
1427         ASSERT_BREAK((prAdapter != NULL) &&
1428                                     (prSwRfb != NULL) &&
1429                                     (pprStaRec != NULL) &&
1430                                     (pu2StatusCode != NULL));
1431
1432         /* P2P 3.2.8 */
1433         *pu2StatusCode = STATUS_CODE_REQ_DECLINED;
1434
1435         prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
1436         prAuthFrame = (P_WLAN_AUTH_FRAME_T)prSwRfb->pvHeader;
1437
1438
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));
1443             break;
1444         }
1445
1446         prStaRec = cnmGetStaRecByAddress(prAdapter,
1447                             (UINT_8) NETWORK_TYPE_P2P_INDEX,
1448                             prAuthFrame->aucSrcAddr);
1449
1450         if (!prStaRec) {
1451             prStaRec = cnmStaRecAlloc(prAdapter,
1452                             (UINT_8) NETWORK_TYPE_P2P_INDEX);
1453
1454             /* TODO(Kevin): Error handling of allocation of STA_RECORD_T for
1455              * exhausted case and do removal of unused STA_RECORD_T.
1456              */
1457             /* Sent a message event to clean un-used STA_RECORD_T. */
1458             ASSERT(prStaRec);
1459
1460             COPY_MAC_ADDR(prStaRec->aucMacAddr, prAuthFrame->aucSrcAddr);
1461
1462             prSwRfb->ucStaRecIdx = prStaRec->ucIndex;
1463
1464             prStaRec->u2BSSBasicRateSet = prP2pBssInfo->u2BSSBasicRateSet;
1465
1466             prStaRec->u2DesiredNonHTRateSet = RATE_SET_ERP_P2P;
1467
1468             prStaRec->u2OperationalRateSet = RATE_SET_ERP_P2P;
1469             prStaRec->ucPhyTypeSet = PHY_TYPE_SET_802_11GN;
1470             prStaRec->eStaType = STA_TYPE_P2P_GC;
1471
1472             /* NOTE(Kevin): Better to change state here, not at TX Done */
1473             cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
1474         }
1475         else {
1476             prSwRfb->ucStaRecIdx = prStaRec->ucIndex;
1477
1478             if ((prStaRec->ucStaState > STA_STATE_1) && (IS_STA_IN_P2P(prStaRec))) {
1479
1480                 cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
1481
1482                 p2pFuncResetStaRecStatus(prAdapter, prStaRec);
1483
1484                 bssRemoveStaRecFromClientList(prAdapter, prP2pBssInfo, prStaRec);
1485             }
1486
1487         }
1488
1489         if (prP2pBssInfo->rStaRecOfClientList.u4NumElem > P2P_MAXIMUM_CLIENT_COUNT ||
1490             kalP2PMaxClients(prAdapter->prGlueInfo, prP2pBssInfo->rStaRecOfClientList.u4NumElem)) {
1491             /* GROUP limit full. */
1492             /* P2P 3.2.8 */
1493             DBGLOG(P2P, WARN, ("Group Limit Full. (%d)\n", (INT_16)prP2pBssInfo->rStaRecOfClientList.u4NumElem));
1494
1495                         bssRemoveStaRecFromClientList(prAdapter, prP2pBssInfo, prStaRec);
1496
1497                         cnmStaRecFree(prAdapter, prStaRec, FALSE);
1498             break;
1499         }
1500         else {
1501             /* Hotspot Blacklist */
1502             if(prAuthFrame->aucSrcAddr) {
1503                 if(kalP2PCmpBlackList(prAdapter->prGlueInfo, prAuthFrame->aucSrcAddr)) {
1504                     fgReplyAuth = FALSE;
1505                     return fgReplyAuth;
1506                 }
1507             }
1508         }
1509
1510         //prStaRec->eStaType = STA_TYPE_INFRA_CLIENT;
1511         prStaRec->eStaType = STA_TYPE_P2P_GC;
1512
1513         prStaRec->ucNetTypeIndex = NETWORK_TYPE_P2P_INDEX;
1514
1515         /* Update Station Record - Status/Reason Code */
1516         prStaRec->u2StatusCode = STATUS_CODE_SUCCESSFUL;
1517
1518         prStaRec->ucJoinFailureCount = 0;
1519
1520         *pprStaRec = prStaRec;
1521
1522         *pu2StatusCode = STATUS_CODE_SUCCESSFUL;
1523
1524     } while (FALSE);
1525
1526
1527     return fgReplyAuth;
1528
1529 } /* p2pFuncValidateAuth */
1530
1531
1532
1533
1534 VOID
1535 p2pFuncResetStaRecStatus (
1536     IN P_ADAPTER_T prAdapter,
1537     IN P_STA_RECORD_T prStaRec
1538     )
1539 {
1540     do {
1541         if ((prAdapter == NULL) || (prStaRec == NULL)) {
1542             ASSERT(FALSE);
1543             break;
1544         }
1545
1546
1547         prStaRec->u2StatusCode = STATUS_CODE_SUCCESSFUL;
1548         prStaRec->u2ReasonCode = REASON_CODE_RESERVED;
1549         prStaRec->ucJoinFailureCount = 0;
1550         prStaRec->fgTransmitKeyExist = FALSE;
1551
1552         prStaRec->fgSetPwrMgtBit = FALSE;
1553
1554     } while (FALSE);
1555
1556     return;
1557 } /* p2pFuncResetStaRecStatus */
1558
1559
1560
1561 /*----------------------------------------------------------------------------*/
1562 /*!
1563 * @brief The function is used to initialize the value of the connection settings for
1564 *        P2P network
1565 *
1566 * @param (none)
1567 *
1568 * @return (none)
1569 */
1570 /*----------------------------------------------------------------------------*/
1571 VOID
1572 p2pFuncInitConnectionSettings (
1573     IN P_ADAPTER_T prAdapter,
1574     IN P_P2P_CONNECTION_SETTINGS_T prP2PConnSettings
1575     )
1576 {
1577     P_DEVICE_TYPE_T prDevType;
1578     UINT_8 aucDefaultDevName[] = P2P_DEFAULT_DEV_NAME;
1579     UINT_8 aucWfaOui[] = VENDOR_OUI_WFA;
1580
1581     ASSERT(prP2PConnSettings);
1582
1583     /* Setup Default Device Name */
1584     prP2PConnSettings->ucDevNameLen = P2P_DEFAULT_DEV_NAME_LEN;
1585     kalMemCopy(prP2PConnSettings->aucDevName, aucDefaultDevName, sizeof(aucDefaultDevName));
1586
1587     /* Setup Primary Device Type (Big-Endian) */
1588     prDevType = &prP2PConnSettings->rPrimaryDevTypeBE;
1589
1590     prDevType->u2CategoryId = HTONS(P2P_DEFAULT_PRIMARY_CATEGORY_ID);
1591     prDevType->u2SubCategoryId = HTONS(P2P_DEFAULT_PRIMARY_SUB_CATEGORY_ID);
1592
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;
1597
1598     /* Setup Secondary Device Type */
1599     prP2PConnSettings->ucSecondaryDevTypeCount = 0;
1600
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;
1607
1608     /* For Device Capability */
1609     prP2PConnSettings->fgSupportServiceDiscovery = FALSE;
1610     prP2PConnSettings->fgSupportClientDiscoverability = TRUE;
1611     prP2PConnSettings->fgSupportConcurrentOperation = TRUE;
1612     prP2PConnSettings->fgSupportInfraManaged = FALSE;
1613     prP2PConnSettings->fgSupportInvitationProcedure = FALSE;
1614
1615     /* For Group Capability */
1616 #if CFG_SUPPORT_PERSISTENT_GROUP
1617     prP2PConnSettings->fgSupportPersistentP2PGroup = TRUE;
1618 #else
1619     prP2PConnSettings->fgSupportPersistentP2PGroup = FALSE;
1620 #endif
1621     prP2PConnSettings->fgSupportIntraBSSDistribution = TRUE;
1622     prP2PConnSettings->fgSupportCrossConnection = TRUE;
1623     prP2PConnSettings->fgSupportPersistentReconnect = FALSE;
1624
1625     prP2PConnSettings->fgSupportOppPS = FALSE;
1626     prP2PConnSettings->u2CTWindow = P2P_CTWINDOW_DEFAULT;
1627
1628     /* For Connection Settings. */
1629     prP2PConnSettings->eAuthMode = AUTH_MODE_OPEN;
1630
1631     prP2PConnSettings->prTargetP2pDesc = NULL;
1632     prP2PConnSettings->ucSSIDLen = 0;
1633
1634     /* Misc */
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);
1641
1642     prP2PConnSettings->eFormationPolicy = ENUM_P2P_FORMATION_POLICY_AUTO;
1643
1644     return;
1645 } /* p2pFuncInitConnectionSettings */
1646
1647
1648
1649
1650
1651 /*----------------------------------------------------------------------------*/
1652 /*!
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.
1656 *
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
1660 *
1661 * @retval TRUE      Reply the Assoc Resp
1662 * @retval FALSE     Don't reply the Assoc Resp
1663 */
1664 /*----------------------------------------------------------------------------*/
1665 BOOLEAN
1666 p2pFuncValidateAssocReq (
1667     IN P_ADAPTER_T prAdapter,
1668     IN P_SW_RFB_T prSwRfb,
1669     OUT PUINT_16 pu2StatusCode
1670     )
1671 {
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;
1676 #if CFG_SUPPORT_WFD
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;
1680 #endif
1681
1682
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.
1688      */
1689
1690     do {
1691         ASSERT_BREAK((prAdapter != NULL) &&
1692                                         (prSwRfb != NULL) &&
1693                                         (pu2StatusCode != NULL));
1694
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;
1698
1699         prStaRec = cnmGetStaRecByIndex(prAdapter, prSwRfb->ucStaRecIdx);
1700
1701         if (prStaRec == NULL) {
1702             /* Station record should be ready while RX AUTH frame. */
1703             fgReplyAssocResp = FALSE;
1704             ASSERT(FALSE);
1705             break;
1706         }
1707         else {
1708             prStaRec->ucRCPI = prSwRfb->prHifRxHdr->ucRcpi;
1709         }
1710
1711         prStaRec->u2DesiredNonHTRateSet &= prP2pBssInfo->u2OperationalRateSet;
1712         prStaRec->ucDesiredPhyTypeSet = prStaRec->ucPhyTypeSet & prP2pBssInfo->ucPhyTypeSet;
1713
1714         if (prStaRec->ucDesiredPhyTypeSet == 0) {
1715             /* The station only support 11B rate. */
1716             *pu2StatusCode = STATUS_CODE_ASSOC_DENIED_RATE_NOT_SUPPORTED;
1717             break;
1718         }
1719
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;
1724             ASSERT(FALSE);
1725             break;
1726         }
1727
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)) {
1734                 /* Rejected all. */
1735                 break;
1736             }
1737             else {
1738
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;
1742
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);
1749
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);
1756
1757                 if ((prWfdCfgSettings->u4WfdPolicy & BIT(5)) && (prAttriWfdDevInfo != NULL)) {
1758                     /* Rejected with WFD IE. */
1759                     break;
1760                 }
1761
1762                 if ((prWfdCfgSettings->u4WfdPolicy & BIT(0)) && (prAttriWfdDevInfo == NULL)) {
1763                     /* Rejected without WFD IE. */
1764                     break;
1765                 }
1766
1767                 if (prAttriWfdDevInfo != NULL) {
1768
1769                     //prAttriWfdDevInfo = (P_WFD_DEVICE_INFORMATION_IE_T)p2pFuncGetSpecAttri(prAdapter,
1770                     //                                                               VENDOR_OUI_TYPE_WFD,
1771                     //                                                                (PUINT_8)prWfdAttribute,
1772                     //                                                                u2AttriListLen,
1773                     //                                                                WFD_ATTRI_ID_DEV_INFO);
1774                     //if (prAttriWfdDevInfo == NULL) {
1775                     //    /* No such attribute. */
1776                     //    break;
1777                     //}
1778
1779                     WLAN_GET_FIELD_BE16(&prAttriWfdDevInfo->u2WfdDevInfo, &u2WfdDevInfo);
1780                     DBGLOG(P2P, INFO,("RX Assoc Req WFD Info:0x%x.\n", u2WfdDevInfo));
1781
1782                     if ((prWfdCfgSettings->u4WfdPolicy & BIT(1)) && ((u2WfdDevInfo & 0x3) == 0x0)) {
1783                         /* Rejected because of SOURCE. */
1784                         break;
1785                     }
1786
1787                     if ((prWfdCfgSettings->u4WfdPolicy & BIT(2)) && ((u2WfdDevInfo & 0x3) == 0x1)) {
1788                         /* Rejected because of Primary Sink. */
1789                         break;
1790                     }
1791
1792                     if ((prWfdCfgSettings->u4WfdPolicy & BIT(3)) && ((u2WfdDevInfo & 0x3) == 0x2)) {
1793                         /* Rejected because of Secondary Sink. */
1794                         break;
1795                     }
1796
1797                     if ((prWfdCfgSettings->u4WfdPolicy & BIT(4)) && ((u2WfdDevInfo & 0x3) == 0x3)) {
1798                         /* Rejected because of Source & Primary Sink. */
1799                         break;
1800                     }
1801
1802                     /* Check role */
1803
1804                     if(prWfdCfgSettings->u4WfdFlag & WFD_FLAGS_DEV_INFO_VALID) {
1805
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;
1809
1810                            /* We may change role here if we are dual role */
1811
1812                             if((u2WfdDevInfo & BITS(0,1)) == 0x00 /* Peer is Source*/) {
1813                                 DBGLOG(P2P, INFO,("WFD: Switch role to primary sink\n"));
1814
1815                                 prWfdCfgSettings->u2WfdDevInfo &= ~BITS(0,1);
1816                                 prWfdCfgSettings->u2WfdDevInfo |= 0x1;
1817
1818                                 /* event to annonce the role is chanaged to P-Sink */
1819
1820                             }
1821                             else if((u2WfdDevInfo & BITS(0,1)) == 0x01 /* Peer is P-Sink */) {
1822
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 */
1826                            }
1827                            else {
1828
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 */
1833                            }
1834
1835                             p2pFsmRunEventWfdSettingUpdate (prAdapter,NULL);
1836
1837                         } /* Dual role p2p->wfd_params->WfdDevInfo */
1838                     } /* WFD_FLAG_DEV_INFO_VALID */
1839
1840
1841                 }
1842                 else {
1843                     /* Without WFD IE.
1844                                      * Do nothing. Accept the connection request.
1845                                      */
1846                 }
1847             }
1848
1849         } /* ucWfdEnable */
1850
1851 #endif
1852
1853         *pu2StatusCode = STATUS_CODE_SUCCESSFUL;
1854
1855     } while (FALSE);
1856
1857 #if CFG_SUPPORT_WFD
1858     if ((prWfdAttribute) && (fgNeedFree)) {
1859         kalMemFree(prWfdAttribute, VIR_MEM_TYPE, WPS_MAXIMUM_ATTRIBUTES_CACHE_SIZE);
1860     }
1861 #endif
1862
1863     return fgReplyAssocResp;
1864
1865 } /* p2pFuncValidateAssocReq */
1866
1867
1868
1869
1870 /*----------------------------------------------------------------------------*/
1871 /*!
1872 * @brief This function is used to check the P2P IE
1873 *
1874 *
1875 * @return none
1876 */
1877 /*----------------------------------------------------------------------------*/
1878 BOOLEAN
1879 p2pFuncParseCheckForP2PInfoElem (
1880     IN  P_ADAPTER_T prAdapter,
1881     IN  PUINT_8 pucBuf,
1882     OUT PUINT_8 pucOuiType
1883     )
1884 {
1885     UINT_8 aucWfaOui[] = VENDOR_OUI_WFA_SPECIFIC;
1886     P_IE_WFA_T prWfaIE = (P_IE_WFA_T)NULL;
1887
1888     do {
1889         ASSERT_BREAK((prAdapter != NULL) && (pucBuf != NULL) && (pucOuiType != NULL));
1890
1891         prWfaIE = (P_IE_WFA_T)pucBuf;
1892
1893         if (IE_LEN(pucBuf) <= ELEM_MIN_LEN_WFA_OUI_TYPE_SUBTYPE) {
1894             break;
1895         }
1896         else if (prWfaIE->aucOui[0] != aucWfaOui[0] ||
1897                  prWfaIE->aucOui[1] != aucWfaOui[1] ||
1898                  prWfaIE->aucOui[2] != aucWfaOui[2]) {
1899             break;
1900         }
1901
1902         *pucOuiType = prWfaIE->ucOuiType;
1903
1904         return TRUE;
1905     } while (FALSE);
1906
1907     return FALSE;
1908 } /* p2pFuncParseCheckForP2PInfoElem */
1909
1910
1911
1912
1913 /*----------------------------------------------------------------------------*/
1914 /*!
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.
1918 *
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
1922 *
1923 * @retval TRUE      Reply the Probe Response
1924 * @retval FALSE     Don't reply the Probe Response
1925 */
1926 /*----------------------------------------------------------------------------*/
1927 BOOLEAN
1928 p2pFuncValidateProbeReq (
1929     IN P_ADAPTER_T prAdapter,
1930     IN P_SW_RFB_T prSwRfb,
1931     OUT PUINT_32 pu4ControlFlags
1932     )
1933 {
1934     BOOLEAN fgIsReplyProbeRsp = FALSE;
1935     P_P2P_FSM_INFO_T prP2pFsmInfo = (P_P2P_FSM_INFO_T)NULL;
1936
1937     DEBUGFUNC("p2pFuncValidateProbeReq");
1938         DBGLOG(P2P, TRACE, ("p2pFuncValidateProbeReq\n"));
1939
1940     do {
1941
1942         ASSERT_BREAK((prAdapter != NULL) && (prSwRfb != NULL));
1943
1944         prP2pFsmInfo = prAdapter->rWifiVar.prP2pFsmInfo;
1945
1946         if (prP2pFsmInfo->u4P2pPacketFilter & PARAM_PACKET_FILTER_PROBE_REQ) {
1947
1948                         printk("p2pFuncValidateProbeReq\n");
1949
1950                         /* Leave the probe response to p2p_supplicant. */
1951             kalP2PIndicateRxMgmtFrame(prAdapter->prGlueInfo, prSwRfb);
1952         }
1953
1954     } while (FALSE);
1955
1956     return fgIsReplyProbeRsp;
1957
1958 } /* end of p2pFuncValidateProbeReq() */
1959
1960
1961
1962 /*----------------------------------------------------------------------------*/
1963 /*!
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.
1967 *
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
1971 *
1972 * @retval TRUE      Reply the Probe Response
1973 * @retval FALSE     Don't reply the Probe Response
1974 */
1975 /*----------------------------------------------------------------------------*/
1976 VOID
1977 p2pFuncValidateRxActionFrame (
1978     IN P_ADAPTER_T prAdapter,
1979     IN P_SW_RFB_T prSwRfb
1980     )
1981 {
1982     P_P2P_FSM_INFO_T prP2pFsmInfo = (P_P2P_FSM_INFO_T)NULL;
1983
1984     DEBUGFUNC("p2pFuncValidateProbeReq");
1985
1986     do {
1987
1988         ASSERT_BREAK((prAdapter != NULL) && (prSwRfb != NULL));
1989
1990         prP2pFsmInfo = prAdapter->rWifiVar.prP2pFsmInfo;
1991
1992         if (prP2pFsmInfo->u4P2pPacketFilter & PARAM_PACKET_FILTER_ACTION_FRAME) {
1993             /* Leave the probe response to p2p_supplicant. */
1994             kalP2PIndicateRxMgmtFrame(prAdapter->prGlueInfo, prSwRfb);
1995         }
1996
1997     } while (FALSE);
1998
1999     return;
2000
2001 } /* p2pFuncValidateRxMgmtFrame */
2002
2003
2004
2005 BOOLEAN
2006 p2pFuncIsAPMode (
2007     IN P_P2P_FSM_INFO_T prP2pFsmInfo
2008     )
2009 {
2010     if (prP2pFsmInfo) {
2011         if(prP2pFsmInfo->fgIsWPSMode == 1){
2012             return FALSE;
2013         }
2014         return prP2pFsmInfo->fgIsApMode;
2015     }
2016     else {
2017         return FALSE;
2018     }
2019 }
2020 /* p2pFuncIsAPMode */
2021
2022
2023
2024 VOID
2025 p2pFuncParseBeaconContent (
2026     IN P_ADAPTER_T prAdapter,
2027     IN P_BSS_INFO_T prP2pBssInfo,
2028     IN PUINT_8 pucIEInfo,
2029     IN UINT_32 u4IELen
2030     )
2031 {
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;
2037
2038     do {
2039         ASSERT_BREAK((prAdapter != NULL) &&
2040                         (prP2pBssInfo != NULL));
2041
2042         if (u4IELen == 0) {
2043             break;
2044         }
2045
2046         prP2pSpecificBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;
2047         prP2pSpecificBssInfo->u2AttributeLen = 0;
2048
2049         ASSERT_BREAK(pucIEInfo != NULL);
2050
2051         pucIE = pucIEInfo;
2052
2053         ucOldSecMode = kalP2PGetCipher(prAdapter->prGlueInfo);
2054
2055         IE_FOR_EACH(pucIE, u4IELen, u2Offset) {
2056             switch (IE_ID(pucIE)) {
2057             case ELEM_ID_SSID:   /* 0 */ /* V */ /* Done */
2058                 {
2059                     DBGLOG(P2P, TRACE, ("SSID update\n"));
2060
2061                     /* Update when starting GO. */
2062                     COPY_SSID(prP2pBssInfo->aucSSID,
2063                                                 prP2pBssInfo->ucSSIDLen,
2064                                                 SSID_IE(pucIE)->aucSSID,
2065                                                 SSID_IE(pucIE)->ucLength);
2066
2067                     COPY_SSID(prP2pSpecificBssInfo->aucGroupSsid,
2068                                                 prP2pSpecificBssInfo->u2GroupSsidLen,
2069                                                 SSID_IE(pucIE)->aucSSID,
2070                                                 SSID_IE(pucIE)->ucLength);
2071
2072                 }
2073                 break;
2074             case ELEM_ID_SUP_RATES:  /* 1 */ /* V */ /* Done */
2075                 {
2076                     DBGLOG(P2P, TRACE, ("Support Rate IE\n"));
2077                     kalMemCopy(prP2pBssInfo->aucAllSupportedRates,
2078                                     SUP_RATES_IE(pucIE)->aucSupportedRates,
2079                                     SUP_RATES_IE(pucIE)->ucLength);
2080
2081                     prP2pBssInfo->ucAllSupportedRatesLen = SUP_RATES_IE(pucIE)->ucLength;
2082
2083                     DBGLOG_MEM8(P2P, TRACE, SUP_RATES_IE(pucIE)->aucSupportedRates, SUP_RATES_IE(pucIE)->ucLength);
2084                 }
2085                 break;
2086             case ELEM_ID_DS_PARAM_SET: /* 3 */ /* V */ /* Done */
2087                 {
2088                     P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
2089
2090                     DBGLOG(P2P, TRACE, ("DS PARAM IE\n"));
2091
2092                     ASSERT(prP2pConnSettings->ucOperatingChnl == DS_PARAM_IE(pucIE)->ucCurrChnl);
2093
2094                     if (prP2pConnSettings->eBand != BAND_2G4) {
2095                         ASSERT(FALSE);
2096                         break;
2097                     }
2098
2099                     //prP2pBssInfo->ucPrimaryChannel = DS_PARAM_IE(pucIE)->ucCurrChnl;
2100
2101                     //prP2pBssInfo->eBand = BAND_2G4;
2102                 }
2103                 break;
2104             case ELEM_ID_TIM: /* 5 */ /* V */
2105                 DBGLOG(P2P, TRACE, ("TIM IE\n"));
2106                 TIM_IE(pucIE)->ucDTIMPeriod = prP2pBssInfo->ucDTIMPeriod;
2107                 break;
2108             case ELEM_ID_ERP_INFO:  /* 42 */    /* V */
2109                 {
2110 #if 1
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));
2114
2115 #else
2116                     /* This IE would dynamic change due to FW detection change is required. */
2117                     DBGLOG(P2P, TRACE, ("ERP IE.\n"));
2118
2119                     prP2pBssInfo->ucPhyTypeSet |= PHY_TYPE_SET_802_11GN;
2120
2121                     ASSERT(prP2pBssInfo->eBand == BAND_2G4);
2122
2123                     prP2pBssInfo->fgObssErpProtectMode = ((ERP_INFO_IE(pucIE)->ucERP & ERP_INFO_USE_PROTECTION)? TRUE : FALSE);
2124
2125                     prP2pBssInfo->fgErpProtectMode = ((ERP_INFO_IE(pucIE)->ucERP & (ERP_INFO_USE_PROTECTION | ERP_INFO_NON_ERP_PRESENT))? TRUE : FALSE);
2126 #endif
2127
2128                 }
2129                 break;
2130             case ELEM_ID_HT_CAP:    /* 45 */    /* V */
2131                 {
2132 #if 1
2133                     DBGLOG(P2P, TRACE, ("HT CAP IE would be overwritten by driver\n"));
2134
2135                     DBGLOG(P2P, TRACE, ("HT Cap Info:%x, AMPDU Param:%x\n", HT_CAP_IE(pucIE)->u2HtCapInfo, HT_CAP_IE(pucIE)->ucAmpduParam));
2136
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));
2141 #else
2142                     prP2pBssInfo->ucPhyTypeSet |= PHY_TYPE_SET_802_11N;
2143
2144                     /* u2HtCapInfo */
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;
2148                     }
2149                     else {
2150                         prP2pBssInfo->fgAssoc40mBwAllowed = TRUE;
2151                     }
2152
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;
2156                     }
2157                     else {
2158                         prAdapter->rWifiVar.rConnSettings.fgRxShortGIDisabled = FALSE;
2159                     }
2160
2161                     /* ucAmpduParam */
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));
2163
2164                     /* rSupMcsSet */
2165                     /* Can do nothing. the field is default value from other configuration. */
2166                     //HT_CAP_IE(pucIE)->rSupMcsSet;
2167
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)));
2170
2171                     /* u4TxBeamformingCap */
2172                     ASSERT(HT_CAP_IE(pucIE)->u4TxBeamformingCap == TX_BEAMFORMING_CAP_DEFAULT_VAL);
2173
2174                     /* ucAselCap */
2175                     ASSERT(HT_CAP_IE(pucIE)->ucAselCap == ASEL_CAP_DEFAULT_VAL);
2176 #endif
2177                 }
2178                 break;
2179             case ELEM_ID_RSN: /* 48 */  /* V */
2180                                 {
2181                                         RSN_INFO_T rRsnIe;
2182
2183                 DBGLOG(P2P, TRACE, ("RSN IE\n"));
2184                 kalP2PSetCipher(prAdapter->prGlueInfo, IW_AUTH_CIPHER_CCMP);
2185                 ucNewSecMode = TRUE;
2186
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;
2193                                         }
2194                 }
2195                 break;
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);
2202
2203                 DBGLOG_MEM8(P2P, TRACE, EXT_SUP_RATES_IE(pucIE)->aucExtSupportedRates, EXT_SUP_RATES_IE(pucIE)->ucLength);
2204
2205                 prP2pBssInfo->ucAllSupportedRatesLen += EXT_SUP_RATES_IE(pucIE)->ucLength;
2206                 break;
2207             case ELEM_ID_HT_OP: /* 61 */        /* V */   // TODO:
2208                 {
2209 #if 1
2210                     DBGLOG(P2P, TRACE, ("HT OP IE would be overwritten by driver\n"));
2211
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));
2217 #else
2218                     UINT_16 u2Info2 = 0;
2219                     prP2pBssInfo->ucPhyTypeSet |= PHY_TYPE_SET_802_11N;
2220
2221                     DBGLOG(P2P, TRACE, ("HT OP IE\n"));
2222
2223                     /* ucPrimaryChannel. */
2224                     ASSERT(HT_OP_IE(pucIE)->ucPrimaryChannel == prP2pBssInfo->ucPrimaryChannel);
2225
2226                     /* ucInfo1 */
2227                     prP2pBssInfo->ucHtOpInfo1 = HT_OP_IE(pucIE)->ucInfo1;
2228
2229                     /* u2Info2 */
2230                     u2Info2 = HT_OP_IE(pucIE)->u2Info2;
2231
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;
2235                     }
2236
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;
2240                     }
2241
2242                     switch (u2Info2 & HT_OP_INFO2_HT_PROTECTION) {
2243                     case HT_PROTECT_MODE_NON_HT:
2244                         prP2pBssInfo->eHtProtectMode = HT_PROTECT_MODE_NON_HT;
2245                         break;
2246                     case HT_PROTECT_MODE_NON_MEMBER:
2247                         prP2pBssInfo->eHtProtectMode = HT_PROTECT_MODE_NONE;
2248                         prP2pBssInfo->eObssHtProtectMode = HT_PROTECT_MODE_NON_MEMBER;
2249                         break;
2250                     default:
2251                         prP2pBssInfo->eHtProtectMode = HT_OP_IE(pucIE)->u2Info2;
2252                         break;
2253                     }
2254
2255                     /* u2Info3 */
2256                     prP2pBssInfo->u2HtOpInfo3 = HT_OP_IE(pucIE)->u2Info3;
2257
2258                     /* aucBasicMcsSet */
2259                     DBGLOG_MEM8(P2P, TRACE, HT_OP_IE(pucIE)->aucBasicMcsSet, 16);
2260 #endif
2261                 }
2262                 break;
2263             case ELEM_ID_OBSS_SCAN_PARAMS: /* 74 */     /* V */
2264                 {
2265                     DBGLOG(P2P, TRACE, ("ELEM_ID_OBSS_SCAN_PARAMS IE would be replaced by driver\n"));
2266                 }
2267                 break;
2268             case ELEM_ID_EXTENDED_CAP: /* 127 */  /* V */
2269                 {
2270                     DBGLOG(P2P, TRACE, ("ELEM_ID_EXTENDED_CAP IE would be replaced by driver\n"));
2271                 }
2272                 break;
2273             case ELEM_ID_VENDOR: /* 221 */ /* V */
2274                 DBGLOG(P2P, TRACE, ("Vender Specific IE\n"));
2275                 {
2276                     UINT_8 ucOuiType;
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;
2283                         }
2284                         else if ((ucOuiType == VENDOR_OUI_TYPE_WPS)) {
2285                             kalP2PUpdateWSC_IE(prAdapter->prGlueInfo, 0, pucIE, IE_SIZE(pucIE));
2286                         }
2287
2288                         // WMM here.
2289                     }
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],
2295                                             pucIE,
2296                                             IE_SIZE(pucIE));
2297
2298                             prP2pSpecificBssInfo->u2AttributeLen += IE_SIZE(pucIE);
2299                         }
2300                        else if(ucOuiType == VENDOR_OUI_TYPE_WFD) {
2301
2302                             kalMemCopy(&prP2pSpecificBssInfo->aucAttributesCache[prP2pSpecificBssInfo->u2AttributeLen],
2303                                             pucIE,
2304                                             IE_SIZE(pucIE));
2305
2306                             prP2pSpecificBssInfo->u2AttributeLen += IE_SIZE(pucIE);
2307                                                         }
2308                     }
2309                     else {
2310
2311                         kalMemCopy(&prP2pSpecificBssInfo->aucAttributesCache[prP2pSpecificBssInfo->u2AttributeLen],
2312                                             pucIE,
2313                                             IE_SIZE(pucIE));
2314
2315                         prP2pSpecificBssInfo->u2AttributeLen += IE_SIZE(pucIE);
2316                         DBGLOG(P2P, TRACE, ("Driver unprocessed Vender Specific IE\n"));
2317                         ASSERT(FALSE);
2318                     }
2319
2320                     // TODO: Store other Vender IE except for WMM Param.
2321                 }
2322                 break;
2323             default:
2324                 DBGLOG(P2P, TRACE, ("Unprocessed element ID:%d \n", IE_ID(pucIE)));
2325                 break;
2326             }
2327         }
2328
2329         if (!ucNewSecMode && ucOldSecMode)
2330             kalP2PSetCipher(prAdapter->prGlueInfo, IW_AUTH_CIPHER_NONE);
2331
2332     } while (FALSE);
2333
2334     return;
2335 } /* p2pFuncParseBeaconContent */
2336
2337
2338
2339
2340 P_BSS_DESC_T
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
2346     )
2347 {
2348     P_BSS_DESC_T prTargetBss = (P_BSS_DESC_T)NULL;
2349     P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T)NULL;
2350
2351     do {
2352         ASSERT_BREAK((prAdapter != NULL) &&
2353                 (prConnReqInfo != NULL) &&
2354                 (prChnlReqInfo != NULL) &&
2355                 (prScanReqInfo != NULL));
2356
2357         prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
2358
2359         if (prP2pBssInfo->eCurrentOPMode != OP_MODE_INFRASTRUCTURE) {
2360             break;
2361         }
2362
2363         // Update connection request information.
2364         ASSERT(prConnReqInfo->fgIsConnRequest == TRUE);
2365
2366         /* Find BSS Descriptor first. */
2367         prTargetBss =  scanP2pSearchDesc(prAdapter,
2368                                                                         prP2pBssInfo,
2369                                                                         prConnReqInfo);
2370
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;
2378         }
2379         else {
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;
2386         }
2387
2388     } while (FALSE);
2389
2390     return prTargetBss;
2391 } /* p2pFuncKeepOnConnection */
2392
2393 /* Currently Only for ASSOC Response Frame. */
2394 VOID
2395 p2pFuncStoreAssocRspIEBuffer (
2396     IN P_ADAPTER_T prAdapter,
2397     IN P_SW_RFB_T prSwRfb
2398     )
2399 {
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;
2403     INT_16 i2IELen = 0;
2404
2405     do {
2406         ASSERT_BREAK((prAdapter != NULL) && (prSwRfb != NULL));
2407
2408         prAssocRspFrame = (P_WLAN_ASSOC_RSP_FRAME_T)prSwRfb->pvHeader;
2409
2410         if (prAssocRspFrame->u2FrameCtrl != MAC_FRAME_ASSOC_RSP) {
2411             break;
2412         }
2413
2414         i2IELen = prSwRfb->u2PacketLen - (WLAN_MAC_HEADER_LEN +
2415                                                                     CAP_INFO_FIELD_LEN +
2416                                                                     STATUS_CODE_FIELD_LEN +
2417                                                                     AID_FIELD_LEN);
2418
2419
2420         if (i2IELen <= 0) {
2421             break;
2422         }
2423
2424         prP2pFsmInfo = prAdapter->rWifiVar.prP2pFsmInfo;
2425         prJoinInfo = &(prP2pFsmInfo->rJoinInfo);
2426         prJoinInfo->u4BufLength = (UINT_32)i2IELen;
2427
2428         kalMemCopy(prJoinInfo->aucIEBuf, prAssocRspFrame->aucInfoElem, prJoinInfo->u4BufLength);
2429
2430     } while (FALSE);
2431
2432
2433     return;
2434 } /* p2pFuncStoreAssocRspIEBuffer */
2435
2436
2437
2438
2439 /*----------------------------------------------------------------------------*/
2440 /*!
2441 * \brief This routine is called to set Packet Filter.
2442 *
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.
2450 *
2451 * \retval WLAN_STATUS_SUCCESS
2452 * \retval WLAN_STATUS_INVALID_LENGTH
2453 * \retval WLAN_STATUS_NOT_SUPPORTED
2454 * \retval WLAN_STATUS_ADAPTER_NOT_READY
2455 */
2456 /*----------------------------------------------------------------------------*/
2457 VOID
2458 p2pFuncMgmtFrameRegister (
2459     IN P_ADAPTER_T  prAdapter,
2460     IN  UINT_16 u2FrameType,
2461     IN BOOLEAN fgIsRegistered,
2462     OUT PUINT_32 pu4P2pPacketFilter
2463     )
2464 {
2465     UINT_32 u4NewPacketFilter = 0;
2466
2467     DEBUGFUNC("p2pFuncMgmtFrameRegister");
2468
2469     do {
2470         ASSERT_BREAK(prAdapter != NULL);
2471
2472         if (pu4P2pPacketFilter) {
2473             u4NewPacketFilter = *pu4P2pPacketFilter;
2474         }
2475
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"));
2481             }
2482             else {
2483                 u4NewPacketFilter &= ~PARAM_PACKET_FILTER_PROBE_REQ;
2484                 DBGLOG(P2P, TRACE, ("Close packet filer probe request\n"));
2485             }
2486             break;
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"));
2491             }
2492             else {
2493                 u4NewPacketFilter &= ~PARAM_PACKET_FILTER_ACTION_FRAME;
2494                 DBGLOG(P2P, TRACE, ("Close packet filer action frame.\n"));
2495             }
2496             break;
2497         default:
2498             DBGLOG(P2P, TRACE, ("Ask frog to add code for mgmt:%x\n", u2FrameType));
2499             break;
2500         }
2501
2502         if (pu4P2pPacketFilter) {
2503             *pu4P2pPacketFilter = u4NewPacketFilter;
2504         }
2505
2506 //        u4NewPacketFilter |= prAdapter->u4OsPacketFilter;
2507
2508         prAdapter->u4OsPacketFilter &= ~PARAM_PACKET_FILTER_P2P_MASK;
2509         prAdapter->u4OsPacketFilter |= u4NewPacketFilter;
2510
2511         DBGLOG(P2P, TRACE, ("P2P Set PACKET filter:0x%lx\n", prAdapter->u4OsPacketFilter));
2512
2513         wlanSendSetQueryCmd(prAdapter,
2514                 CMD_ID_SET_RX_FILTER,
2515                 TRUE,
2516                 FALSE,
2517                 FALSE,
2518                 nicCmdEventSetCommon,
2519                 nicOidCmdTimeoutCommon,
2520                 sizeof(UINT_32),
2521                 (PUINT_8)&prAdapter->u4OsPacketFilter,
2522                 &u4NewPacketFilter,
2523                 sizeof(u4NewPacketFilter)
2524                 );
2525
2526     } while (FALSE);
2527
2528     return;
2529 }   /* p2pFuncMgmtFrameRegister */
2530
2531
2532 VOID
2533 p2pFuncUpdateMgmtFrameRegister (
2534     IN P_ADAPTER_T prAdapter,
2535     IN UINT_32 u4OsFilter
2536     )
2537 {
2538
2539     do {
2540
2541         prAdapter->rWifiVar.prP2pFsmInfo->u4P2pPacketFilter = u4OsFilter;
2542
2543         if ((prAdapter->u4OsPacketFilter & PARAM_PACKET_FILTER_P2P_MASK) ^ u4OsFilter) {
2544
2545             prAdapter->u4OsPacketFilter &= ~PARAM_PACKET_FILTER_P2P_MASK;
2546
2547             prAdapter->u4OsPacketFilter |= (u4OsFilter & PARAM_PACKET_FILTER_P2P_MASK);
2548
2549             wlanSendSetQueryCmd(prAdapter,
2550                     CMD_ID_SET_RX_FILTER,
2551                     TRUE,
2552                     FALSE,
2553                     FALSE,
2554                     nicCmdEventSetCommon,
2555                     nicOidCmdTimeoutCommon,
2556                     sizeof(UINT_32),
2557                     (PUINT_8)&prAdapter->u4OsPacketFilter,
2558                     &u4OsFilter,
2559                     sizeof(u4OsFilter)
2560                     );
2561             DBGLOG(P2P, TRACE, ("P2P Set PACKET filter:0x%lx\n", prAdapter->u4OsPacketFilter));
2562         }
2563
2564     } while (FALSE);
2565
2566
2567
2568
2569     return;
2570 } /* p2pFuncUpdateMgmtFrameRegister */
2571
2572
2573 VOID
2574 p2pFuncGetStationInfo (
2575     IN P_ADAPTER_T prAdapter,
2576     IN PUINT_8 pucMacAddr,
2577     OUT P_P2P_STATION_INFO_T prStaInfo
2578     )
2579 {
2580
2581     do {
2582         ASSERT_BREAK((prAdapter != NULL) &&
2583                                     (pucMacAddr != NULL) &&
2584                                     (prStaInfo != NULL));
2585
2586         prStaInfo->u4InactiveTime = 0;
2587         prStaInfo->u4RxBytes = 0;
2588         prStaInfo->u4TxBytes = 0;
2589         prStaInfo->u4RxPackets = 0;
2590         prStaInfo->u4TxPackets = 0;
2591         // TODO:
2592
2593     } while (FALSE);
2594
2595     return;
2596 } /* p2pFuncGetStationInfo */
2597
2598
2599 BOOLEAN
2600 p2pFuncGetAttriList (
2601     IN P_ADAPTER_T prAdapter,
2602     IN UINT_8 ucOuiType,
2603     IN PUINT_8 pucIE,
2604     IN UINT_16 u2IELength,
2605     OUT PPUINT_8 ppucAttriList,
2606     OUT PUINT_16 pu2AttriListLen
2607     )
2608 {
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;
2616
2617     do {
2618         ASSERT_BREAK((prAdapter != NULL) &&
2619                         (pucIE != NULL) &&
2620                         (u2IELength != 0) &&
2621                         (ppucAttriList != NULL) &&
2622                         (pu2AttriListLen != NULL));
2623
2624         if(ppucAttriList) {
2625             *ppucAttriList = NULL;
2626         }
2627         if(pu2AttriListLen) {
2628             *pu2AttriListLen = 0;
2629         }
2630
2631         if (ucOuiType == VENDOR_OUI_TYPE_WPS){
2632             aucWfaOui[0] = 0x00;
2633             aucWfaOui[1] = 0x50;
2634             aucWfaOui[2] = 0xF2;
2635         }
2636         else if ((ucOuiType != VENDOR_OUI_TYPE_P2P)
2637 #if CFG_SUPPORT_WFD
2638                 && (ucOuiType != VENDOR_OUI_TYPE_WFD)
2639 #endif
2640                 ) {
2641             DBGLOG(P2P, INFO, ("Not supported OUI Type to parsing 0x%x\n", ucOuiType));
2642             break;
2643         }
2644
2645
2646         IE_FOR_EACH(pucIE, u2IELength, u2Offset) {
2647             if (ELEM_ID_VENDOR == IE_ID(pucIE)) {
2648                 prIe = (P_IE_P2P_T)pucIE;
2649
2650                 if (prIe->ucLength <= P2P_OUI_TYPE_LEN) {
2651                     continue;
2652
2653                 }
2654
2655                 if ((prIe->aucOui[0] == aucWfaOui[0]) &&
2656                         (prIe->aucOui[1] == aucWfaOui[1]) &&
2657                         (prIe->aucOui[2] == aucWfaOui[2]) &&
2658                         (ucOuiType == prIe->ucOuiType)) {
2659
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);
2664                         }
2665                         else {
2666                             ASSERT(FALSE);
2667                         }
2668                     }
2669                     else {
2670 /* More than 2 attributes. */
2671                         UINT_16 u2CopyLen;
2672
2673                         if (FALSE == fgBackupAttributes) {
2674                             P_P2P_SPECIFIC_BSS_INFO_T prP2pSpecificBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;;
2675
2676                             fgBackupAttributes = TRUE;
2677                             if (ucOuiType == VENDOR_OUI_TYPE_P2P) {
2678                                 kalMemCopy(&prP2pSpecificBssInfo->aucAttributesCache[0],
2679                                        pucAttriListStart,
2680                                        u2AttriListLen);
2681
2682                                 pucAttriListStart = &prP2pSpecificBssInfo->aucAttributesCache[0];
2683
2684                                 u2BufferSize = P2P_MAXIMUM_ATTRIBUTE_LEN;
2685                             }
2686                             else if (ucOuiType == VENDOR_OUI_TYPE_WPS) {
2687                                 kalMemCopy(&prP2pSpecificBssInfo->aucWscAttributesCache[0],
2688                                        pucAttriListStart,
2689                                        u2AttriListLen);
2690                                 pucAttriListStart = &prP2pSpecificBssInfo->aucWscAttributesCache[0];
2691
2692                                 u2BufferSize = WPS_MAXIMUM_ATTRIBUTES_CACHE_SIZE;
2693                             }
2694 #if CFG_SUPPORT_WFD
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);
2698
2699                                 if (pucTmpBuf != NULL) {
2700                                     fgIsAllocMem = TRUE;
2701                                 }
2702                                 else {
2703                                     /* Can't alloca memory for WFD IE relocate. */
2704                                     ASSERT(FALSE);
2705                                     break;
2706                                 }
2707
2708                                 kalMemCopy(pucTmpBuf,
2709                                        pucAttriListStart,
2710                                        u2AttriListLen);
2711
2712                                 pucAttriListStart = pucTmpBuf;
2713
2714                                 u2BufferSize = WPS_MAXIMUM_ATTRIBUTES_CACHE_SIZE;
2715                             }
2716 #endif
2717                             else {
2718                                 fgBackupAttributes = FALSE;
2719                             }
2720                         }
2721
2722                         u2CopyLen = (UINT_16)(prIe->ucLength - P2P_OUI_TYPE_LEN);
2723
2724                         if ((u2AttriListLen + u2CopyLen) > u2BufferSize) {
2725
2726                             u2CopyLen = u2BufferSize - u2AttriListLen;
2727
2728                             DBGLOG(P2P, WARN, ("Length of received P2P attributes > maximum cache size.\n"));
2729
2730                         }
2731
2732                         if (u2CopyLen) {
2733                             kalMemCopy((PUINT_8)((UINT_32)pucAttriListStart + (UINT_32)u2AttriListLen),
2734                                         &prIe->aucP2PAttributes[0],
2735                                         u2CopyLen);
2736
2737                             u2AttriListLen += u2CopyLen;
2738                         }
2739
2740
2741                     }
2742                 } /* prIe->aucOui */
2743             } /* ELEM_ID_VENDOR */
2744         } /* IE_FOR_EACH */
2745
2746
2747     } while (FALSE);
2748
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);
2754         }
2755         else if (ucOuiType == VENDOR_OUI_TYPE_WFD) {
2756         }
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)));
2763             }
2764         }
2765         else {
2766         }
2767
2768         ASSERT(u2Offset == u2AttriListLen);
2769
2770         *ppucAttriList = pucAttriListStart;
2771         *pu2AttriListLen = u2AttriListLen;
2772
2773     }
2774     else {
2775         *ppucAttriList = (PUINT_8)NULL;
2776         *pu2AttriListLen = 0;
2777     }
2778
2779     return fgIsAllocMem;
2780 } /* p2pFuncGetAttriList */
2781
2782
2783 P_MSDU_INFO_T
2784 p2pFuncProcessP2pProbeRsp (
2785     IN P_ADAPTER_T prAdapter,
2786     IN P_MSDU_INFO_T prMgmtTxMsdu
2787     )
2788 {
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;
2797
2798
2799     do {
2800         ASSERT_BREAK((prAdapter != NULL) && (prMgmtTxMsdu != NULL));
2801
2802         prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
2803
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);
2807
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;
2812
2813 #if CFG_SUPPORT_WFD
2814         prAdapter->prGlueInfo->prP2PInfo->u2VenderIELen = 0;
2815 #endif
2816
2817         IE_FOR_EACH(pucIEBuf, u2IELength, u2Offset) {
2818             switch (IE_ID(pucIEBuf)) {
2819             case ELEM_ID_SSID:
2820                 {
2821
2822                     COPY_SSID(prP2pBssInfo->aucSSID,
2823                                     prP2pBssInfo->ucSSIDLen,
2824                                     SSID_IE(pucIEBuf)->aucSSID,
2825                                     SSID_IE(pucIEBuf)->ucLength);
2826                 }
2827                 break;
2828             case ELEM_ID_VENDOR:
2829                 {
2830                     UINT_8 ucOuiType = 0;
2831                     UINT_16 u2SubTypeVersion = 0;
2832 #if! CFG_SUPPORT_WFD
2833
2834
2835                     if (rsnParseCheckForWFAInfoElem(prAdapter, pucIEBuf, &ucOuiType, &u2SubTypeVersion)) {
2836                         if (ucOuiType == VENDOR_OUI_TYPE_WPS) {
2837                             kalP2PUpdateWSC_IE(prAdapter->prGlueInfo, 2, pucIEBuf, IE_SIZE(pucIEBuf));
2838                             fgIsWSCIE = TRUE;
2839                         }
2840
2841                     }
2842
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));
2847                             fgIsP2PIE = TRUE;
2848                         }
2849
2850                     }
2851
2852
2853
2854                     else {
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);
2858                         }
2859                     }
2860 #else
2861                     /* Eddie May be WFD */
2862                    if (rsnParseCheckForWFAInfoElem(prAdapter, pucIEBuf, &ucOuiType, &u2SubTypeVersion)) {
2863                                 if(ucOuiType == VENDOR_OUI_TYPE_WMM) {
2864                                                 break;
2865                                  }
2866
2867                         }
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);
2872                                 }
2873 #endif
2874
2875
2876                 }
2877                 break;
2878             default:
2879                 break;
2880             }
2881
2882         }
2883
2884
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);
2893
2894         u2EstimatedExtraIELen = 0;
2895
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;
2900             }
2901
2902             else {
2903                 ASSERT(txProbeRspIETable[u4Idx].pfnCalculateVariableIELen);
2904
2905                 u2EstimatedExtraIELen += (UINT_16)(txProbeRspIETable[u4Idx].pfnCalculateVariableIELen(prAdapter,
2906                                                                                                                                 NETWORK_TYPE_P2P_INDEX,
2907                                                                                                                                 NULL));
2908             }
2909
2910         }
2911
2912
2913         if (fgIsWSCIE) {
2914             u2EstimatedExtraIELen += kalP2PCalWSC_IELen(prAdapter->prGlueInfo, 2);
2915         }
2916
2917         if (fgIsP2PIE) {
2918             u2EstimatedExtraIELen += kalP2PCalWSC_IELen(prAdapter->prGlueInfo, 1);
2919         }
2920
2921 #if CFG_SUPPORT_WFD
2922          u2EstimatedExtraIELen += prAdapter->prGlueInfo->prP2PInfo->u2VenderIELen;
2923 #endif
2924
2925
2926
2927         if ((u2EstimateSize += u2EstimatedExtraIELen) > (prRetMsduInfo->u2FrameLength)) {
2928             prRetMsduInfo = cnmMgtPktAlloc(prAdapter, u2EstimateSize);
2929
2930             if (prRetMsduInfo == NULL) {
2931                 DBGLOG(P2P, WARN, ("No packet for sending new probe response, use original one\n"));
2932                 prRetMsduInfo = prMgmtTxMsdu;
2933                 break;
2934             }
2935
2936
2937             prRetMsduInfo->ucNetworkType = NETWORK_TYPE_P2P_INDEX;
2938         }
2939
2940
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);
2949
2950         prRetMsduInfo->u2FrameLength = (WLAN_MAC_MGMT_HEADER_LEN + TIMESTAMP_FIELD_LEN + BEACON_INTERVAL_FIELD_LEN + CAP_INFO_FIELD_LEN);
2951
2952         bssBuildBeaconProbeRespFrameCommonIEs(prRetMsduInfo,
2953                                                 prP2pBssInfo,
2954                                                 prProbeRspFrame->aucDestAddr);
2955
2956
2957         for (u4Idx = 0; u4Idx < u4IeArraySize; u4Idx++) {
2958             if (txProbeRspIETable[u4Idx].pfnAppendIE) {
2959                 txProbeRspIETable[u4Idx].pfnAppendIE(prAdapter, prRetMsduInfo);
2960             }
2961
2962         }
2963
2964
2965         if (fgIsWSCIE) {
2966             kalP2PGenWSC_IE(prAdapter->prGlueInfo,
2967                                 2,
2968                                 (PUINT_8)((UINT_32)prRetMsduInfo->prPacket + (UINT_32)prRetMsduInfo->u2FrameLength));
2969
2970             prRetMsduInfo->u2FrameLength += (UINT_16)kalP2PCalWSC_IELen(prAdapter->prGlueInfo, 2);
2971         }
2972
2973         if (fgIsP2PIE) {
2974             kalP2PGenWSC_IE(prAdapter->prGlueInfo,
2975                                 1,
2976                                 (PUINT_8)((UINT_32)prRetMsduInfo->prPacket + (UINT_32)prRetMsduInfo->u2FrameLength));
2977
2978             prRetMsduInfo->u2FrameLength += (UINT_16)kalP2PCalWSC_IELen(prAdapter->prGlueInfo, 1);
2979         }
2980
2981 #if CFG_SUPPORT_WFD
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;
2986         }
2987 #endif
2988
2989
2990     } while (FALSE);
2991
2992     if (prRetMsduInfo != prMgmtTxMsdu) {
2993         cnmMgtPktFree(prAdapter, prMgmtTxMsdu);
2994     }
2995
2996
2997     return prRetMsduInfo;
2998 } /* p2pFuncProcessP2pProbeRsp */
2999
3000
3001 #if 0 //LINUX_VERSION_CODE >= KERNEL_VERSION(3, 2, 0)
3002 UINT_32
3003 p2pFuncCalculateExtra_IELenForBeacon (
3004     IN P_ADAPTER_T prAdapter,
3005     IN ENUM_NETWORK_TYPE_INDEX_T eNetTypeIndex,
3006     IN P_STA_RECORD_T prStaRec
3007     )
3008 {
3009
3010     P_P2P_SPECIFIC_BSS_INFO_T prP2pSpeBssInfo = (P_P2P_SPECIFIC_BSS_INFO_T)NULL;
3011     UINT_32 u4IELen = 0;
3012
3013     do {
3014         ASSERT_BREAK((prAdapter != NULL) && (eNetTypeIndex == NETWORK_TYPE_P2P_INDEX));
3015
3016         if (p2pFuncIsAPMode(prAdapter->rWifiVar.prP2pFsmInfo)) {
3017             break;
3018         }
3019
3020         prP2pSpeBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;
3021
3022         u4IELen = prP2pSpeBssInfo->u2IELenForBCN;
3023
3024     } while (FALSE);
3025
3026     return u4IELen;
3027 } /* p2pFuncCalculateP2p_IELenForBeacon */
3028
3029 VOID
3030 p2pFuncGenerateExtra_IEForBeacon (
3031     IN P_ADAPTER_T prAdapter,
3032     IN P_MSDU_INFO_T prMsduInfo
3033     )
3034 {
3035     P_P2P_SPECIFIC_BSS_INFO_T prP2pSpeBssInfo = (P_P2P_SPECIFIC_BSS_INFO_T)NULL;
3036     PUINT_8 pucIEBuf = (PUINT_8)NULL;
3037
3038     do {
3039         ASSERT_BREAK((prAdapter != NULL) && (prMsduInfo != NULL));
3040
3041         prP2pSpeBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;
3042
3043         if (p2pFuncIsAPMode(prAdapter->rWifiVar.prP2pFsmInfo)) {
3044
3045             break;
3046         }
3047
3048         pucIEBuf = (PUINT_8)((UINT_32)prMsduInfo->prPacket + (UINT_32)prMsduInfo->u2FrameLength);
3049
3050         kalMemCopy(pucIEBuf, prP2pSpeBssInfo->aucBeaconIECache, prP2pSpeBssInfo->u2IELenForBCN);
3051
3052         prMsduInfo->u2FrameLength += prP2pSpeBssInfo->u2IELenForBCN;
3053
3054     } while (FALSE);
3055
3056     return;
3057 } /* p2pFuncGenerateExtra_IEForBeacon */
3058
3059
3060 #else
3061 UINT_32
3062 p2pFuncCalculateP2p_IELenForBeacon (
3063     IN P_ADAPTER_T prAdapter,
3064     IN ENUM_NETWORK_TYPE_INDEX_T eNetTypeIndex,
3065     IN P_STA_RECORD_T prStaRec
3066     )
3067 {
3068     P_P2P_SPECIFIC_BSS_INFO_T prP2pSpeBssInfo = (P_P2P_SPECIFIC_BSS_INFO_T)NULL;
3069     UINT_32 u4IELen = 0;
3070
3071     do {
3072         ASSERT_BREAK((prAdapter != NULL) && (eNetTypeIndex == NETWORK_TYPE_P2P_INDEX));
3073
3074         if (!prAdapter->fgIsP2PRegistered) {
3075             break;
3076         }
3077
3078
3079         if (p2pFuncIsAPMode(prAdapter->rWifiVar.prP2pFsmInfo)) {
3080             break;
3081         }
3082
3083         prP2pSpeBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;
3084
3085         u4IELen = prP2pSpeBssInfo->u2AttributeLen;
3086
3087     } while (FALSE);
3088
3089     return u4IELen;
3090 } /* p2pFuncCalculateP2p_IELenForBeacon */
3091
3092
3093 VOID
3094 p2pFuncGenerateP2p_IEForBeacon (
3095     IN P_ADAPTER_T prAdapter,
3096     IN P_MSDU_INFO_T prMsduInfo
3097     )
3098 {
3099     P_P2P_SPECIFIC_BSS_INFO_T prP2pSpeBssInfo = (P_P2P_SPECIFIC_BSS_INFO_T)NULL;
3100     PUINT_8 pucIEBuf = (PUINT_8)NULL;
3101
3102     do {
3103         ASSERT_BREAK((prAdapter != NULL) && (prMsduInfo != NULL));
3104
3105         if (!prAdapter->fgIsP2PRegistered) {
3106             break;
3107         }
3108
3109         prP2pSpeBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;
3110
3111         if (p2pFuncIsAPMode(prAdapter->rWifiVar.prP2pFsmInfo)) {
3112
3113             break;
3114         }
3115
3116         pucIEBuf = (PUINT_8)((UINT_32)prMsduInfo->prPacket + (UINT_32)prMsduInfo->u2FrameLength);
3117
3118         kalMemCopy(pucIEBuf, prP2pSpeBssInfo->aucAttributesCache, prP2pSpeBssInfo->u2AttributeLen);
3119
3120         prMsduInfo->u2FrameLength += prP2pSpeBssInfo->u2AttributeLen;
3121
3122     } while (FALSE);
3123
3124     return;
3125 } /* p2pFuncGenerateP2p_IEForBeacon */
3126
3127
3128
3129
3130
3131 UINT_32
3132 p2pFuncCalculateWSC_IELenForBeacon (
3133     IN P_ADAPTER_T prAdapter,
3134     IN ENUM_NETWORK_TYPE_INDEX_T eNetTypeIndex,
3135     IN P_STA_RECORD_T prStaRec
3136     )
3137 {
3138     if (eNetTypeIndex != NETWORK_TYPE_P2P_INDEX) {
3139         return 0;
3140     }
3141
3142     return kalP2PCalWSC_IELen(prAdapter->prGlueInfo, 0);
3143 } /* p2pFuncCalculateP2p_IELenForBeacon */
3144
3145
3146 VOID
3147 p2pFuncGenerateWSC_IEForBeacon (
3148     IN P_ADAPTER_T prAdapter,
3149     IN P_MSDU_INFO_T prMsduInfo
3150     )
3151 {
3152     PUINT_8               pucBuffer;
3153     UINT_16               u2IELen = 0;
3154     ASSERT(prAdapter);
3155     ASSERT(prMsduInfo);
3156
3157     if (prMsduInfo->ucNetworkType != NETWORK_TYPE_P2P_INDEX) {
3158         return;
3159     }
3160
3161     u2IELen = (UINT_16)kalP2PCalWSC_IELen(prAdapter->prGlueInfo, 0);
3162
3163     pucBuffer = (PUINT_8)((UINT_32)prMsduInfo->prPacket +
3164                           (UINT_32)prMsduInfo->u2FrameLength);
3165
3166     ASSERT(pucBuffer);
3167
3168     // TODO: Check P2P FSM State.
3169     kalP2PGenWSC_IE(prAdapter->prGlueInfo,
3170                    0,
3171                    pucBuffer);
3172
3173     prMsduInfo->u2FrameLength += u2IELen;
3174
3175     return;
3176 } /* p2pFuncGenerateP2p_IEForBeacon */
3177
3178 #endif
3179 /*----------------------------------------------------------------------------*/
3180 /*!
3181 * @brief This function is used to calculate P2P IE length for Beacon frame.
3182 *
3183 * @param[in] eNetTypeIndex      Specify which network
3184 * @param[in] prStaRec           Pointer to the STA_RECORD_T
3185 *
3186 * @return The length of P2P IE added
3187 */
3188 /*----------------------------------------------------------------------------*/
3189 UINT_32
3190 p2pFuncCalculateP2p_IELenForAssocRsp (
3191     IN P_ADAPTER_T prAdapter,
3192     IN ENUM_NETWORK_TYPE_INDEX_T eNetTypeIndex,
3193     IN P_STA_RECORD_T prStaRec
3194     )
3195 {
3196
3197     if (eNetTypeIndex != NETWORK_TYPE_P2P_INDEX) {
3198         return 0;
3199     }
3200
3201     return p2pFuncCalculateP2P_IELen(prAdapter,
3202                                 eNetTypeIndex,
3203                                 prStaRec,
3204                                 txAssocRspAttributesTable,
3205                                 sizeof(txAssocRspAttributesTable)/sizeof(APPEND_VAR_ATTRI_ENTRY_T));
3206
3207 } /* p2pFuncCalculateP2p_IELenForAssocRsp */
3208
3209
3210
3211
3212
3213
3214 /*----------------------------------------------------------------------------*/
3215 /*!
3216 * @brief This function is used to generate P2P IE for Beacon frame.
3217 *
3218 * @param[in] prMsduInfo             Pointer to the composed MSDU_INFO_T.
3219 *
3220 * @return none
3221 */
3222 /*----------------------------------------------------------------------------*/
3223 VOID
3224 p2pFuncGenerateP2p_IEForAssocRsp (
3225     IN P_ADAPTER_T prAdapter,
3226     IN P_MSDU_INFO_T prMsduInfo
3227     )
3228 {
3229     P_P2P_FSM_INFO_T prP2pFsmInfo = (P_P2P_FSM_INFO_T)NULL;
3230     P_STA_RECORD_T prStaRec = (P_STA_RECORD_T)NULL;
3231
3232     do {
3233         ASSERT_BREAK((prAdapter != NULL) && (prMsduInfo != NULL));
3234
3235         prP2pFsmInfo = prAdapter->rWifiVar.prP2pFsmInfo;
3236
3237         prStaRec = cnmGetStaRecByIndex(prAdapter, prMsduInfo->ucStaRecIndex);
3238
3239         if (IS_STA_P2P_TYPE(prStaRec)) {
3240             DBGLOG(P2P, TRACE, ("Generate NULL P2P IE for Assoc Rsp.\n"));
3241
3242             p2pFuncGenerateP2P_IE(prAdapter,
3243                     TRUE,
3244                     &prMsduInfo->u2FrameLength,
3245                     prMsduInfo->prPacket,
3246                     1500,
3247                     txAssocRspAttributesTable,
3248                     sizeof(txAssocRspAttributesTable)/sizeof(APPEND_VAR_ATTRI_ENTRY_T));
3249         }
3250         else {
3251
3252             DBGLOG(P2P, TRACE, ("Legacy device, no P2P IE.\n"));
3253         }
3254
3255     } while (FALSE);
3256
3257     return;
3258
3259 } /* p2pFuncGenerateP2p_IEForAssocRsp */
3260
3261
3262 UINT_32
3263 p2pFuncCalculateWSC_IELenForAssocRsp (
3264     IN P_ADAPTER_T prAdapter,
3265     IN ENUM_NETWORK_TYPE_INDEX_T eNetTypeIndex,
3266     IN P_STA_RECORD_T prStaRec
3267     )
3268 {
3269         DBGLOG(P2P, TRACE, ("p2pFuncCalculateWSC_IELenForAssocRsp\n"));
3270     if (eNetTypeIndex != NETWORK_TYPE_P2P_INDEX) {
3271         return 0;
3272     }
3273
3274     return kalP2PCalWSC_IELen(prAdapter->prGlueInfo, 0);
3275 } /* p2pFuncCalculateP2p_IELenForAssocRsp */
3276
3277
3278 VOID
3279 p2pFuncGenerateWSC_IEForAssocRsp (
3280     IN P_ADAPTER_T prAdapter,
3281     IN P_MSDU_INFO_T prMsduInfo
3282     )
3283 {
3284     PUINT_8               pucBuffer;
3285     UINT_16               u2IELen = 0;
3286     ASSERT(prAdapter);
3287     ASSERT(prMsduInfo);
3288
3289     if (prMsduInfo->ucNetworkType != NETWORK_TYPE_P2P_INDEX) {
3290         return;
3291     }
3292         DBGLOG(P2P, TRACE, ("p2pFuncGenerateWSC_IEForAssocRsp\n"));
3293
3294     u2IELen = (UINT_16)kalP2PCalWSC_IELen(prAdapter->prGlueInfo, 0);
3295
3296     pucBuffer = (PUINT_8)((UINT_32)prMsduInfo->prPacket +
3297                           (UINT_32)prMsduInfo->u2FrameLength);
3298
3299     ASSERT(pucBuffer);
3300
3301     // TODO: Check P2P FSM State.
3302     kalP2PGenWSC_IE(prAdapter->prGlueInfo,
3303                    0,
3304                    pucBuffer);
3305
3306     prMsduInfo->u2FrameLength += u2IELen;
3307
3308     return;
3309 }
3310 /* p2pFuncGenerateP2p_IEForAssocRsp */
3311
3312
3313
3314
3315 UINT_32
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
3322     )
3323 {
3324
3325     UINT_32 u4OverallAttriLen, u4Dummy;
3326     UINT_16 u2EstimatedFixedAttriLen;
3327     UINT_32 i;
3328
3329
3330     /* Overall length of all Attributes */
3331     u4OverallAttriLen = 0;
3332
3333     for (i = 0; i < u4AttriTableSize; i++) {
3334         u2EstimatedFixedAttriLen = arAppendAttriTable[i].u2EstimatedFixedAttriLen;
3335
3336         if (u2EstimatedFixedAttriLen) {
3337             u4OverallAttriLen += u2EstimatedFixedAttriLen;
3338         }
3339         else {
3340             ASSERT(arAppendAttriTable[i].pfnCalculateVariableAttriLen);
3341
3342             u4OverallAttriLen +=
3343                 arAppendAttriTable[i].pfnCalculateVariableAttriLen(prAdapter, prStaRec);
3344         }
3345     }
3346
3347     u4Dummy = u4OverallAttriLen;
3348     u4OverallAttriLen += P2P_IE_OUI_HDR;
3349
3350     for (;(u4Dummy > P2P_MAXIMUM_ATTRIBUTE_LEN);) {
3351         u4OverallAttriLen += P2P_IE_OUI_HDR;
3352         u4Dummy -= P2P_MAXIMUM_ATTRIBUTE_LEN;
3353     }
3354
3355     return u4OverallAttriLen;
3356 } /* p2pFuncCalculateP2P_IELen */
3357
3358
3359 VOID
3360 p2pFuncGenerateP2P_IE (
3361     IN P_ADAPTER_T prAdapter,
3362     IN BOOLEAN fgIsAssocFrame,
3363     IN PUINT_16 pu2Offset,
3364     IN PUINT_8 pucBuf,
3365     IN UINT_16 u2BufSize,
3366     IN APPEND_VAR_ATTRI_ENTRY_T arAppendAttriTable[],
3367     IN UINT_32 u4AttriTableSize
3368     )
3369 {
3370     PUINT_8 pucBuffer = (PUINT_8)NULL;
3371     P_IE_P2P_T prIeP2P = (P_IE_P2P_T)NULL;
3372     UINT_32 u4OverallAttriLen;
3373     UINT_32 u4AttriLen;
3374     UINT_8 aucWfaOui[] = VENDOR_OUI_WFA_SPECIFIC;
3375     UINT_8 aucTempBuffer[P2P_MAXIMUM_ATTRIBUTE_LEN];
3376     UINT_32 i;
3377
3378
3379     do {
3380         ASSERT_BREAK((prAdapter != NULL) && (pucBuf != NULL));
3381
3382         pucBuffer = (PUINT_8)((UINT_32)pucBuf + (*pu2Offset));
3383
3384         ASSERT_BREAK(pucBuffer != NULL);
3385
3386         /* Check buffer length is still enough. */
3387         ASSERT_BREAK((u2BufSize - (*pu2Offset)) >= P2P_IE_OUI_HDR);
3388
3389         prIeP2P = (P_IE_P2P_T)pucBuffer;
3390
3391         prIeP2P->ucId = ELEM_ID_P2P;
3392
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;
3397
3398         (*pu2Offset) += P2P_IE_OUI_HDR;
3399
3400         /* Overall length of all Attributes */
3401         u4OverallAttriLen = 0;
3402
3403
3404         for (i = 0; i < u4AttriTableSize; i++) {
3405
3406             if (arAppendAttriTable[i].pfnAppendAttri) {
3407                 u4AttriLen = arAppendAttriTable[i].pfnAppendAttri(prAdapter, fgIsAssocFrame, pu2Offset, pucBuf, u2BufSize);
3408
3409                 u4OverallAttriLen += u4AttriLen;
3410
3411                 if (u4OverallAttriLen > P2P_MAXIMUM_ATTRIBUTE_LEN) {
3412                     u4OverallAttriLen -= P2P_MAXIMUM_ATTRIBUTE_LEN;
3413
3414                     prIeP2P->ucLength = (VENDOR_OUI_TYPE_LEN + P2P_MAXIMUM_ATTRIBUTE_LEN);
3415
3416                     pucBuffer = (PUINT_8)((UINT_32)prIeP2P + (VENDOR_OUI_TYPE_LEN + P2P_MAXIMUM_ATTRIBUTE_LEN));
3417
3418                     prIeP2P = (P_IE_P2P_T)((UINT_32)prIeP2P +
3419                             (ELEM_HDR_LEN + (VENDOR_OUI_TYPE_LEN + P2P_MAXIMUM_ATTRIBUTE_LEN)));
3420
3421                     kalMemCopy(aucTempBuffer, pucBuffer, u4OverallAttriLen);
3422
3423                     prIeP2P->ucId = ELEM_ID_P2P;
3424
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;
3429
3430                     kalMemCopy(prIeP2P->aucP2PAttributes, aucTempBuffer, u4OverallAttriLen);
3431                     (*pu2Offset) += P2P_IE_OUI_HDR;
3432                 }
3433
3434             }
3435
3436         }
3437
3438         prIeP2P->ucLength = (UINT_8)(VENDOR_OUI_TYPE_LEN + u4OverallAttriLen);
3439
3440
3441     } while (FALSE);
3442
3443     return;
3444 } /* p2pFuncGenerateP2P_IE */
3445
3446 UINT_32
3447 p2pFuncAppendAttriStatusForAssocRsp (
3448     IN P_ADAPTER_T prAdapter,
3449     IN BOOLEAN fgIsAssocFrame,
3450     IN PUINT_16 pu2Offset,
3451     IN PUINT_8 pucBuf,
3452     IN UINT_16 u2BufSize
3453     )
3454 {
3455     PUINT_8 pucBuffer;
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;
3459
3460     ASSERT(prAdapter);
3461     ASSERT(pucBuf);
3462
3463     prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
3464
3465     if (fgIsAssocFrame) {
3466         return u4AttriLen;
3467     }
3468
3469     // TODO: For assoc request P2P IE check in driver & return status in P2P IE.
3470
3471     pucBuffer = (PUINT_8)((UINT_32)pucBuf +
3472                             (UINT_32)(*pu2Offset));
3473
3474     ASSERT(pucBuffer);
3475     prAttriStatus = (P_P2P_ATTRI_STATUS_T)pucBuffer;
3476
3477     ASSERT(u2BufSize >= ((*pu2Offset) + (UINT_16)u4AttriLen));
3478
3479
3480
3481
3482     prAttriStatus->ucId = P2P_ATTRI_ID_STATUS;
3483     WLAN_SET_FIELD_16(&prAttriStatus->u2Length, P2P_ATTRI_MAX_LEN_STATUS);
3484
3485     prAttriStatus->ucStatusCode = P2P_STATUS_FAIL_PREVIOUS_PROTOCOL_ERR;
3486
3487     u4AttriLen = (P2P_ATTRI_HDR_LEN + P2P_ATTRI_MAX_LEN_STATUS);
3488
3489     (*pu2Offset) += (UINT_16)u4AttriLen;
3490
3491     return u4AttriLen;
3492 } /* p2pFuncAppendAttriStatusForAssocRsp */
3493
3494 UINT_32
3495 p2pFuncAppendAttriExtListenTiming (
3496     IN P_ADAPTER_T prAdapter,
3497     IN BOOLEAN fgIsAssocFrame,
3498     IN PUINT_16 pu2Offset,
3499     IN PUINT_8 pucBuf,
3500     IN UINT_16 u2BufSize
3501     )
3502 {
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;
3507
3508     ASSERT(prAdapter);
3509     ASSERT(pucBuf);
3510
3511     if (fgIsAssocFrame) {
3512         return u4AttriLen;
3513     }
3514
3515     // TODO: For extend listen timing.
3516
3517     prP2pSpecificBssInfo = prAdapter->rWifiVar.prP2pSpecificBssInfo;
3518
3519     u4AttriLen = (P2P_ATTRI_HDR_LEN + P2P_ATTRI_MAX_LEN_EXT_LISTEN_TIMING);
3520
3521     ASSERT(u2BufSize >= ((*pu2Offset) + (UINT_16)u4AttriLen));
3522
3523     pucBuffer = (PUINT_8)((UINT_32)pucBuf +
3524                             (UINT_32)(*pu2Offset));
3525
3526     ASSERT(pucBuffer);
3527
3528     prP2pExtListenTiming = (P_P2P_ATTRI_EXT_LISTEN_TIMING_T)pucBuffer;
3529
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);
3534
3535     (*pu2Offset) += (UINT_16)u4AttriLen;
3536
3537     return u4AttriLen;
3538 } /* p2pFuncAppendAttriExtListenTiming */
3539
3540
3541 P_IE_HDR_T
3542 p2pFuncGetSpecIE (
3543     IN P_ADAPTER_T prAdapter,
3544     IN PUINT_8 pucIEBuf,
3545     IN UINT_16 u2BufferLen,
3546     IN UINT_8 ucElemID,
3547     IN PBOOLEAN pfgIsMore
3548     )
3549 {
3550     P_IE_HDR_T prTargetIE = (P_IE_HDR_T)NULL;
3551     PUINT_8 pucIE = (PUINT_8)NULL;
3552     UINT_16 u2Offset = 0;
3553
3554     if (pfgIsMore) {
3555             *pfgIsMore = FALSE;
3556     }
3557
3558     do {
3559         ASSERT_BREAK((prAdapter != NULL)
3560                 && (pucIEBuf != NULL));
3561
3562         pucIE = pucIEBuf;
3563
3564         IE_FOR_EACH(pucIE, u2BufferLen, u2Offset) {
3565             if (IE_ID(pucIE) == ucElemID) {
3566                 if ((prTargetIE) && (pfgIsMore)) {
3567
3568                     *pfgIsMore = TRUE;
3569                     break;
3570                 }
3571                 else {
3572                     prTargetIE = (P_IE_HDR_T)pucIE;
3573
3574                     if (pfgIsMore == NULL) {
3575                         break;
3576                     }
3577
3578                 }
3579
3580             }
3581         }
3582
3583     } while (FALSE);
3584
3585     return prTargetIE;
3586 } /* p2pFuncGetSpecIE */
3587
3588
3589
3590 P_ATTRIBUTE_HDR_T
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
3597     )
3598 {
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;
3606
3607
3608     DBGLOG(P2P, INFO, ("Check AssocReq Oui type %u attri %u for len %u\n",ucOuiType, u2AttriID, u2BufferLen));
3609
3610     do {
3611         ASSERT_BREAK((prAdapter != NULL)
3612                 && (pucIEBuf != NULL));
3613
3614         u2BufferLenLeft = u2BufferLen;
3615         pucIE = pucIEBuf;
3616         do {
3617             fgIsMore = FALSE;
3618             prP2pIE = (P_IE_P2P_T)p2pFuncGetSpecIE(prAdapter,
3619                                             pucIE,
3620                                             u2BufferLenLeft,
3621                                             ELEM_ID_VENDOR,
3622                                             &fgIsMore);
3623
3624             if (prP2pIE) {
3625
3626                 ASSERT(prP2pIE>pucIE);
3627
3628                 u2BufferLenLeft = u2BufferLen - (UINT_16)(  ((UINT_32)prP2pIE) - ((UINT_32)pucIEBuf));
3629
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));
3632
3633                 if(IE_LEN(prP2pIE) > P2P_OUI_TYPE_LEN) {
3634
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;
3641                         break;
3642                     case VENDOR_OUI_TYPE_P2P:
3643                         break;
3644                     case VENDOR_OUI_TYPE_WPA:
3645                     case VENDOR_OUI_TYPE_WMM:
3646                     case VENDOR_OUI_TYPE_WFD:
3647                     default:
3648                         break;
3649                     }
3650
3651
3652                         if ((prP2pIE->aucOui[0] == aucWfaOui[0])
3653                               && (prP2pIE->aucOui[1] == aucWfaOui[1])
3654                               && (prP2pIE->aucOui[2] == aucWfaOui[2])
3655                                 ) {
3656
3657                             u2OffsetAttri = 0;
3658                         pucAttri = prP2pIE->aucP2PAttributes;
3659
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;
3665                                     break;
3666                                 }
3667
3668                             }
3669
3670                         }
3671
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;
3677                                     break;
3678                                 }
3679
3680                             }
3681
3682                         }
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;
3688                                         break;
3689                                     }
3690
3691                         }
3692                     }
3693                             else {
3694                                 // Possible or else.
3695                 }
3696
3697             }
3698                     } /* ucOuiType */
3699                 } /* P2P_OUI_TYPE_LEN */
3700
3701                 pucIE = (PUINT_8)(((UINT_32)prP2pIE) + IE_SIZE(prP2pIE));
3702
3703             } /* prP2pIE */
3704
3705         } while (prP2pIE && fgIsMore && u2BufferLenLeft);
3706
3707     } while (FALSE);
3708
3709     return prTargetAttri;
3710 }
3711 /* p2pFuncGetSpecAttri */
3712
3713
3714 WLAN_STATUS
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
3720     )
3721 {
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;
3725
3726
3727     do {
3728
3729         ASSERT_BREAK((prAdapter != NULL) &&
3730                                 (prBssInfo != NULL) &&
3731                                 (prMsduInfo != NULL));
3732
3733
3734 //        txBcnIETable
3735
3736 //        txProbeRspIETable
3737
3738
3739
3740         prBcnFrame = (P_WLAN_BEACON_FRAME_T)prMsduInfo->prPacket;
3741
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));
3748
3749     } while (FALSE);
3750
3751     return rWlanStatus;
3752 } /* p2pFuncGenerateBeaconProbeRsp */
3753
3754
3755 WLAN_STATUS
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
3763     )
3764 {
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;
3769
3770     PUINT_8 pucBuffer = (PUINT_8)NULL;
3771
3772     do {
3773         ASSERT_BREAK((prAdapter != NULL) && (pucBcnBuffer != NULL));
3774
3775         prWlanBcnFrame = (P_WLAN_MAC_HEADER_T)pucBcnBuffer;
3776
3777         if ((prWlanBcnFrame->u2FrameCtrl != MAC_FRAME_BEACON) && (!fgIsProbeRsp)) {
3778             rWlanStatus = WLAN_STATUS_INVALID_DATA;
3779             break;
3780         }
3781
3782         else if (prWlanBcnFrame->u2FrameCtrl != MAC_FRAME_PROBE_RSP) {
3783             rWlanStatus = WLAN_STATUS_INVALID_DATA;
3784             break;
3785         }
3786
3787
3788
3789         if (fgIsProbeRsp) {
3790             ASSERT_BREAK(prP2pProbeRspInfo != NULL);
3791
3792             if (!prP2pProbeRspInfo->prProbeRspMsduTemplate) {
3793                 cnmMgtPktFree(prAdapter, prP2pProbeRspInfo->prProbeRspMsduTemplate);
3794             }
3795
3796             prP2pProbeRspInfo->prProbeRspMsduTemplate = cnmMgtPktAlloc(prAdapter, u4BcnBufLen);
3797
3798             prMsduInfo = prP2pProbeRspInfo->prProbeRspMsduTemplate;
3799
3800             prMsduInfo->eSrc = TX_PACKET_MGMT;
3801             prMsduInfo->ucStaRecIndex = 0xFF;
3802             prMsduInfo->ucNetworkType = NETWORK_TYPE_P2P_INDEX;
3803
3804         }
3805         else {
3806             prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
3807             prMsduInfo = prP2pBssInfo->prBeacon;
3808
3809             if (prMsduInfo == NULL) {
3810                 rWlanStatus = WLAN_STATUS_FAILURE;
3811                 break;
3812             }
3813
3814             if (u4BcnBufLen > (OFFSET_OF(WLAN_BEACON_FRAME_T, aucInfoElem[0]) + MAX_IE_LENGTH)) {
3815                 /* Unexpected error, buffer overflow. */
3816                 ASSERT(FALSE);
3817                 break;
3818             }
3819
3820         }
3821
3822
3823         pucBuffer = (PUINT_8)((UINT_32)(prMsduInfo->prPacket) + MAC_TX_RESERVED_FIELD);
3824
3825         kalMemCopy(pucBuffer, pucBcnBuffer, u4BcnBufLen);
3826
3827         prMsduInfo->fgIs802_11 = TRUE;
3828         prMsduInfo->u2FrameLength = (UINT_16)u4BcnBufLen;
3829
3830         if (fgSynToFW) {
3831             rWlanStatus = p2pFuncGenerateBeaconProbeRsp(prAdapter, prP2pBssInfo, prMsduInfo, fgIsProbeRsp);
3832         }
3833
3834     } while (FALSE);
3835
3836     return rWlanStatus;
3837
3838 } /* p2pFuncComposeBeaconTemplate */
3839
3840 #if CFG_SUPPORT_WFD
3841 WLAN_STATUS wfdAdjustResource(
3842     IN P_ADAPTER_T prAdapter,
3843     IN BOOLEAN fgEnable
3844     ) {
3845 #if 1
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));
3849     if(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;
3854             }
3855             if(QM_GUARANTEED_TC1_RESOURCE>2) {
3856                 prQM->au4GuaranteedTcResource[TC1_INDEX] = QM_GUARANTEED_TC1_RESOURCE - 2;
3857                 prQM->au4GuaranteedTcResource[TC2_INDEX] += 2;
3858             }
3859           }
3860           else {
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;
3865           }
3866 #endif
3867     return WLAN_STATUS_SUCCESS;
3868 }
3869
3870 WLAN_STATUS wfdAdjustThread(
3871     IN P_ADAPTER_T prAdapter,
3872     IN BOOLEAN fgEnable
3873     ) {
3874 #define WFD_TX_THREAD_PRIORITY 70
3875     DBGLOG(P2P, INFO, ("wfdAdjustResource %d\n", fgEnable));
3876     if(fgEnable) {
3877 #ifdef LINUX
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, &param);
3882 #endif
3883           }
3884           else {
3885 #ifdef LINUX
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, &param);
3889 #endif
3890           }
3891     return WLAN_STATUS_SUCCESS;
3892 }
3893
3894
3895 #endif /* CFG_SUPPORT_WFD  */
3896
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) {
3901 #if CFG_SUPPORT_WFD
3902
3903         P_WFD_CFG_SETTINGS_T prWfdCfgSettings = (P_WFD_CFG_SETTINGS_T)NULL;
3904     prWfdCfgSettings = &prAdapter->rWifiVar.prP2pFsmInfo->rWfdConfigureSettings;
3905
3906     if ((prWfdCfgSettings->ucWfdEnable) &&
3907             ((prWfdCfgSettings->u4WfdFlag & WFD_FLAGS_DEV_INFO_VALID))) {
3908
3909              if(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX].eConnectionState == PARAM_MEDIA_STATE_CONNECTED ) {
3910                  wfdAdjustResource(prAdapter, TRUE);
3911                  wfdAdjustThread(prAdapter, TRUE);
3912              }
3913              else {
3914                  wfdAdjustResource(prAdapter, FALSE);
3915                  wfdAdjustThread(prAdapter, FALSE);
3916              }
3917
3918      }
3919 #endif
3920      return WLAN_STATUS_SUCCESS;
3921 }
3922
3923
3924
3925
3926
3927
3928
3929
3930
3931 BOOLEAN
3932 p2pFuncIsChannelGrant (
3933     IN P_ADAPTER_T prAdapter
3934     )
3935 {
3936     P_P2P_FSM_INFO_T prP2pFsmInfo = (P_P2P_FSM_INFO_T)NULL;
3937
3938     if (prAdapter == NULL)
3939         return FALSE;
3940
3941     prP2pFsmInfo = prAdapter->rWifiVar.prP2pFsmInfo;
3942
3943
3944     if (prP2pFsmInfo == NULL)
3945         return FALSE;
3946
3947     return (prP2pFsmInfo->eCurrentState == P2P_STATE_CHNL_ON_HAND);
3948
3949 } /* p2pFuncIsChannelGrant */
3950