2 ** $Id: @(#) p2p_scan.c@@
6 \brief This file defines the p2p scan profile and the processing function of
7 scan result for SCAN Module.
9 The SCAN Profile selection is part of SCAN MODULE and responsible for defining
10 SCAN Parameters - e.g. MIN_CHANNEL_TIME, number of scan channels.
11 In this file we also define the process of SCAN Result including adding, searching
12 and removing SCAN record from the list.
19 /*******************************************************************************
20 * C O M P I L E R F L A G S
21 ********************************************************************************
24 /*******************************************************************************
25 * E X T E R N A L R E F E R E N C E S
26 ********************************************************************************
31 /*******************************************************************************
33 ********************************************************************************
36 /*******************************************************************************
38 ********************************************************************************
41 /*******************************************************************************
43 ********************************************************************************
46 /*******************************************************************************
47 * P R I V A T E D A T A
48 ********************************************************************************
51 /*******************************************************************************
53 ********************************************************************************
56 /*******************************************************************************
57 * F U N C T I O N D E C L A R A T I O N S
58 ********************************************************************************
61 /*******************************************************************************
63 ********************************************************************************
67 scanSearchTargetP2pDesc (
68 IN P_ADAPTER_T prAdapter,
69 IN UINT_8 aucDeviceID[],
70 IN PP_BSS_DESC_T pprBssDesc
74 P_P2P_DEVICE_DESC_T prTargetP2pDesc = (P_P2P_DEVICE_DESC_T)NULL;
75 P_SCAN_INFO_T prScanInfo = (P_SCAN_INFO_T)NULL;
76 P_LINK_T prBSSDescList;
77 P_BSS_DESC_T prBssDesc = (P_BSS_DESC_T)NULL;
83 prScanInfo = &(prAdapter->rWifiVar.rScanInfo);
84 prBSSDescList = &prScanInfo->rBSSDescList;
86 //4 <1> The outer loop to search for a candidate.
87 LINK_FOR_EACH_ENTRY(prBssDesc, prBSSDescList, rLinkEntry, BSS_DESC_T) {
89 /* Loop for each prBssDesc */
90 prTargetP2pDesc = scanFindP2pDeviceDesc(prAdapter,
96 if (prTargetP2pDesc != NULL) {
101 if ((pprBssDesc) && (prTargetP2pDesc != NULL)) {
102 /* Only valid if prTargetP2pDesc is not NULL. */
103 *pprBssDesc = prBssDesc;
106 return prTargetP2pDesc;
107 } /* scanSearchTargetP2pDesc */
113 scanInvalidAllP2pClientDevice (
114 IN P_ADAPTER_T prAdapter,
115 IN P_BSS_DESC_T prBssDesc
118 P_LINK_ENTRY_T prLinkEntry = (P_LINK_ENTRY_T)NULL;
119 P_P2P_DEVICE_DESC_T prTargetDesc = (P_P2P_DEVICE_DESC_T)NULL;
121 LINK_FOR_EACH(prLinkEntry, &prBssDesc->rP2pDeviceList) {
122 prTargetDesc = LINK_ENTRY(prLinkEntry, P2P_DEVICE_DESC_T, rLinkEntry);
124 if (prTargetDesc->fgDevInfoValid) {
125 prTargetDesc->fgDevInfoValid = FALSE;
130 } /* scanRenewP2pClientDevice */
133 scanRemoveInvalidP2pClientDevice (
134 IN P_ADAPTER_T prAdapter,
135 IN P_BSS_DESC_T prBssDesc
138 P_LINK_ENTRY_T prLinkEntry = (P_LINK_ENTRY_T)NULL, prNexEntry = (P_LINK_ENTRY_T)NULL;
139 P_P2P_DEVICE_DESC_T prTargetDesc = (P_P2P_DEVICE_DESC_T)NULL;
140 P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T)NULL;
142 prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
144 LINK_FOR_EACH_SAFE(prLinkEntry, prNexEntry, &prBssDesc->rP2pDeviceList) {
145 prTargetDesc = LINK_ENTRY(prLinkEntry, P2P_DEVICE_DESC_T, rLinkEntry);
147 if (!prTargetDesc->fgDevInfoValid) {
148 LINK_REMOVE_KNOWN_ENTRY(&prBssDesc->rP2pDeviceList, prLinkEntry);
149 if ((prP2pConnSettings) &&
150 (prP2pConnSettings->prTargetP2pDesc == prTargetDesc)) {
151 prP2pConnSettings->prTargetP2pDesc = NULL;
153 kalMemFree(prTargetDesc, VIR_MEM_TYPE, sizeof(P2P_DEVICE_DESC_T));
158 } /* scanRenewP2pClientDevice */
163 scanFindP2pDeviceDesc (
164 IN P_ADAPTER_T prAdapter,
165 IN P_BSS_DESC_T prBssDesc,
166 IN UINT_8 aucMacAddr[],
167 IN BOOLEAN fgIsDeviceAddr,
168 IN BOOLEAN fgAddIfNoFound
172 P_P2P_DEVICE_DESC_T prTargetDesc = (P_P2P_DEVICE_DESC_T)NULL;
173 P_LINK_ENTRY_T prLinkEntry = (P_LINK_ENTRY_T)NULL;
176 ASSERT_BREAK((prAdapter != NULL) &&
177 (prBssDesc != NULL) &&
178 (aucMacAddr != NULL));
180 LINK_FOR_EACH(prLinkEntry, &prBssDesc->rP2pDeviceList) {
181 prTargetDesc = LINK_ENTRY(prLinkEntry, P2P_DEVICE_DESC_T, rLinkEntry);
183 if (fgIsDeviceAddr) {
184 if (EQUAL_MAC_ADDR(prTargetDesc->aucDeviceAddr, aucMacAddr)) {
189 if (EQUAL_MAC_ADDR(prTargetDesc->aucInterfaceAddr, aucMacAddr)) {
197 if ((fgAddIfNoFound) && (prTargetDesc == NULL)) {
198 /* Target Not Found. */
199 // TODO: Use memory pool in the future.
200 prTargetDesc = kalMemAlloc(sizeof(P2P_DEVICE_DESC_T), VIR_MEM_TYPE);
203 kalMemZero(prTargetDesc, sizeof(P2P_DEVICE_DESC_T));
204 LINK_ENTRY_INITIALIZE(&(prTargetDesc->rLinkEntry));
205 COPY_MAC_ADDR(prTargetDesc->aucDeviceAddr, aucMacAddr);
206 LINK_INSERT_TAIL(&prBssDesc->rP2pDeviceList, &prTargetDesc->rLinkEntry);
207 prTargetDesc->fgDevInfoValid = TRUE;
217 } /* scanFindP2pDeviceDesc */
221 scanGetP2pDeviceDesc (
222 IN P_ADAPTER_T prAdapter,
223 IN P_BSS_DESC_T prBssDesc
227 P_P2P_DEVICE_DESC_T prTargetDesc = (P_P2P_DEVICE_DESC_T)NULL;
232 if (prBssDesc->prP2pDesc == NULL) {
234 prTargetDesc = kalMemAlloc(sizeof(P2P_DEVICE_DESC_T), VIR_MEM_TYPE);
237 kalMemZero(prTargetDesc, sizeof(P2P_DEVICE_DESC_T));
238 LINK_ENTRY_INITIALIZE(&(prTargetDesc->rLinkEntry));
239 LINK_INSERT_TAIL(&prBssDesc->rP2pDeviceList, &prTargetDesc->rLinkEntry);
240 prTargetDesc->fgDevInfoValid = TRUE;
241 prBssDesc->prP2pDesc = prTargetDesc;
242 /* We are not sure the SrcAddr is Device Address or Interface Address. */
243 COPY_MAC_ADDR(prTargetDesc->aucDeviceAddr, prBssDesc->aucSrcAddr);
244 COPY_MAC_ADDR(prTargetDesc->aucInterfaceAddr, prBssDesc->aucSrcAddr);
252 prTargetDesc = prBssDesc->prP2pDesc;
258 } /* scanFindP2pDeviceDesc */
262 /*----------------------------------------------------------------------------*/
264 * @brief Convert the Beacon or ProbeResp Frame in SW_RFB_T to Event Packet
266 * @param[in] prSwRfb Pointer to the receiving SW_RFB_T structure.
268 * @retval WLAN_STATUS_SUCCESS It is a valid Scan Result and been sent to the host.
269 * @retval WLAN_STATUS_FAILURE It is not a valid Scan Result.
271 /*----------------------------------------------------------------------------*/
273 scanUpdateP2pDeviceDesc (
274 IN P_ADAPTER_T prAdapter,
275 IN P_BSS_DESC_T prBssDesc
278 P_P2P_DEVICE_DESC_T prP2pDesc = (P_P2P_DEVICE_DESC_T)NULL;
279 P_P2P_ATTRIBUTE_T prP2pAttribute = (P_P2P_ATTRIBUTE_T)NULL;
280 UINT_16 u2AttributeLen = 0;
282 BOOLEAN fgUpdateDevInfo = FALSE;
284 P_DEVICE_NAME_TLV_T prP2pDevName = (P_DEVICE_NAME_TLV_T)NULL;
285 P_P2P_ATTRI_GROUP_INFO_T prP2pAttriGroupInfo = (P_P2P_ATTRI_GROUP_INFO_T)NULL;
289 prP2pDesc = scanGetP2pDeviceDesc(prAdapter, prBssDesc);
293 return fgUpdateDevInfo;
296 p2pGetP2PAttriList(prAdapter, prBssDesc->aucIEBuf, prBssDesc->u2IELength, (PPUINT_8)&prP2pAttribute, &u2AttributeLen);
298 while (u2AttributeLen >= P2P_ATTRI_HDR_LEN) {
299 switch (prP2pAttribute->ucId) {
300 case P2P_ATTRI_ID_P2P_CAPABILITY: /* Beacon, Probe Response */
302 P_P2P_ATTRI_CAPABILITY_T prP2pAttriCapability = (P_P2P_ATTRI_CAPABILITY_T)NULL;
304 prP2pAttriCapability = (P_P2P_ATTRI_CAPABILITY_T)prP2pAttribute;
305 ASSERT(prP2pAttriCapability->u2Length == 2);
307 prP2pDesc->ucDeviceCapabilityBitmap = prP2pAttriCapability->ucDeviceCap;
308 prP2pDesc->ucGroupCapabilityBitmap = prP2pAttriCapability->ucGroupCap;
311 case P2P_ATTRI_ID_P2P_DEV_ID: /* Beacon */
313 P_P2P_ATTRI_DEV_ID_T prP2pAttriDevID = (P_P2P_ATTRI_DEV_ID_T)NULL;
315 prP2pAttriDevID = (P_P2P_ATTRI_DEV_ID_T)prP2pAttribute;
316 ASSERT(prP2pAttriDevID->u2Length == P2P_ATTRI_MAX_LEN_P2P_DEV_ID);
318 kalMemCopy(prP2pDesc->aucDeviceAddr, prP2pAttriDevID->aucDevAddr, MAC_ADDR_LEN);
321 case P2P_ATTRI_ID_P2P_DEV_INFO: /* Probe Response */
323 P_P2P_ATTRI_DEV_INFO_T prP2pAttriDevInfo = (P_P2P_ATTRI_DEV_INFO_T)NULL;
324 P_P2P_DEVICE_TYPE_T prP2pDevType = (P_P2P_DEVICE_TYPE_T)NULL;
325 UINT_16 u2NameLen = 0, u2Id = 0;
327 fgUpdateDevInfo = TRUE;
329 prP2pAttriDevInfo = (P_P2P_ATTRI_DEV_INFO_T)prP2pAttribute;
331 kalMemCopy(prP2pDesc->aucDeviceAddr, prP2pAttriDevInfo->aucDevAddr, MAC_ADDR_LEN);
333 WLAN_GET_FIELD_BE16(&prP2pAttriDevInfo->u2ConfigMethodsBE, &prP2pDesc->u2ConfigMethod);
335 prP2pDevType = &prP2pDesc->rPriDevType;
336 WLAN_GET_FIELD_BE16(&prP2pAttriDevInfo->rPrimaryDevTypeBE.u2CategoryId, &prP2pDevType->u2CategoryID);
337 WLAN_GET_FIELD_BE16(&prP2pAttriDevInfo->rPrimaryDevTypeBE.u2SubCategoryId, &prP2pDevType->u2SubCategoryID);
339 ASSERT(prP2pAttriDevInfo->ucNumOfSecondaryDevType <= P2P_GC_MAX_CACHED_SEC_DEV_TYPE_COUNT); // TODO: Fixme if secondary device type is more than 2.
340 prP2pDesc->ucSecDevTypeNum = 0;
341 for (u4Idx = 0; u4Idx < prP2pAttriDevInfo->ucNumOfSecondaryDevType; u4Idx++) {
342 if (u4Idx < P2P_GC_MAX_CACHED_SEC_DEV_TYPE_COUNT) {
343 prP2pDevType = &(prP2pDesc->arSecDevType[u4Idx]);
344 WLAN_GET_FIELD_BE16(&prP2pAttriDevInfo->arSecondaryDevTypeListBE[u4Idx].u2CategoryId, &prP2pDevType->u2CategoryID);
345 WLAN_GET_FIELD_BE16(&prP2pAttriDevInfo->arSecondaryDevTypeListBE[u4Idx].u2SubCategoryId, &prP2pDevType->u2SubCategoryID);
346 prP2pDesc->ucSecDevTypeNum++;
350 prP2pDevName = (P_DEVICE_NAME_TLV_T)((PUINT_8)prP2pAttriDevInfo->arSecondaryDevTypeListBE + (u4Idx * sizeof(DEVICE_TYPE_T)));
351 WLAN_GET_FIELD_BE16(&prP2pDevName->u2Length, &u2NameLen);
352 WLAN_GET_FIELD_BE16(&prP2pDevName->u2Id, &u2Id);
353 ASSERT(u2Id == WPS_ATTRI_ID_DEVICE_NAME);
354 if (u2NameLen > WPS_ATTRI_MAX_LEN_DEVICE_NAME) {
355 u2NameLen = WPS_ATTRI_MAX_LEN_DEVICE_NAME;
357 prP2pDesc->u2NameLength = u2NameLen;
358 kalMemCopy(prP2pDesc->aucName, prP2pDevName->aucName, prP2pDesc->u2NameLength);
361 case P2P_ATTRI_ID_P2P_GROUP_INFO: /* Probe Response */
362 prP2pAttriGroupInfo = (P_P2P_ATTRI_GROUP_INFO_T)prP2pAttribute;
364 case P2P_ATTRI_ID_NOTICE_OF_ABSENCE:
366 case P2P_ATTRI_ID_EXT_LISTEN_TIMING:
367 // TODO: Not implement yet.
374 u2AttributeLen -= (prP2pAttribute->u2Length + P2P_ATTRI_HDR_LEN);
376 prP2pAttribute = (P_P2P_ATTRIBUTE_T)((UINT_32)prP2pAttribute + (prP2pAttribute->u2Length + P2P_ATTRI_HDR_LEN));
381 if (prP2pAttriGroupInfo != NULL) {
382 P_P2P_CLIENT_INFO_DESC_T prClientInfoDesc = (P_P2P_CLIENT_INFO_DESC_T)NULL;
383 P_P2P_DEVICE_TYPE_T prP2pDevType = (P_P2P_DEVICE_TYPE_T)NULL;
385 scanInvalidAllP2pClientDevice(prAdapter, prBssDesc);
387 /* GO/Device itself. */
388 prP2pDesc->fgDevInfoValid = TRUE;
390 prClientInfoDesc = (P_P2P_CLIENT_INFO_DESC_T)prP2pAttriGroupInfo->arClientDesc;
391 u2AttributeLen = prP2pAttriGroupInfo->u2Length;
394 while (u2AttributeLen > 0) {
395 prP2pDesc = scanFindP2pDeviceDesc(prAdapter, prBssDesc, prClientInfoDesc->aucDevAddr, TRUE, TRUE);
402 prP2pDesc->fgDevInfoValid = TRUE;
404 /* Basic size for P2P client info descriptor. */
405 ASSERT(u2AttributeLen >= 25);
406 if (u2AttributeLen < 25) {
407 DBGLOG(P2P, WARN, ("Length incorrect warning.\n"));
410 COPY_MAC_ADDR(prP2pDesc->aucInterfaceAddr, prClientInfoDesc->aucIfAddr);
412 prP2pDesc->ucDeviceCapabilityBitmap = prClientInfoDesc->ucDeviceCap;
414 WLAN_GET_FIELD_BE16(&prClientInfoDesc->u2ConfigMethodsBE, &prP2pDesc->u2ConfigMethod);
416 prP2pDevType = &(prP2pDesc->rPriDevType);
417 WLAN_GET_FIELD_BE16(&prClientInfoDesc->rPrimaryDevTypeBE.u2CategoryId, &prP2pDevType->u2CategoryID);
418 WLAN_GET_FIELD_BE16(&prClientInfoDesc->rPrimaryDevTypeBE.u2SubCategoryId, &prP2pDevType->u2SubCategoryID);
420 ASSERT(prClientInfoDesc->ucNumOfSecondaryDevType <= P2P_GC_MAX_CACHED_SEC_DEV_TYPE_COUNT);
421 prP2pDesc->ucSecDevTypeNum = 0;
422 for (u4Idx = 0; u4Idx < prClientInfoDesc->ucNumOfSecondaryDevType; u4Idx++) {
423 if (u4Idx < P2P_GC_MAX_CACHED_SEC_DEV_TYPE_COUNT) {
424 prP2pDevType = &(prP2pDesc->arSecDevType[u4Idx]);
425 WLAN_GET_FIELD_BE16(&prClientInfoDesc->arSecondaryDevTypeListBE[u4Idx].u2CategoryId, &prP2pDevType->u2CategoryID);
426 WLAN_GET_FIELD_BE16(&prClientInfoDesc->arSecondaryDevTypeListBE[u4Idx].u2SubCategoryId, &prP2pDevType->u2SubCategoryID);
427 prP2pDesc->ucSecDevTypeNum++;
431 prP2pDevName = (P_DEVICE_NAME_TLV_T)(prClientInfoDesc->arSecondaryDevTypeListBE + (u4Idx * sizeof(DEVICE_TYPE_T)));
432 WLAN_GET_FIELD_BE16(&prP2pDevName->u2Length, &prP2pDesc->u2NameLength);
433 if (prP2pDesc->u2NameLength > WPS_ATTRI_MAX_LEN_DEVICE_NAME) {
434 prP2pDesc->u2NameLength = WPS_ATTRI_MAX_LEN_DEVICE_NAME;
437 kalMemCopy(prP2pDesc->aucName, prP2pDevName->aucName, prP2pDesc->u2NameLength);
439 u2AttributeLen -= (prClientInfoDesc->ucLength + P2P_CLIENT_INFO_DESC_HDR_LEN);
440 prClientInfoDesc = (P_P2P_CLIENT_INFO_DESC_T)((UINT_32)prClientInfoDesc + (UINT_32)prClientInfoDesc->ucLength + P2P_CLIENT_INFO_DESC_HDR_LEN);
443 scanRemoveInvalidP2pClientDevice(prAdapter, prBssDesc);
446 return fgUpdateDevInfo;
447 } /* end of scanAddP2pDeviceInfo() */
453 /*----------------------------------------------------------------------------*/
455 * @brief Convert the Beacon or ProbeResp Frame in SW_RFB_T to Event Packet
457 * @param[in] prSwRfb Pointer to the receiving SW_RFB_T structure.
459 * @retval WLAN_STATUS_SUCCESS It is a valid Scan Result and been sent to the host.
460 * @retval WLAN_STATUS_FAILURE It is not a valid Scan Result.
462 /*----------------------------------------------------------------------------*/
464 scanSendDeviceDiscoverEvent (
465 IN P_ADAPTER_T prAdapter,
466 IN P_BSS_DESC_T prBssDesc,
467 IN P_SW_RFB_T prSwRfb
470 EVENT_P2P_DEV_DISCOVER_RESULT_T rEventDevInfo;
472 P_LINK_ENTRY_T prLinkEntry = (P_LINK_ENTRY_T)NULL;
473 P_P2P_DEVICE_DESC_T prTargetDesc = (P_P2P_DEVICE_DESC_T)NULL;
475 LINK_FOR_EACH(prLinkEntry, &prBssDesc->rP2pDeviceList) {
476 prTargetDesc = LINK_ENTRY(prLinkEntry, P2P_DEVICE_DESC_T, rLinkEntry);
478 COPY_MAC_ADDR(rEventDevInfo.aucDeviceAddr, prTargetDesc->aucDeviceAddr);
479 COPY_MAC_ADDR(rEventDevInfo.aucInterfaceAddr, prTargetDesc->aucInterfaceAddr);
481 rEventDevInfo.ucDeviceCapabilityBitmap = prTargetDesc->ucDeviceCapabilityBitmap;
482 rEventDevInfo.ucGroupCapabilityBitmap = prTargetDesc->ucGroupCapabilityBitmap;
483 rEventDevInfo.u2ConfigMethod = prTargetDesc->u2ConfigMethod;
485 kalMemCopy(&rEventDevInfo.rPriDevType,
486 &prTargetDesc->rPriDevType,
487 sizeof(P2P_DEVICE_TYPE_T));
489 kalMemCopy(rEventDevInfo.arSecDevType,
490 prTargetDesc->arSecDevType,
491 (prTargetDesc->ucSecDevTypeNum * sizeof(P2P_DEVICE_TYPE_T)));
493 rEventDevInfo.ucSecDevTypeNum = prTargetDesc->ucSecDevTypeNum;
495 rEventDevInfo.u2NameLength = prTargetDesc->u2NameLength;
496 kalMemCopy(rEventDevInfo.aucName,
497 prTargetDesc->aucName,
498 prTargetDesc->u2NameLength);
500 COPY_MAC_ADDR(rEventDevInfo.aucBSSID, prBssDesc->aucBSSID);
502 if (prTargetDesc == prBssDesc->prP2pDesc) {
503 nicRxAddP2pDevice(prAdapter,
506 prBssDesc->u2IELength);
509 nicRxAddP2pDevice(prAdapter,
516 kalP2PIndicateFound(prAdapter->prGlueInfo);
520 P_P2P_SPECIFIC_BSS_INFO_T prP2pSpecificBssInfo = (P_P2P_SPECIFIC_BSS_INFO_T)NULL;
521 P_P2P_ATTRIBUTE_T prP2pAttribute = (P_P2P_ATTRIBUTE_T)NULL;
522 UINT_16 u2AttributeLen = 0;
524 P_P2P_ATTRI_GROUP_INFO_T prP2pAttriGroupInfo = (P_P2P_ATTRI_GROUP_INFO_T)NULL;
525 P_DEVICE_NAME_TLV_T prP2pDevName = (P_DEVICE_NAME_TLV_T)NULL;
529 prP2pSpecificBssInfo = &prAdapter->rWifiVar.rP2pSpecificBssInfo;
532 p2pGetP2PAttriList(prAdapter, prBssDesc->aucIEBuf, prBssDesc->u2IELength, (PPUINT_8)&prP2pAttribute, &u2AttributeLen);
534 prP2pAttribute = (P_P2P_ATTRIBUTE_T)&prP2pSpecificBssInfo->aucAttributesCache[0];
535 u2AttributeLen = prP2pSpecificBssInfo->u2AttributeLen;
537 rEventDevInfo.fgDevInfoValid = FALSE;
539 while (u2AttributeLen >= P2P_ATTRI_HDR_LEN) {
540 switch (prP2pAttribute->ucId) {
541 case P2P_ATTRI_ID_P2P_CAPABILITY:
543 P_P2P_ATTRI_CAPABILITY_T prP2pAttriCapability = (P_P2P_ATTRI_CAPABILITY_T)NULL;
545 prP2pAttriCapability = (P_P2P_ATTRI_CAPABILITY_T)prP2pAttribute;
546 ASSERT(prP2pAttriCapability->u2Length == 2);
547 rEventDevInfo.ucDeviceCapabilityBitmap = prP2pAttriCapability->ucDeviceCap;
548 rEventDevInfo.ucGroupCapabilityBitmap = prP2pAttriCapability->ucGroupCap;
551 case P2P_ATTRI_ID_P2P_DEV_ID:
553 P_P2P_ATTRI_DEV_ID_T prP2pAttriDevID = (P_P2P_ATTRI_DEV_ID_T)NULL;
555 prP2pAttriDevID = (P_P2P_ATTRI_DEV_ID_T)prP2pAttribute;
556 ASSERT(prP2pAttriDevID->u2Length == 6);
557 kalMemCopy(rEventDevInfo.aucCommunicateAddr, prP2pAttriDevID->aucDevAddr, MAC_ADDR_LEN);
560 case P2P_ATTRI_ID_P2P_DEV_INFO:
562 P_P2P_ATTRI_DEV_INFO_T prP2pAttriDevInfo = (P_P2P_ATTRI_DEV_INFO_T)NULL;
563 P_P2P_DEVICE_TYPE_T prP2pDevType = (P_P2P_DEVICE_TYPE_T)NULL;
565 prP2pAttriDevInfo = (P_P2P_ATTRI_DEV_INFO_T)prP2pAttribute;
566 rEventDevInfo.fgDevInfoValid = TRUE;
567 kalMemCopy(rEventDevInfo.aucCommunicateAddr, prP2pAttriDevInfo->aucDevAddr, MAC_ADDR_LEN);
568 rEventDevInfo.u2ConfigMethod = prP2pAttriDevInfo->u2ConfigMethodsBE;
570 prP2pDevType = &rEventDevInfo.rPriDevType;
571 prP2pDevType->u2CategoryID = prP2pAttriDevInfo->rPrimaryDevTypeBE.u2CategoryId;
572 prP2pDevType->u2SubCategoryID = prP2pAttriDevInfo->rPrimaryDevTypeBE.u2SubCategoryId;
574 ASSERT(prP2pAttriDevInfo->ucNumOfSecondaryDevType <= 2); // TODO: Fixme if secondary device type is more than 2.
575 for (u4Idx = 0; u4Idx < prP2pAttriDevInfo->ucNumOfSecondaryDevType; u4Idx++) {
576 // TODO: Current sub device type can only support 2.
577 prP2pDevType = &rEventDevInfo.arSecDevType[u4Idx];
578 prP2pDevType->u2CategoryID = prP2pAttriDevInfo->rPrimaryDevTypeBE.u2CategoryId;
579 prP2pDevType->u2SubCategoryID = prP2pAttriDevInfo->rPrimaryDevTypeBE.u2SubCategoryId;
582 prP2pDevName = (P_DEVICE_NAME_TLV_T)(prP2pAttriDevInfo->arSecondaryDevTypeListBE + (u4Idx * sizeof(DEVICE_TYPE_T)));
583 ASSERT(prP2pDevName->u2Id == 0x1011);
584 ASSERT(prP2pDevName->u2Length <= 32); // TODO: Fixme if device name length is longer than 32 bytes.
585 kalMemCopy(rEventDevInfo.aucName, prP2pDevName->aucName, prP2pDevName->u2Length);
588 case P2P_ATTRI_ID_P2P_GROUP_INFO:
589 prP2pAttriGroupInfo = (P_P2P_ATTRI_GROUP_INFO_T)prP2pAttribute;
593 u2AttributeLen -= (prP2pAttribute->u2Length + P2P_ATTRI_HDR_LEN);
595 prP2pAttribute = (P_P2P_ATTRIBUTE_T)((UINT_32)prP2pAttribute + (prP2pAttribute->u2Length + P2P_ATTRI_HDR_LEN));
599 nicRxAddP2pDevice(prAdapter,
602 if (prP2pAttriGroupInfo != NULL) {
603 P_P2P_CLIENT_INFO_DESC_T prClientInfoDesc = (P_P2P_CLIENT_INFO_DESC_T)NULL;
604 P_P2P_DEVICE_TYPE_T prP2pDevType = (P_P2P_DEVICE_TYPE_T)NULL;
606 prClientInfoDesc = prP2pAttriGroupInfo->arClientDesc;
607 u2AttributeLen = prP2pAttriGroupInfo->u2Length;
609 while (u2AttributeLen > 0) {
610 /* Basic size for P2P client info descriptor. */
611 ASSERT(u2AttributeLen >= 25);
612 rEventDevInfo.fgDevInfoValid = TRUE;
613 kalMemCopy(rEventDevInfo.aucCommunicateAddr, prClientInfoDesc->aucIfAddr, MAC_ADDR_LEN);
614 rEventDevInfo.ucDeviceCapabilityBitmap = prClientInfoDesc->ucDeviceCap;
615 rEventDevInfo.u2ConfigMethod = prClientInfoDesc->u2ConfigMethodsBE;
617 prP2pDevType = &rEventDevInfo.rPriDevType;
618 prP2pDevType->u2CategoryID = prClientInfoDesc->rPrimaryDevTypeBE.u2CategoryId;
619 prP2pDevType->u2SubCategoryID = prClientInfoDesc->rPrimaryDevTypeBE.u2SubCategoryId;
621 ASSERT(prClientInfoDesc->ucNumOfSecondaryDevType <= 2); // TODO: Fixme if secondary device type is more than 2.
622 for (u4Idx = 0; u4Idx < prClientInfoDesc->ucNumOfSecondaryDevType; u4Idx++) {
623 // TODO: Current sub device type can only support 2.
624 prP2pDevType = &rEventDevInfo.arSecDevType[u4Idx];
625 prP2pDevType->u2CategoryID = prClientInfoDesc->arSecondaryDevTypeListBE[u4Idx].u2CategoryId;
626 prP2pDevType->u2SubCategoryID = prClientInfoDesc->arSecondaryDevTypeListBE[u4Idx].u2SubCategoryId;
629 prP2pDevName = (P_DEVICE_NAME_TLV_T)(prClientInfoDesc->arSecondaryDevTypeListBE + (u4Idx * sizeof(DEVICE_TYPE_T)));
630 ASSERT(prP2pDevName->u2Id == 0x1011);
631 ASSERT(prP2pDevName->u2Length <= 32); // TODO: Fixme if device name length is longer than 32 bytes.
632 kalMemCopy(&rEventDevInfo.aucName, prP2pDevName->aucName, prP2pDevName->u2Length);
634 nicRxAddP2pDevice(prAdapter,
637 u2AttributeLen -= prP2pAttriGroupInfo->u2Length;
638 prP2pAttriGroupInfo = prP2pAttriGroupInfo + prP2pAttriGroupInfo->u2Length + 1;
643 return WLAN_STATUS_SUCCESS;
644 } /* scanSendDeviceDiscoverEvent */
647 scanP2pProcessBeaconAndProbeResp(
648 IN P_ADAPTER_T prAdapter,
649 IN P_SW_RFB_T prSwRfb,
650 IN P_WLAN_STATUS prStatus,
651 IN P_BSS_DESC_T prBssDesc,
652 IN P_WLAN_BEACON_FRAME_T prWlanBeaconFrame
655 P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T)NULL;
656 P_P2P_CONNECTION_SETTINGS_T prP2pConnSettings = (P_P2P_CONNECTION_SETTINGS_T)NULL;
657 prP2pBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
658 prP2pConnSettings = prAdapter->rWifiVar.prP2PConnSettings;
660 if (prBssDesc->fgIsP2PPresent) {
662 if ((!prP2pBssInfo->ucDTIMPeriod) && // First time.
663 (prP2pBssInfo->eCurrentOPMode == OP_MODE_INFRASTRUCTURE) && // P2P GC
664 (prP2pBssInfo->eConnectionState == PARAM_MEDIA_STATE_CONNECTED) && // Connected
665 ((prWlanBeaconFrame->u2FrameCtrl & MASK_FRAME_TYPE) == MAC_FRAME_BEACON) && // TX Beacon
666 EQUAL_SSID(prBssDesc->aucSSID, // SSID Match
667 prBssDesc->ucSSIDLen,
668 prP2pConnSettings->aucSSID,
669 prP2pConnSettings->ucSSIDLen)) {
672 prP2pBssInfo->ucDTIMPeriod = prBssDesc->ucDTIMPeriod;
673 nicPmIndicateBssConnected(prAdapter, NETWORK_TYPE_P2P_INDEX);
677 RF_CHANNEL_INFO_T rChannelInfo;
679 ASSERT_BREAK((prSwRfb != NULL) && (prBssDesc != NULL));
681 if (((prWlanBeaconFrame->u2FrameCtrl & MASK_FRAME_TYPE) != MAC_FRAME_PROBE_RSP)) {
682 // Only report Probe Response frame to supplicant.
683 /* Probe response collect much more information. */
687 rChannelInfo.ucChannelNum = prBssDesc->ucChannelNum;
688 rChannelInfo.eBand = prBssDesc->eBand;
690 kalP2PIndicateBssInfo(prAdapter->prGlueInfo,
691 (PUINT_8)prSwRfb->pvHeader,
692 (UINT_32)prSwRfb->u2PacketLen,
694 RCPI_TO_dBm(prBssDesc->ucRCPI));
702 scnEventReturnChannel (
703 IN P_ADAPTER_T prAdapter,
704 IN UINT_8 ucScnSeqNum
708 CMD_SCAN_CANCEL rCmdScanCancel;
710 /* send cancel message to firmware domain */
711 rCmdScanCancel.ucSeqNum = ucScnSeqNum;
712 rCmdScanCancel.ucIsExtChannel = (UINT_8) FALSE;
714 wlanSendSetQueryCmd(prAdapter,
721 sizeof(CMD_SCAN_CANCEL),
722 (PUINT_8)&rCmdScanCancel,
727 } /* scnEventReturnChannel */
730 scanRemoveAllP2pBssDesc(
731 IN P_ADAPTER_T prAdapter
734 P_LINK_T prBSSDescList;
735 P_BSS_DESC_T prBssDesc;
736 P_BSS_DESC_T prBSSDescNext;
740 prBSSDescList = &(prAdapter->rWifiVar.rScanInfo.rBSSDescList);
742 /* Search BSS Desc from current SCAN result list. */
743 LINK_FOR_EACH_ENTRY_SAFE(prBssDesc, prBSSDescNext, prBSSDescList, rLinkEntry, BSS_DESC_T) {
744 scanRemoveP2pBssDesc(prAdapter, prBssDesc);
746 } /* scanRemoveAllP2pBssDesc */
749 scanRemoveP2pBssDesc(
750 IN P_ADAPTER_T prAdapter,
751 IN P_BSS_DESC_T prBssDesc
756 } /* scanRemoveP2pBssDesc */
761 IN P_ADAPTER_T prAdapter,
762 IN P_BSS_INFO_T prP2pBssInfo,
763 IN P_P2P_CONNECTION_REQ_INFO_T prConnReqInfo
766 P_BSS_DESC_T prCandidateBssDesc = (P_BSS_DESC_T)NULL, prBssDesc = (P_BSS_DESC_T)NULL;
767 P_LINK_T prBssDescList = (P_LINK_T)NULL;
770 if ((prAdapter == NULL) ||
771 (prP2pBssInfo == NULL) ||
772 (prConnReqInfo == NULL)) {
777 prBssDescList = &(prAdapter->rWifiVar.rScanInfo.rBSSDescList);
779 DBGLOG(P2P, LOUD, ("Connecting to BSSID: "MACSTR"\n", MAC2STR(prConnReqInfo->aucBssid)));
780 DBGLOG(P2P, LOUD, ("Connecting to SSID:%s, length:%d\n",
781 prConnReqInfo->rSsidStruct.aucSsid,
782 prConnReqInfo->rSsidStruct.ucSsidLen));
784 LINK_FOR_EACH_ENTRY(prBssDesc, prBssDescList, rLinkEntry, BSS_DESC_T) {
785 DBGLOG(P2P, LOUD, ("Checking BSS: "MACSTR"\n", MAC2STR(prBssDesc->aucBSSID)));
787 if (prBssDesc->eBSSType != BSS_TYPE_INFRASTRUCTURE) {
788 DBGLOG(P2P, LOUD, ("Ignore mismatch BSS type.\n"));
793 if (UNEQUAL_MAC_ADDR(prBssDesc->aucBSSID, prConnReqInfo->aucBssid)) {
794 DBGLOG(P2P, LOUD, ("Ignore mismatch BSSID.\n"));
799 /* SSID should be the same? SSID is vary for each connection. so... */
800 if (UNEQUAL_SSID(prConnReqInfo->rSsidStruct.aucSsid,
801 prConnReqInfo->rSsidStruct.ucSsidLen,
803 prBssDesc->ucSSIDLen)) {
805 DBGLOG(P2P, TRACE, ("Connecting to BSSID: "MACSTR"\n", MAC2STR(prConnReqInfo->aucBssid)));
806 DBGLOG(P2P, TRACE, ("Connecting to SSID:%s, length:%d\n",
807 prConnReqInfo->rSsidStruct.aucSsid,
808 prConnReqInfo->rSsidStruct.ucSsidLen));
809 DBGLOG(P2P, TRACE, ("Checking SSID:%s, length:%d\n",
811 prBssDesc->ucSSIDLen));
812 DBGLOG(P2P, TRACE, ("Ignore mismatch SSID, (But BSSID match).\n"));
817 if (!prBssDesc->fgIsP2PPresent) {
818 DBGLOG(P2P, ERROR, ("SSID, BSSID, BSSTYPE match, but no P2P IE present.\n"));
822 /* Final decision. */
823 prCandidateBssDesc = prBssDesc;
831 return prCandidateBssDesc;
832 } /* scanP2pSearchDesc */