VOID MlmeP2pGoDiscoverAction(
IN PRTMP_ADAPTER pAd,
IN MLME_QUEUE_ELEM *Elem)
{
PMLME_P2P_ACTION_STRUCT pGoReq = (PMLME_P2P_ACTION_STRUCT) Elem->Msg;
DBGPRINT(RT_DEBUG_TRACE, ("P2P- GO DISCOVERY request. \n"));
MlmeP2pCommonAction(pAd, P2PACT_GO_DISCOVER_REQ, 0, NULL, 0, Elem);
if (pGoReq->TabIndex < MAX_P2P_GROUP_SIZE)
{
/* when used in MlmeP2pGoDiscoverAction, WcidIndex */
pAd->P2pTable.Client[pGoReq->TabIndex].P2pClientState = P2PSTATE_WAIT_GO_DISCO_ACK;
DBGPRINT(RT_DEBUG_TRACE, ("P2P- Client State %s \n", decodeP2PClientState(pAd->P2pTable.Client[pGoReq->TabIndex].P2pClientState)));
}
}
/*
==========================================================================
Description:
Copy P2P Table's information to Mac Table when the P2P Device is in my group.
Parameters:
Note:
==========================================================================
*/
VOID P2pCopyP2PTabtoMacTab(
IN PRTMP_ADAPTER pAd,
IN UCHAR P2pindex,
IN UCHAR Macindex)
{
MAC_TABLE_ENTRY *pEntry;
RT_P2P_CLIENT_ENTRY *pP2pEntry;
if ((P2pindex >= MAX_P2P_GROUP_SIZE) || (Macindex >= MAX_LEN_OF_MAC_TABLE))
return;
pEntry = &pAd->MacTab.Content[Macindex];
pP2pEntry = &pAd->P2pTable.Client[P2pindex];
pEntry->P2pInfo.CTWindow = pP2pEntry->CTWindow;
pEntry->P2pInfo.P2pClientState = pP2pEntry->P2pClientState;
pEntry->P2pInfo.P2pFlag = pP2pEntry->P2pFlag;
pEntry->P2pInfo.NoAToken = pP2pEntry->NoAToken;
pEntry->P2pInfo.GeneralToken = pP2pEntry->GeneralToken;
DBGPRINT(RT_DEBUG_TRACE, ("MacTab Add = %s. \n", decodeP2PClientState(pEntry->P2pInfo.P2pClientState)));
pEntry->P2pInfo.ConfigMethod = pP2pEntry->ConfigMethod;
pEntry->P2pInfo.DevCapability = pP2pEntry->DevCapability;
pEntry->P2pInfo.GroupCapability = pP2pEntry->GroupCapability;
pEntry->P2pInfo.NumSecondaryType = pP2pEntry->NumSecondaryType;
pEntry->P2pInfo.DeviceNameLen = pP2pEntry->DeviceNameLen;
RTMPMoveMemory(pEntry->P2pInfo.DevAddr, pP2pEntry->addr, MAC_ADDR_LEN);
RTMPMoveMemory(pEntry->P2pInfo.InterfaceAddr, pP2pEntry->InterfaceAddr, MAC_ADDR_LEN);
DBGPRINT(RT_DEBUG_TRACE, ("MacTab InterfaceAddr = %x %x %x %x %x %x . \n", PRINT_MAC(pP2pEntry->InterfaceAddr)));
DBGPRINT(RT_DEBUG_TRACE, ("MacTab DevAddr = %x %x %x %x %x %x. \n", PRINT_MAC(pP2pEntry->addr)));
DBGPRINT(RT_DEBUG_TRACE, ("MacTab DeviceNameLen = %ld . \n", pEntry->P2pInfo.DeviceNameLen));
RTMPMoveMemory(pEntry->P2pInfo.PrimaryDevType, pP2pEntry->PrimaryDevType, P2P_DEVICE_TYPE_LEN);
RTMPMoveMemory(pEntry->P2pInfo.DeviceName, pP2pEntry->DeviceName, 32);
RTMPMoveMemory(pEntry->P2pInfo.SecondaryDevType, pP2pEntry->SecondaryDevType, P2P_DEVICE_TYPE_LEN);
P2PPrintMac(pAd, Macindex);
}
INT Set_P2P_Print_GroupTable_Proc(
IN PRTMP_ADAPTER pAd,
IN PSTRING arg)
{
POS_COOKIE pObj;
int i, j;
pObj = (POS_COOKIE) pAd->OS_Cookie;
if (pObj->ioctl_if_type != INT_P2P)
return 0;
DBGPRINT(RT_DEBUG_ERROR, ("%s:: P2pTable ClientNum = %d\n", __FUNCTION__, pAd->P2pTable.ClientNumber));
for (i=0; i < pAd->P2pTable.ClientNumber; i++)
{
DBGPRINT(RT_DEBUG_ERROR, ("Table.Client[%d]: DeviceName[", i));
for (j=0; j<pAd->P2pTable.Client[i].DeviceNameLen;j++)
DBGPRINT(RT_DEBUG_ERROR, ("%c ", pAd->P2pTable.Client[i].DeviceName[j]));
DBGPRINT(RT_DEBUG_ERROR, ("]\n"));
DBGPRINT(RT_DEBUG_ERROR, (" Addr[%02x:%02x:%02x:%02x:%02x:%02x]\n", PRINT_MAC(pAd->P2pTable.Client[i].addr)));
DBGPRINT(RT_DEBUG_ERROR, (" BSSID[%02x:%02x:%02x:%02x:%02x:%02x]\n", PRINT_MAC(pAd->P2pTable.Client[i].bssid)));
DBGPRINT(RT_DEBUG_ERROR, (" InterfaceAddr[%02x:%02x:%02x:%02x:%02x:%02x]\n", PRINT_MAC(pAd->P2pTable.Client[i].InterfaceAddr)));
DBGPRINT(RT_DEBUG_ERROR, (" SSID["));
for (j=0; j<pAd->P2pTable.Client[i].SsidLen;j++)
DBGPRINT(RT_DEBUG_ERROR, ("%c ", pAd->P2pTable.Client[i].Ssid[j]));
DBGPRINT(RT_DEBUG_ERROR, ("]\n"));
DBGPRINT(RT_DEBUG_ERROR, (" OpChannel = %d. ListenChannel = %d.\n", pAd->P2pTable.Client[i].OpChannel, pAd->P2pTable.Client[i].ListenChannel));
DBGPRINT(RT_DEBUG_ERROR, (" P2pClientState = %s. MyGOIndex = %d.\n", decodeP2PClientState(pAd->P2pTable.Client[i].P2pClientState), pAd->P2pTable.Client[i].MyGOIndex));
DBGPRINT(RT_DEBUG_ERROR, (" Dpid = %s. Rule = %s.\n", decodeDpid(pAd->P2pTable.Client[i].Dpid), decodeMyRule(pAd->P2pTable.Client[i].Rule)));
if (pAd->P2pTable.Client[i].WscMode == 1)
DBGPRINT(RT_DEBUG_ERROR, (" WscMode = PIN. PIN = %02x %02x %02x %02x %02x %02x %02x %02x.\n", pAd->P2pTable.Client[i].PIN[0], pAd->P2pTable.Client[i].PIN[1], pAd->P2pTable.Client[i].PIN[2], pAd->P2pTable.Client[i].PIN[3],
pAd->P2pTable.Client[i].PIN[4], pAd->P2pTable.Client[i].PIN[5], pAd->P2pTable.Client[i].PIN[6], pAd->P2pTable.Client[i].PIN[7]));
else if (pAd->P2pTable.Client[i].WscMode == 2)
DBGPRINT(RT_DEBUG_ERROR, (" WscMode = PBC.\n"));
else
DBGPRINT(RT_DEBUG_ERROR, (" WscMode = ***Unknown***.\n"));
DBGPRINT(RT_DEBUG_ERROR, (" CfgMethod = %s. GoIntent = %d.\n", decodeConfigMethod(pAd->P2pTable.Client[i].ConfigMethod), pAd->P2pTable.Client[i].GoIntent));
decodeDeviceCap(pAd->P2pTable.Client[i].DevCapability);
decodeGroupCap(pAd->P2pTable.Client[i].GroupCapability);
DBGPRINT(RT_DEBUG_ERROR, ("\n"));
}
return TRUE;
}
INT Set_P2P_Print_GroupTable_Proc(
IN PRTMP_ADAPTER pAd,
IN PSTRING arg)
{
POS_COOKIE pObj;
int i, j;
pObj = (POS_COOKIE) pAd->OS_Cookie;
if (pObj->ioctl_if_type != INT_P2P)
return 0;
RTMP_SEM_LOCK(&pAd->P2pTableSemLock);
DBGPRINT(RT_DEBUG_ERROR, ("%s:: P2pTable ClientNum = %d\n", __FUNCTION__, pAd->P2pTable.ClientNumber));
for (i=0; i < pAd->P2pTable.ClientNumber; i++)
{
PRT_P2P_CLIENT_ENTRY pP2pEntry = &pAd->P2pTable.Client[i];
DBGPRINT(RT_DEBUG_ERROR, ("Table.Client[%d]: DeviceName[%d][%s]\n", i, pP2pEntry->DeviceNameLen, pP2pEntry->DeviceName));
DBGPRINT(RT_DEBUG_ERROR, (" Addr[%02x:%02x:%02x:%02x:%02x:%02x]\n", PRINT_MAC(pP2pEntry->addr)));
DBGPRINT(RT_DEBUG_ERROR, (" BSSID[%02x:%02x:%02x:%02x:%02x:%02x]\n", PRINT_MAC(pP2pEntry->bssid)));
DBGPRINT(RT_DEBUG_ERROR, (" InterfaceAddr[%02x:%02x:%02x:%02x:%02x:%02x]\n", PRINT_MAC(pP2pEntry->InterfaceAddr)));
DBGPRINT(RT_DEBUG_ERROR, (" SSID["));
for (j=0; j<pP2pEntry->SsidLen;j++)
DBGPRINT(RT_DEBUG_ERROR, ("%c ", pP2pEntry->Ssid[j]));
DBGPRINT(RT_DEBUG_ERROR, ("]\n"));
DBGPRINT(RT_DEBUG_ERROR, (" OpChannel = %d. ListenChannel = %d.\n", pP2pEntry->OpChannel, pP2pEntry->ListenChannel));
DBGPRINT(RT_DEBUG_ERROR, (" P2pClientState = %s. MyGOIndex = %d.\n", decodeP2PClientState(pP2pEntry->P2pClientState), pP2pEntry->MyGOIndex));
DBGPRINT(RT_DEBUG_ERROR, (" Dpid = %s. Rule = %s.\n", decodeDpid(pP2pEntry->Dpid), decodeMyRule(pP2pEntry->Rule)));
if (pP2pEntry->WscMode == 1)
DBGPRINT(RT_DEBUG_ERROR, (" WscMode = PIN. PIN = %02x %02x %02x %02x %02x %02x %02x %02x.\n",
pP2pEntry->PIN[0], pP2pEntry->PIN[1], pP2pEntry->PIN[2], pP2pEntry->PIN[3],
pP2pEntry->PIN[4], pP2pEntry->PIN[5], pP2pEntry->PIN[6], pP2pEntry->PIN[7]));
else if (pAd->P2pTable.Client[i].WscMode == 2)
DBGPRINT(RT_DEBUG_ERROR, (" WscMode = PBC.\n"));
else
DBGPRINT(RT_DEBUG_ERROR, (" WscMode = ***Unknown***.\n"));
DBGPRINT(RT_DEBUG_ERROR, (" CfgMethod = %s. GoIntent = %d.\n", decodeConfigMethod(pAd->P2pTable.Client[i].ConfigMethod), pAd->P2pTable.Client[i].GoIntent));
decodeDeviceCap(pP2pEntry->DevCapability);
decodeGroupCap(pP2pEntry->GroupCapability);
DBGPRINT(RT_DEBUG_ERROR, (" Rssi = %d.\n", pP2pEntry->Rssi));
#ifdef WFD_SUPPORT
DBGPRINT(RT_DEBUG_ERROR, (" WFD = %d.\n", pP2pEntry->WfdEntryInfo.bWfdClient));
if (pP2pEntry->WfdEntryInfo.bWfdClient)
{
DBGPRINT(RT_DEBUG_ERROR, (" DeviceType = %d. RTSP_Port = %d. MaxThroughput=%d.\n",
pP2pEntry->WfdEntryInfo.wfd_devive_type, pP2pEntry->WfdEntryInfo.rtsp_port, pP2pEntry->WfdEntryInfo.max_throughput));
DBGPRINT(RT_DEBUG_ERROR, (" SessionAvail = %d. PC = %d\n",
pP2pEntry->WfdEntryInfo.session_avail, pP2pEntry->WfdEntryInfo.wfd_PC));
hex_dump("device_info::", pP2pEntry->WfdEntryInfo.wfd_serv_disc_query_info.wfd_device_info_ie, 6);
hex_dump("associate bssid::", pP2pEntry->WfdEntryInfo.wfd_serv_disc_query_info.wfd_associate_bssid_ie, 6);
hex_dump("audio format::", pP2pEntry->WfdEntryInfo.wfd_serv_disc_query_info.wfd_audio_format_ie, 15);
hex_dump("video format::", pP2pEntry->WfdEntryInfo.wfd_serv_disc_query_info.wfd_video_format_ie, 21);
hex_dump("3d video format::", pP2pEntry->WfdEntryInfo.wfd_serv_disc_query_info.wfd_3d_video_format_ie, 13);
hex_dump("content protection::", pP2pEntry->WfdEntryInfo.wfd_serv_disc_query_info.wfd_content_proctection, 1);
hex_dump("couple sink::", pP2pEntry->WfdEntryInfo.wfd_serv_disc_query_info.wfd_couple_sink_info_ie, 1);
hex_dump("extentded capability::", pP2pEntry->WfdEntryInfo.wfd_serv_disc_query_info.wfd_extent_capability_ie, 2);
hex_dump("alternate mac address::", pP2pEntry->WfdEntryInfo.wfd_serv_disc_query_info.wfd_alternate_mac_addr_ie, SUBID_WFD_ALTERNATE_MAC_ADDR_LEN);
}
#endif /* WFD_SUPPORT */
DBGPRINT(RT_DEBUG_ERROR, ("\n"));
}
RTMP_SEM_UNLOCK(&pAd->P2pTableSemLock);
return TRUE;
}
UCHAR P2pGroupTabInsert(
IN PRTMP_ADAPTER pAd,
IN PUCHAR Addr,
IN P2P_CLIENT_STATE State,
IN CHAR Ssid[],
IN UCHAR SsidLen,
IN UCHAR DevCap,
IN UCHAR GrpCap)
{
PRT_P2P_TABLE Tab = &pAd->P2pTable;
UCHAR i;
if (NdisEqualMemory(ZeroSsid, Addr, 6))
{
DBGPRINT(RT_DEBUG_ERROR,("P2pGroupTabInsert . Addr all zero Error. \n"));
return P2P_NOT_FOUND;
}
if ((Addr[0] & 0x1) == 0x1)
{
DBGPRINT(RT_DEBUG_ERROR,("P2pGroupTabInsert . Insert mcast Addr Error. \n"));
return P2P_NOT_FOUND;
}
for (i = 0; i < MAX_P2P_GROUP_SIZE; i++)
{
/* This peer already exist, so only update state. */
if ((Tab->Client[i].P2pClientState != P2PSTATE_NONE)
&& (RTMPEqualMemory(Tab->Client[i].addr, Addr, MAC_ADDR_LEN)))
{
if (State != P2PSTATE_NONE)
Tab->Client[i].P2pClientState = State;
if ((SsidLen > 0) && (Ssid != NULL))
RTMPMoveMemory(Tab->Client[i].Ssid, Ssid, 32);
Tab->Client[i].SsidLen = SsidLen;
return i;
}
else if (Tab->Client[i].P2pClientState == P2PSTATE_NONE)
{
Tab->ClientNumber++;
RTMPMoveMemory(Tab->Client[i].addr, Addr, 6);
DBGPRINT(RT_DEBUG_ERROR, (" P2pGroupTabInsert[%d] . Arrd[%02x:%02x:%02x:%02x:%02x:%02x] Update State = %s \n", i, Addr[0], Addr[1], Addr[2], Addr[3], Addr[4], Addr[5], decodeP2PClientState(State)));
Tab->Client[i].P2pClientState = State;
if ((SsidLen > 0) && (Ssid != NULL))
RTMPMoveMemory(Tab->Client[i].Ssid, Ssid, 32);
Tab->Client[i].SsidLen = SsidLen;
pAd->P2pTable.Client[i].Dbm = 0;
pAd->P2pTable.Client[i].GoIntent = 0;
pAd->P2pTable.Client[i].MyGOIndex = 0xff;
pAd->P2pTable.Client[i].Peerip = 0;
pAd->P2pTable.Client[i].ConfigTimeOut = 0;
pAd->P2pTable.Client[i].OpChannel = 0;
pAd->P2pTable.Client[i].ListenChannel = 0;
pAd->P2pTable.Client[i].GeneralToken = RandomByte(pAd);
pAd->P2pTable.Client[i].DevCapability = DevCap;
pAd->P2pTable.Client[i].GroupCapability = GrpCap;
if ((pAd->P2pTable.Client[i].GeneralToken == 0)
|| (pAd->P2pTable.Client[i].GeneralToken > 245))
pAd->P2pTable.Client[i].GeneralToken = 6;
pAd->P2pTable.Client[i].Dpid = DEV_PASS_ID_NOSPEC;
pAd->P2pTable.Client[i].P2pFlag = 0;
if (State == P2PSTATE_DISCOVERY_GO)
pAd->P2pTable.Client[i].Rule = P2P_IS_GO;
else
pAd->P2pTable.Client[i].Rule = P2P_IS_CLIENT;
return i;
}
}
return P2P_NOT_FOUND;
}
/*
==========================================================================
Description:
This is a periodic routine that check P2P Group Table's Status. One importatn task is to check if some frame
that need transmission result is success or retry fail.
Parameters:
Note:
==========================================================================
*/
VOID P2pGroupMaintain(
IN PRTMP_ADAPTER pAd)
{
PRT_P2P_CONFIG pP2PCtrl = &pAd->P2pCfg;
UCHAR i;
PRT_P2P_CLIENT_ENTRY pP2pEntry;
ULONG Data;
/*UCHAR Value;*/
/*BCN_TIME_CFG_STRUC csr;*/
BOOLEAN bAllPsm = TRUE;
if (pP2PCtrl->GONoASchedule.bValid == TRUE)
{
/* Disable OppPS when NoA is ON. */
P2pStopOpPS(pAd);
RTMP_IO_READ32(pAd, TSF_TIMER_DW1, &Data);
if (Data != pP2PCtrl->GONoASchedule.TsfHighByte)
{
DBGPRINT(RT_DEBUG_ERROR, ("P2pGroupMaintain. Tsf MSB changed to %ld from %ld. restart NoA . \n",Data, pP2PCtrl->GONoASchedule.TsfHighByte ));
/* I want to resume the NoA */
pP2PCtrl->GONoASchedule.bNeedResumeNoA = TRUE;
P2pStopNoA(pAd, NULL);
/* Ok. Now resume it. */
pP2PCtrl->GONoASchedule.bNeedResumeNoA = FALSE;
P2pGOStartNoA(pAd);
}
}
else if ((P2P_GO_ON(pAd)) && (pP2PCtrl->GONoASchedule.bValid == FALSE)
&& (IS_OPPS_ON(pAd)))
{
/* Since NoA is OFF, consider to enable OppPS. */
for (i = 0; i < MAX_LEN_OF_MAC_TABLE;i++)
{
PMAC_TABLE_ENTRY pEntry = &pAd->MacTab.Content[i];
if (IS_ENTRY_CLIENT(pEntry)
&& (pEntry->PsMode == PWR_ACTIVE))
{
bAllPsm = FALSE;
break;
}
}
if ((bAllPsm == TRUE) && (pAd->MacTab.Size > 0))
{
/* bit 7 is OppPS bit. set 1 to enable. bit [0:6] is in unit TU. */
if (IS_OPPS_ON(pAd))
{
P2pStartOpPS(pAd);
pP2PCtrl->CTWindows = 0x8a;
}
/* case 2 to turn on CTWindows. Not decide the case 2 rule yet. 2010-June */
else if (0)
{
pP2PCtrl->CTWindows = 0x8a;
}
}
else if (P2P_TEST_BIT(pAd->P2pCfg.CTWindows, P2P_OPPS_BIT))
{
P2pStopOpPS(pAd);
}
}
if (pP2PCtrl->p2pidxForServiceCbReq < MAX_P2P_GROUP_SIZE)
{
if (pAd->P2pTable.Client[pAd->P2pCfg.p2pidxForServiceCbReq].ConfigTimeOut > 0)
pAd->P2pTable.Client[pAd->P2pCfg.p2pidxForServiceCbReq].ConfigTimeOut--;
if (pAd->P2pTable.Client[pAd->P2pCfg.p2pidxForServiceCbReq].P2pClientState == P2PSTATE_SERVICE_COMEBACK_COMMAND
&& (pAd->P2pTable.Client[pAd->P2pCfg.p2pidxForServiceCbReq].ConfigTimeOut == 0))
{
/*P2pSendComebackReq(pAd, pAd->P2pCfg.p2pidxForServiceCbReq, pAd->P2pTable.Client[pAd->P2pCfg.p2pidxForServiceCbReq].addr); */
pP2PCtrl->p2pidxForServiceCbReq = MAX_P2P_GROUP_SIZE;
}
}
if (IS_PERSISTENT_ON(pAd)
&& (!P2P_GO_ON(pAd))
&& (!P2P_CLI_ON(pAd)))
{
for (i = 0; i < MAX_P2P_GROUP_SIZE; i++)
{
pP2pEntry = &pAd->P2pTable.Client[i];
/* Add some delay to connect to Persistent GO. Because some GO like broadcom need configuration time to start GO. */
if ((pP2pEntry->P2pClientState == P2PSTATE_REINVOKEINVITE_TILLCONFIGTIME))
{
if (pP2pEntry->ConfigTimeOut > 0)
pP2pEntry->ConfigTimeOut--;
if (pP2pEntry->ConfigTimeOut == 0)
{
pP2PCtrl->P2PConnectState = P2P_DO_WPS_ENROLLEE;
pP2pEntry->P2pClientState = P2PSTATE_GO_WPS;
P2pWpsDone(pAd, pP2pEntry->addr);
}
}
}
}
if (P2P_GO_ON(pAd))
{
for (i = 0; i < MAX_P2P_GROUP_SIZE; i++)
{
pP2pEntry = &pAd->P2pTable.Client[i];
if (pP2pEntry->P2pClientState == P2PSTATE_WAIT_GO_DISCO_ACK_SUCCESS)
{
ULONG TotalFrameLen;
DBGPRINT(RT_DEBUG_TRACE,("P2P P2PSTATE_WAIT_GO_DISCO_ACK_SUCCESS \n"));
P2PSendDevDisRsp(pAd, P2PSTATUS_SUCCESS, pAd->P2pCfg.LatestP2pPublicFrame.Token, pAd->P2pCfg.LatestP2pPublicFrame.p80211Header.Addr2, &TotalFrameLen);
pP2pEntry->P2pClientState = P2PSTATE_CLIENT_OPERATING;
}
else if ((pP2pEntry->P2pClientState == P2PSTATE_PROVISION_COMMAND) || (pP2pEntry->P2pClientState == P2PSTATE_INVITE_COMMAND))
{
if (pP2pEntry->StateCount > 0)
{
/*DBGPRINT(RT_DEBUG_ERROR, ("pEntry[%d] StateCount = %d\n", i, pP2pEntry->StateCount)); */
pP2pEntry->StateCount--;
}
if ((pP2pEntry->StateCount == 0) && (pP2pEntry->bValid))
{
DBGPRINT(RT_DEBUG_ERROR, ("P2P Table : idx=%d Send Probe Req. \n", i));
pP2pEntry->StateCount = 10;
P2pSendProbeReq(pAd);
}
}
}
}
/* time out case. */
else if ((pP2PCtrl->P2PConnectState == P2P_DO_GO_SCAN_BEGIN)
&& (pP2PCtrl->P2pCounter.GoScanBeginCounter100ms > 1200 /*GOSCANBEGINCOUNTER_MAX*/))
{
DBGPRINT(RT_DEBUG_TRACE, ("P2P_DO_GO_SCAN_BEGIN Timeout. BAck to idle. \n"));
pP2PCtrl->P2PConnectState = P2P_CONNECT_IDLE;
}
else if ((pAd->flg_p2p_OpStatusFlags == 0) &&
(!MAC_ADDR_EQUAL(&ZERO_MAC_ADDR, &pP2PCtrl->ConnectingMAC)) &&
(IS_P2P_SEARCH(pAd)))
{
for (i = 0; i < MAX_P2P_GROUP_SIZE; i++)
{
pP2pEntry = &pAd->P2pTable.Client[i];
if (pP2pEntry->P2pClientState == P2PSTATE_NONE)
continue;
if ((pP2pEntry->P2pClientState >= P2PSTATE_SENT_GO_NEG_REQ) &&
(pP2pEntry->P2pClientState <= P2PSTATE_WAIT_GO_COMFIRM_ACK))
{
if (pP2pEntry->StateCount > 0)
{
/*DBGPRINT(RT_DEBUG_ERROR, ("pEntry[%d] StateCount = %d\n", i, pP2pEntry->StateCount)); */
pP2pEntry->StateCount--;
}
if ((pP2pEntry->StateCount == 0) && ((pP2pEntry->bValid)))
{
DBGPRINT(RT_DEBUG_ERROR, ("P2P Table : idx=%d Go Nego Req Retry. \n", i));
/*pP2pEntry->P2pClientState = P2PSTATE_CONNECT_COMMAND; */
/*pP2PCtrl->P2PConnectState = P2P_CONNECT_IDLE; */
/*pP2PCtrl->P2pCounter.Counter100ms = 0; */
pP2pEntry->StateCount = 50;
P2pSendProbeReq(pAd);
}
}
else if (pP2pEntry->P2pClientState == P2PSTATE_GO_COMFIRM_ACK_SUCCESS)
{
DBGPRINT(RT_DEBUG_ERROR, ("P2P Table : idx=%d Get Confirm Ask Success. p2pState = %d.\n", i, pP2PCtrl->P2PConnectState));
/* Don't leet ClientState keep in P2PSTATE_GO_COMFIRM_ACK_SUCCESS, */
/* Or will keep calling P2pGoNegoDone(). */
/* ClientState will be updated when GO receiving AuthReq. */
pP2pEntry->P2pClientState = P2PSTATE_GOT_GO_COMFIRM;
P2pGoNegoDone(pAd, pP2pEntry);
}
else if (pP2pEntry->P2pClientState== P2PSTATE_REVOKEINVITE_RSP_ACK_SUCCESS)
{
/* Only when I am GO . I need to check the response ack success or not. */
/* doesn't check rule. start GO right away. */
pP2pEntry->P2pClientState = P2PSTATE_CLIENT_WPS;
P2pStartAutoGo(pAd);
DBGPRINT(RT_DEBUG_TRACE,("P2P Table : idx=%d Get Invite Rsp Ask Success. p2pState = %d.\n", i, pP2PCtrl->P2PConnectState));
pAd->StaCfg.WscControl.WscState = WSC_STATE_OFF;
/* this is not Auto GO by command from GUI. So set the intent index to != 16 */
pAd->P2pCfg.GoIntentIdx = 15;
}
else if ((pP2pEntry->P2pClientState == P2PSTATE_CONNECT_COMMAND) || (pP2pEntry->P2pClientState == P2PSTATE_PROVISION_COMMAND) || (pP2pEntry->P2pClientState == P2PSTATE_INVITE_COMMAND))
{
if (pP2pEntry->StateCount > 0)
{
DBGPRINT(RT_DEBUG_INFO, ("pEntry[%d] State = %s. StateCount = %d\n", i, decodeP2PClientState(pP2pEntry->P2pClientState), pP2pEntry->StateCount));
pP2pEntry->StateCount--;
}
if ((pP2pEntry->StateCount == 0) && (pP2pEntry->bValid))
{
DBGPRINT(RT_DEBUG_ERROR, ("P2P Table : idx=%d Send Probe Req. \n", i));
pP2pEntry->StateCount =10;
P2pSendProbeReq(pAd);
}
}
else if ((pP2pEntry->P2pClientState == P2PSTATE_DISCOVERY_GO) && (MAC_ADDR_EQUAL(pP2PCtrl->ConnectingMAC, pP2pEntry->addr)))
{
if (pP2pEntry->StateCount > 0)
{
DBGPRINT(RT_DEBUG_INFO, ("pEntry[%d] State = %s. StateCount = %d\n", i, decodeP2PClientState(pP2pEntry->P2pClientState), pP2pEntry->StateCount));
pP2pEntry->StateCount--;
}
if ((pP2pEntry->StateCount == 0) && (pP2pEntry->bValid))
{
DBGPRINT(RT_DEBUG_ERROR, ("P2P Table : idx=%d Send Probe Req. \n", i));
pP2pEntry->P2pClientState = P2PSTATE_PROVISION_COMMAND;
pP2pEntry->StateCount =10;
P2pSendProbeReq(pAd);
}
}
}
}
}
