diff options
Diffstat (limited to 'network/wlan/WDI/COMMON/P2P_SendAction.c')
| -rw-r--r-- | network/wlan/WDI/COMMON/P2P_SendAction.c | 898 |
1 files changed, 898 insertions, 0 deletions
diff --git a/network/wlan/WDI/COMMON/P2P_SendAction.c b/network/wlan/WDI/COMMON/P2P_SendAction.c new file mode 100644 index 00000000..bd6d9ade --- /dev/null +++ b/network/wlan/WDI/COMMON/P2P_SendAction.c @@ -0,0 +1,898 @@ +#include "Mp_Precomp.h" + +#if WPP_SOFTWARE_TRACE +#include "P2P_SendAction.tmh" +#endif + +#include "P2P_Internal.h" + +#if (P2P_SUPPORT == 1) + +//----------------------------------------------------------------------------- +// Local +//----------------------------------------------------------------------------- +static +VOID +p2p_Send_DumpTxReport( + IN const RT_TX_FEEDBACK_INFO_TX_PROFILE * const pTxProfile + ) +{ + if(NULL == pTxProfile) + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("pTxProfile: is NULL!!!\n")); + return; + } + + if(pTxProfile->bPktOk.bVaild) + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("bPktOk: %u\n", pTxProfile->bPktOk.Data)); + } + else + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("bPktOk: N/A\n")); + } + + if(pTxProfile->bRetryOver.bVaild) + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("bRetryOver: %u\n", pTxProfile->bRetryOver.Data));} + else + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("bRetryOver: N/A\n")); + } + + if(pTxProfile->bLifeTimeOver.bVaild) + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("bLifeTimeOver: %u\n", pTxProfile->bLifeTimeOver.Data)); + } + else + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("bLifeTimeOver: N/A\n")); + } + + if(pTxProfile->bUnicast.bVaild) + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("bUnicast: %u\n", pTxProfile->bUnicast.Data)); + } + else + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("bUnicast: N/A\n")); + } + + if(pTxProfile->uQueueID.bVaild) + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("uQueueID: %u\n", pTxProfile->uQueueID.Data)); + } + else + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("uQueueID: N/A\n")); + } + + if(pTxProfile->uMacID.bVaild) + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("uMacID: %u\n", pTxProfile->uMacID.Data)); + } + else + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("uMacID: N/A\n")); + } + + if(pTxProfile->uDataRetryCount.bVaild) + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("uDataRetryCount: %u\n", pTxProfile->uDataRetryCount.Data)); + } + else + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("uDataRetryCount: N/A\n")); + } + + if(pTxProfile->uQueueTimeUs.bVaild) + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("uQueueTimeUs: %u\n", pTxProfile->uQueueTimeUs.Data)); + } + else + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("uQueueTimeUs: N/A\n")); + } + + if(pTxProfile->uFinalDataRateIndex.bVaild) + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("uFinalDataRateIndex: %u\n", pTxProfile->uFinalDataRateIndex.Data)); + } + else + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("uFinalDataRateIndex: N/A\n")); + } + + return; +} + +static +BOOLEAN +p2p_GetSentFrame( + IN P2P_INFO *info, + IN u1Byte *devAddr, + IN P2P_DEV_TYPE devType, + IN P2P_FRAME_TYPE frameType, + OUT FRAME_BUF *buf + ) +{ + BOOLEAN bFound = FALSE; + + do + { + P2P_DEV_LIST_ENTRY *dev = NULL; + + FrameBuf_Init(0, 0, NULL, buf); + + if(NULL == (dev = p2p_DevList_Get(&info->devList, devAddr, devType))) + { + RT_TRACE_F(COMP_P2P, DBG_WARNING, ("dev not found: %02X:%02X:%02X:%02X:%02X:%02X\n", + devAddr[0], devAddr[1], devAddr[2], devAddr[3], devAddr[4], devAddr[5])); + break; + } + + if(NULL == dev->txFrames[frameType]->frame) + { + RT_TRACE_F(COMP_P2P, DBG_WARNING, ("no tx frame recorded: %02X:%02X:%02X:%02X:%02X:%02X\n", + devAddr[0], devAddr[1], devAddr[2], devAddr[3], devAddr[4], devAddr[5])); + break; + } + + FrameBuf_Init(dev->txFrames[frameType]->frameLen, dev->txFrames[frameType]->frameLen, dev->txFrames[frameType]->frame, buf); + + bFound = TRUE; + }while(FALSE); + + return bFound; +} + +static +VOID +p2p_IndicateFrameSent( + IN P2P_INFO *info, + IN u1Byte *devAddr, + IN P2P_DEV_TYPE devType, + IN P2P_FRAME_TYPE frameType, + IN u4Byte eventId, + IN RT_STATUS rtStatus + ) +{ + p2p_DevList_Lock(&info->devList); + + do + { + FRAME_BUF buf; + + if(!p2p_GetSentFrame(info, devAddr, devType, frameType, &buf)) + { + break; + } + + p2p_IndicateActionFrameSendComplete(info, + eventId, + rtStatus, + buf.os.Octet, + buf.os.Length); + + }while(FALSE); + + p2p_DevList_Unlock(&info->devList); + + return; +} + +static +VOID +p2p_GoNegConfirmSent( + IN PADAPTER pAdapter, + IN const RT_TX_FEEDBACK_INFO * const pTxFeedbackInfo + ) +{ + PP2P_INFO pP2PInfo = (pTxFeedbackInfo) ? + (pTxFeedbackInfo->pContext) : (NULL); + u1Byte dataRate = P2P_LOWEST_RATE; + + if(NULL == pTxFeedbackInfo) return; + + // This tx packet feedback reason doen't match. + if(!(pTxFeedbackInfo->Reason & RT_TX_FEEDBACK_ID_P2P_NEGO_TX)) return; + + FunctionIn(COMP_P2P); + + do + { + if(pTxFeedbackInfo->TxProfile.bPktOk.bVaild && pTxFeedbackInfo->TxProfile.bPktOk.Data) + { + pP2PInfo->State = P2P_STATE_GO_NEGO_COMPLETE; + pP2PInfo->ConnectionContext.Status = P2P_STATUS_SUCCESS; + PlatformSetTimer( pAdapter, &pP2PInfo->P2PMgntTimer, 0); + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("sent OK\n")); + } + else if(P2P_STATE_GO_NEGO_CONFIRM_SENT_WAIT == pP2PInfo->State) + { + BOOLEAN bSupportTxReport = FALSE; + + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("failed, try again\n")); + p2p_Send_DumpTxReport(&pTxFeedbackInfo->TxProfile); + + p2p_DevList_Lock(&pP2PInfo->devList); + + p2p_Send_GoNegConfirm(pP2PInfo, + pP2PInfo->ConnectionContext.ConnectingDevice.DeviceAddress, + pP2PInfo->ConnectionContext.DialogToken, + &bSupportTxReport); + + p2p_DevList_Unlock(&pP2PInfo->devList); + } + }while(FALSE); + + FunctionOut(COMP_P2P); + + return; + +} + +VOID +p2p_PDRspSent( + IN PADAPTER pAdapter, + const RT_TX_FEEDBACK_INFO * const pTxFeedbackInfo + ) +{ + PP2P_INFO pP2PInfo = (pTxFeedbackInfo) ? (pTxFeedbackInfo->pContext) : (NULL); + BOOLEAN bSendOk = FALSE; + + if(NULL == pTxFeedbackInfo) return; + + // This tx packet feedback reason doen't match. + if(!(pTxFeedbackInfo->Reason & RT_TX_FEEDBACK_ID_P2P_PD_RSP_TX)) return; + + FunctionIn(COMP_P2P); + + do + { + p2p_Send_DumpTxReport(&pTxFeedbackInfo->TxProfile); + + bSendOk = (pTxFeedbackInfo->TxProfile.bPktOk.bVaild && pTxFeedbackInfo->TxProfile.bPktOk.Data); + + if(bSendOk) + { + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("send OK\n")); + } + else + { + RT_TRACE(COMP_P2P, DBG_LOUD, ("send failed\n")); + } + + P2PSvc_OnPDRspSent(pP2PInfo->pP2PSvcInfo, bSendOk); + + }while(FALSE); + + FunctionOut(COMP_P2P); + + return; +} + +//----------------------------------------------------------------------------- +// Exported +//----------------------------------------------------------------------------- + +VOID +p2p_Send_GoNegReq( + IN P2P_INFO *pP2PInfo, + IN const u1Byte *da, + IN BOOLEAN bSend + ) +{ + PADAPTER pAdapter = pP2PInfo->pAdapter; + PRT_TCB pTcb = NULL; + PRT_TX_LOCAL_BUFFER pBuf = NULL; + u1Byte dataRate = P2P_LOWEST_RATE; + + PlatformAcquireSpinLock(pAdapter, RT_TX_SPINLOCK); + + if(MgntGetBuffer(pAdapter, &pTcb, &pBuf)) + { + FRAME_BUF fbuf; + u1Byte dialogToken = pP2PInfo->ConnectionContext.DialogToken; + + FrameBuf_Init(pAdapter->MAX_TRANSMIT_BUFFER_SIZE, 0, pBuf->Buffer.VirtualAddress, &fbuf); + FrameBuf_SetDbgLevel(&fbuf, DBG_LOUD); + + p2p_Construct_GoNegReq(pP2PInfo, &fbuf, da, dialogToken); + + pTcb->PacketLength = FrameBuf_Length(&fbuf); + + p2p_IndicateActionFrameSendComplete(pP2PInfo, + P2P_EVENT_GO_NEGOTIATION_REQUEST_SEND_COMPLETE, + RT_STATUS_SUCCESS, + pBuf->Buffer.VirtualAddress, + pTcb->PacketLength); + + if(bSend) + { + p2p_DevList_TxUpdate(&pP2PInfo->devList, P2P_FID_GO_NEG_REQ, + da, P2P_DEV_TYPE_DEV, &fbuf, + dialogToken, RT_GetChannelNumber(pP2PInfo->pAdapter)); + + MgntSendPacket(pAdapter, pTcb, pBuf, pTcb->PacketLength, NORMAL_QUEUE, dataRate); + } + else + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("update dev list only\n")); + } + + PlatformReleaseSpinLock(pAdapter, RT_TX_SPINLOCK); + + return; +} + +VOID +p2p_Send_GoNegRsp( + IN P2P_INFO *pP2PInfo, + IN const u1Byte *da, + IN u1Byte dialogToken + ) +{ + PADAPTER pAdapter = pP2PInfo->pAdapter; + PRT_TCB pTcb; + PRT_TX_LOCAL_BUFFER pBuf; + u1Byte dataRate = P2P_LOWEST_RATE; + + PlatformAcquireSpinLock(pAdapter, RT_TX_SPINLOCK); + + if(MgntGetBuffer(pAdapter, &pTcb, &pBuf)) + { + FRAME_BUF fbuf; + + FrameBuf_Init(pAdapter->MAX_TRANSMIT_BUFFER_SIZE, 0, pBuf->Buffer.VirtualAddress, &fbuf); + FrameBuf_SetDbgLevel(&fbuf, DBG_LOUD); + + p2p_Construct_GoNegRsp(pP2PInfo, dialogToken, &fbuf, da); + + pTcb->PacketLength = FrameBuf_Length(&fbuf); + + p2p_IndicateActionFrameSendComplete(pP2PInfo, + P2P_EVENT_GO_NEGOTIATION_RESPONSE_SEND_COMPLETE, + RT_STATUS_SUCCESS, + pBuf->Buffer.VirtualAddress, + pTcb->PacketLength); + + p2p_DevList_TxUpdate(&pP2PInfo->devList, P2P_FID_GO_NEG_RSP, + da, P2P_DEV_TYPE_DEV, &fbuf, + dialogToken, RT_GetChannelNumber(pP2PInfo->pAdapter)); + + MgntSendPacket(pAdapter, pTcb, pBuf, pTcb->PacketLength, NORMAL_QUEUE, dataRate); + } + + PlatformReleaseSpinLock(pAdapter, RT_TX_SPINLOCK); +} + +VOID +p2p_Send_GoNegConfirm( + IN P2P_INFO *pP2PInfo, + IN const u1Byte *da, + IN u1Byte dialogToken, + OUT PBOOLEAN pbSupportTxReport + ) +{ + PADAPTER pAdapter = pP2PInfo->pAdapter; + PRT_TCB pTcb; + PRT_TX_LOCAL_BUFFER pBuf; + u1Byte dataRate = P2P_LOWEST_RATE; + + PlatformAcquireSpinLock(pAdapter, RT_TX_SPINLOCK); + + if(MgntGetBuffer(pAdapter, &pTcb, &pBuf)) + { + FRAME_BUF fbuf; + + FrameBuf_Init(pAdapter->MAX_TRANSMIT_BUFFER_SIZE, 0, pBuf->Buffer.VirtualAddress, &fbuf); + FrameBuf_SetDbgLevel(&fbuf, DBG_LOUD); + + p2p_Construct_GoNegConf(pP2PInfo, dialogToken, &fbuf, da); + + pTcb->PacketLength = FrameBuf_Length(&fbuf); + + p2p_IndicateActionFrameSendComplete(pP2PInfo, + P2P_EVENT_GO_NEGOTIATION_CONFIRM_SEND_COMPLETE, + RT_STATUS_SUCCESS, + pBuf->Buffer.VirtualAddress, + pTcb->PacketLength); + + *pbSupportTxReport = TxFeedbackInstallTxFeedbackInfoForTcb(pAdapter, pTcb); + + if(*pbSupportTxReport) + { + TxFeedbackFillTxFeedbackInfoUserConfiguration( + pTcb, + RT_TX_FEEDBACK_ID_P2P_NEGO_TX, + pAdapter, + p2p_GoNegConfirmSent, + pP2PInfo + ); + } + + p2p_DevList_TxUpdate(&pP2PInfo->devList, P2P_FID_GO_NEG_CONF, + da, P2P_DEV_TYPE_DEV, &fbuf, + dialogToken, RT_GetChannelNumber(pP2PInfo->pAdapter)); + + MgntSendPacket(pAdapter, pTcb, pBuf, pTcb->PacketLength, NORMAL_QUEUE, dataRate); + } + + PlatformReleaseSpinLock(pP2PInfo->pAdapter, RT_TX_SPINLOCK); +} + +VOID +p2p_Send_InvitationReq( + IN P2P_INFO *pP2PInfo, + IN const u1Byte *da + ) +{ + PADAPTER pAdapter = pP2PInfo->pAdapter; + PRT_TCB pTcb; + PRT_TX_LOCAL_BUFFER pBuf; + u1Byte dataRate = P2P_LOWEST_RATE; + + PlatformAcquireSpinLock(pAdapter, RT_TX_SPINLOCK); + + if(MgntGetBuffer(pAdapter, &pTcb, &pBuf)) + { + FRAME_BUF fbuf; + u1Byte dialogToken = pP2PInfo->InvitationContext.DialogToken; + + FrameBuf_Init(pAdapter->MAX_TRANSMIT_BUFFER_SIZE, 0, pBuf->Buffer.VirtualAddress, &fbuf); + FrameBuf_SetDbgLevel(&fbuf, DBG_LOUD); + + p2p_Construct_InvitationReq(pP2PInfo, &fbuf, da, dialogToken); + + pTcb->PacketLength = FrameBuf_Length(&fbuf); + + p2p_IndicateActionFrameSendComplete(pP2PInfo, + P2P_EVENT_INVITATION_REQUEST_SEND_COMPLETE, + RT_STATUS_SUCCESS, + pBuf->Buffer.VirtualAddress, + pTcb->PacketLength); + + p2p_DevList_TxUpdate(&pP2PInfo->devList, P2P_FID_INV_REQ, + da, P2P_DEV_TYPE_DEV, &fbuf, + dialogToken, RT_GetChannelNumber(pP2PInfo->pAdapter)); + + MgntSendPacket(pAdapter, pTcb, pBuf, pTcb->PacketLength, NORMAL_QUEUE, dataRate); + } + + PlatformReleaseSpinLock(pAdapter, RT_TX_SPINLOCK); +} + +VOID +p2p_Send_InvitationRsp( + IN P2P_INFO *pP2PInfo, + IN const u1Byte *da, + IN u1Byte dialogToken + ) +{ + PADAPTER pAdapter = pP2PInfo->pAdapter; + PRT_TCB pTcb; + PRT_TX_LOCAL_BUFFER pBuf; + u1Byte dataRate = P2P_LOWEST_RATE; + + PlatformAcquireSpinLock(pAdapter, RT_TX_SPINLOCK); + + if(MgntGetBuffer(pAdapter, &pTcb, &pBuf)) + { + FRAME_BUF fbuf; + + FrameBuf_Init(pAdapter->MAX_TRANSMIT_BUFFER_SIZE, 0, pBuf->Buffer.VirtualAddress, &fbuf); + FrameBuf_SetDbgLevel(&fbuf, DBG_LOUD); + + p2p_Construct_InvitationRsp(pP2PInfo, dialogToken, &fbuf, da); + + pTcb->PacketLength = FrameBuf_Length(&fbuf); + + p2p_IndicateActionFrameSendComplete(pP2PInfo, + P2P_EVENT_INVITATION_RESPONSE_SEND_COMPLETE, + RT_STATUS_SUCCESS, + pBuf->Buffer.VirtualAddress, + pTcb->PacketLength); + + p2p_DevList_TxUpdate(&pP2PInfo->devList, P2P_FID_INV_RSP, + da, P2P_DEV_TYPE_DEV, &fbuf, + dialogToken, RT_GetChannelNumber(pP2PInfo->pAdapter)); + + MgntSendPacket(pAdapter, pTcb, pBuf, pTcb->PacketLength, NORMAL_QUEUE, dataRate); + } + + PlatformReleaseSpinLock(pAdapter, RT_TX_SPINLOCK); +} + +VOID +p2p_Send_DevDiscReq( + IN P2P_INFO *pP2PInfo, + IN const u1Byte *bssid, + IN const u1Byte *da, + IN u1Byte dialogToken + ) +{ + PADAPTER pAdapter = pP2PInfo->pAdapter; + PRT_TCB pTcb; + PRT_TX_LOCAL_BUFFER pBuf; + u1Byte dataRate = P2P_LOWEST_RATE; + + PlatformAcquireSpinLock(pAdapter, RT_TX_SPINLOCK); + + if(MgntGetBuffer(pAdapter, &pTcb, &pBuf)) + { + FRAME_BUF fbuf; + + FrameBuf_Init(pAdapter->MAX_TRANSMIT_BUFFER_SIZE, 0, pBuf->Buffer.VirtualAddress, &fbuf); + FrameBuf_SetDbgLevel(&fbuf, DBG_LOUD); + + p2p_Construct_DevDiscReq(pP2PInfo, dialogToken, &fbuf, da, bssid); + + pTcb->PacketLength = FrameBuf_Length(&fbuf); + + MgntSendPacket(pAdapter, pTcb, pBuf, pTcb->PacketLength, NORMAL_QUEUE, dataRate); + } + + PlatformReleaseSpinLock(pAdapter, RT_TX_SPINLOCK); +} + +VOID +p2p_Send_DevDiscRsp( + IN P2P_INFO *pP2PInfo, + IN const u1Byte *da, + IN u1Byte dialogToken, + IN u1Byte status + ) +{ + PADAPTER pAdapter = pP2PInfo->pAdapter; + PRT_TCB pTcb; + PRT_TX_LOCAL_BUFFER pBuf; + u1Byte DataRate = P2P_LOWEST_RATE; + + PlatformAcquireSpinLock(pAdapter, RT_TX_SPINLOCK); + + if(MgntGetBuffer(pAdapter, &pTcb, &pBuf)) + { + FRAME_BUF fbuf; + + FrameBuf_Init(pAdapter->MAX_TRANSMIT_BUFFER_SIZE, 0, pBuf->Buffer.VirtualAddress, &fbuf); + FrameBuf_SetDbgLevel(&fbuf, DBG_LOUD); + + p2p_Construct_DevDiscRsp(pP2PInfo, dialogToken, &fbuf, da, status); + + pTcb->PacketLength = FrameBuf_Length(&fbuf); + + RT_TRACE_F(COMP_P2P, DBG_LOUD, ("Send Packet! status = %d\n", status)); + + MgntSendPacket(pAdapter, pTcb, pBuf, pTcb->PacketLength, NORMAL_QUEUE, DataRate); + } + + PlatformReleaseSpinLock(pAdapter, RT_TX_SPINLOCK); +} + +VOID +p2p_Send_PDReq( + IN P2P_INFO *pP2PInfo, + IN const u1Byte *mac, + IN BOOLEAN bGo, + IN u1Byte dialogToken, + IN u2Byte configMethod + ) +{ + PADAPTER pAdapter = pP2PInfo->pAdapter; + PRT_TCB pTcb; + PRT_TX_LOCAL_BUFFER pBuf; + u1Byte dataRate = P2P_LOWEST_RATE; + + PlatformAcquireSpinLock(pAdapter, RT_TX_SPINLOCK); + + if(MgntGetBuffer(pAdapter, &pTcb, &pBuf)) + { + FRAME_BUF fbuf; + + FrameBuf_Init(pAdapter->MAX_TRANSMIT_BUFFER_SIZE, 0, pBuf->Buffer.VirtualAddress, &fbuf); + FrameBuf_SetDbgLevel(&fbuf, DBG_LOUD); + + // Increase the dialog token. + IncreaseDialogToken(pP2PInfo->DialogToken); + + p2p_Construct_PDReq(pP2PInfo, &fbuf, mac, dialogToken, configMethod); + + pTcb->PacketLength = FrameBuf_Length(&fbuf); + + p2p_DevList_TxUpdate(&pP2PInfo->devList, P2P_FID_PD_REQ, + mac, bGo ? P2P_DEV_TYPE_GO : P2P_DEV_TYPE_DEV, &fbuf, + dialogToken, RT_GetChannelNumber(pP2PInfo->pAdapter)); + + MgntSendPacket(pAdapter, pTcb, pBuf, pTcb->PacketLength, NORMAL_QUEUE, dataRate); + } + + PlatformReleaseSpinLock(pAdapter, RT_TX_SPINLOCK); +} + +VOID +p2p_Send_PDRsp( + IN P2P_INFO *pP2PInfo, + IN const u1Byte *da, + IN u1Byte dialogToken, + IN OCTET_STRING *posP2PAttrs, + IN u2Byte configMethod, + OUT PBOOLEAN pbSupportTxReport + ) +{ + PADAPTER pAdapter = pP2PInfo->pAdapter; + PRT_TCB pTcb; + PRT_TX_LOCAL_BUFFER pBuf; + u1Byte dataRate = P2P_LOWEST_RATE; + BOOLEAN bSupportTxReport = FALSE; + + PlatformAcquireSpinLock(pAdapter, RT_TX_SPINLOCK); + + if(pbSupportTxReport) *pbSupportTxReport = FALSE; + + if(MgntGetBuffer(pAdapter, &pTcb, &pBuf)) + { + FRAME_BUF fbuf; + + FrameBuf_Init(pAdapter->MAX_TRANSMIT_BUFFER_SIZE, 0, pBuf->Buffer.VirtualAddress, &fbuf); + FrameBuf_SetDbgLevel(&fbuf, DBG_LOUD); + + p2p_Construct_PDRsp(pP2PInfo, dialogToken, posP2PAttrs, configMethod, &fbuf, da); + + pTcb->PacketLength = FrameBuf_Length(&fbuf); + + p2p_IndicateActionFrameSendComplete(pP2PInfo, + P2P_EVENT_PROVISION_DISCOVERY_RESPONSE_SEND_COMPLETE, + RT_STATUS_SUCCESS, + pBuf->Buffer.VirtualAddress, + pTcb->PacketLength); + + if(TRUE == (bSupportTxReport = TxFeedbackInstallTxFeedbackInfoForTcb(pAdapter, pTcb))) + { + TxFeedbackFillTxFeedbackInfoUserConfiguration( + pTcb, + RT_TX_FEEDBACK_ID_P2P_PD_RSP_TX, + pAdapter, + p2p_PDRspSent, + (PVOID)(pP2PInfo) + ); + } + + if(pbSupportTxReport) *pbSupportTxReport = bSupportTxReport; + + p2p_DevList_TxUpdate(&pP2PInfo->devList, P2P_FID_PD_RSP, + da, P2P_DEV_TYPE_DEV, &fbuf, + dialogToken, RT_GetChannelNumber(pP2PInfo->pAdapter)); + + MgntSendPacket(pAdapter, pTcb, pBuf, pTcb->PacketLength, NORMAL_QUEUE, dataRate); + } + + PlatformReleaseSpinLock(pAdapter, RT_TX_SPINLOCK); +} + +VOID +p2p_Send_PresenceReq( + IN P2P_INFO *pP2PInfo, + IN const P2P_POWERSAVE_SET *pPs, + IN const u1Byte *da, + IN u1Byte dialogToken + ) +{ + PADAPTER pAdapter = pP2PInfo->pAdapter; + PRT_TCB pTcb; + PRT_TX_LOCAL_BUFFER pBuf; + u1Byte dataRate = P2P_LOWEST_RATE; + + PlatformAcquireSpinLock(pAdapter, RT_TX_SPINLOCK); + + if(MgntGetBuffer(pAdapter, &pTcb, &pBuf)) + { + FRAME_BUF fbuf; + + FrameBuf_Init(pAdapter->MAX_TRANSMIT_BUFFER_SIZE, 0, pBuf->Buffer.VirtualAddress, &fbuf); + FrameBuf_SetDbgLevel(&fbuf, DBG_LOUD); + + p2p_Construct_PresenceReq(pP2PInfo, pPs, da, dialogToken, &fbuf); + + pTcb->PacketLength = FrameBuf_Length(&fbuf); + + MgntSendPacket(pAdapter, pTcb, pBuf, pTcb->PacketLength, NORMAL_QUEUE, dataRate); + } + + PlatformReleaseSpinLock(pAdapter, RT_TX_SPINLOCK); +} + +VOID +p2p_Send_PresenceRsp( + IN P2P_INFO *pP2PInfo, + IN const u1Byte *da, + IN u1Byte dialogToken, + IN u1Byte status + ) +{ + PADAPTER pAdapter = pP2PInfo->pAdapter; + PRT_TCB pTcb; + PRT_TX_LOCAL_BUFFER pBuf; + u1Byte dataRate = P2P_LOWEST_RATE; + + PlatformAcquireSpinLock(pAdapter, RT_TX_SPINLOCK); + + if(MgntGetBuffer(pAdapter, &pTcb, &pBuf)) + { + FRAME_BUF fbuf; + + FrameBuf_Init(pAdapter->MAX_TRANSMIT_BUFFER_SIZE, 0, pBuf->Buffer.VirtualAddress, &fbuf); + FrameBuf_SetDbgLevel(&fbuf, DBG_LOUD); + + p2p_Construct_PresenceRsp(pP2PInfo, da, dialogToken, status, &fbuf); + + pTcb->PacketLength = FrameBuf_Length(&fbuf); + + MgntSendPacket(pAdapter, pTcb, pBuf, pTcb->PacketLength, NORMAL_QUEUE, dataRate); + } + + PlatformReleaseSpinLock(pAdapter, RT_TX_SPINLOCK); +} + +VOID +p2p_Send_GoDiscoverabilityReq( + IN P2P_INFO *pP2PInfo, + IN const u1Byte *da, + IN u1Byte dialogToken + ) +{ + PADAPTER pAdapter = pP2PInfo->pAdapter; + PRT_TCB pTcb; + PRT_TX_LOCAL_BUFFER pBuf; + u1Byte dataRate = P2P_LOWEST_RATE; + + PlatformAcquireSpinLock(pAdapter, RT_TX_SPINLOCK); + + if(MgntGetBuffer(pAdapter, &pTcb, &pBuf)) + { + FRAME_BUF fbuf; + + FrameBuf_Init(pAdapter->MAX_TRANSMIT_BUFFER_SIZE, 0, pBuf->Buffer.VirtualAddress, &fbuf); + FrameBuf_SetDbgLevel(&fbuf, DBG_LOUD); + + p2p_Copnstruct_GoDiscoverabilityReq(pP2PInfo, da, dialogToken, &fbuf); + + pTcb->PacketLength = FrameBuf_Length(&fbuf); + + MgntSendPacket(pAdapter, pTcb, pBuf, pTcb->PacketLength, NORMAL_QUEUE, dataRate); + } + + PlatformReleaseSpinLock(pAdapter, RT_TX_SPINLOCK); +} + +VOID +p2p_Send_SDReq( + IN const P2P_INFO *pP2PInfo, + IN const u1Byte *da + ) +{ + PADAPTER pAdapter = pP2PInfo->pAdapter; + PRT_TCB pTcb; + PRT_TX_LOCAL_BUFFER pBuf; + u1Byte DataRate = P2P_LOWEST_RATE; + + PlatformAcquireSpinLock(pP2PInfo->pAdapter, RT_TX_SPINLOCK); + + if(MgntGetBuffer(pP2PInfo->pAdapter, &pTcb, &pBuf)) + { + FRAME_BUF fbuf; + + FrameBuf_Init(pAdapter->MAX_TRANSMIT_BUFFER_SIZE, 0, pBuf->Buffer.VirtualAddress, &fbuf); + FrameBuf_SetDbgLevel(&fbuf, DBG_LOUD); + + p2p_Construct_SDReq(pP2PInfo, &fbuf, da); + + pTcb->PacketLength = FrameBuf_Length(&fbuf); + + MgntSendPacket(pP2PInfo->pAdapter, pTcb, pBuf, pTcb->PacketLength, NORMAL_QUEUE, DataRate); + } + + PlatformReleaseSpinLock(pP2PInfo->pAdapter, RT_TX_SPINLOCK); + + return; +} + +VOID +p2p_Send_SDRsp( + IN const P2P_INFO *pP2PInfo, + IN const u1Byte *da, + IN u1Byte dialogToken, + IN P2P_SD_STATUS_CODE status, + IN BOOLEAN bFrag + ) +{ + PADAPTER pAdapter = pP2PInfo->pAdapter; + PRT_TCB pTcb; + PRT_TX_LOCAL_BUFFER pBuf; + u1Byte DataRate = P2P_LOWEST_RATE; + + PlatformAcquireSpinLock(pP2PInfo->pAdapter, RT_TX_SPINLOCK); + + if(MgntGetBuffer(pP2PInfo->pAdapter, &pTcb, &pBuf)) + { + FRAME_BUF fbuf; + + FrameBuf_Init(pAdapter->MAX_TRANSMIT_BUFFER_SIZE, 0, pBuf->Buffer.VirtualAddress, &fbuf); + FrameBuf_SetDbgLevel(&fbuf, DBG_LOUD); + + p2p_Construct_SDRsp(pP2PInfo, &fbuf, da, dialogToken, status, bFrag); + + pTcb->PacketLength = FrameBuf_Length(&fbuf); + + MgntSendPacket(pP2PInfo->pAdapter, pTcb, pBuf, pTcb->PacketLength, NORMAL_QUEUE, DataRate); + } + + PlatformReleaseSpinLock(pP2PInfo->pAdapter, RT_TX_SPINLOCK); + + return; +} + +VOID +p2p_Send_SDComebackReq( + IN const P2P_INFO *pP2PInfo, + IN const u1Byte *da, + IN u1Byte dialogToken + ) +{ + PADAPTER pAdapter = pP2PInfo->pAdapter; + PRT_TCB pTcb; + PRT_TX_LOCAL_BUFFER pBuf; + u1Byte DataRate = P2P_LOWEST_RATE; + + PlatformAcquireSpinLock(pP2PInfo->pAdapter, RT_TX_SPINLOCK); + + if(MgntGetBuffer(pP2PInfo->pAdapter, &pTcb, &pBuf)) + { + FRAME_BUF fbuf; + + FrameBuf_Init(pAdapter->MAX_TRANSMIT_BUFFER_SIZE, 0, pBuf->Buffer.VirtualAddress, &fbuf); + FrameBuf_SetDbgLevel(&fbuf, DBG_LOUD); + + p2p_Construct_SDComebackReq(pP2PInfo, &fbuf, da, dialogToken); + + MgntSendPacket(pP2PInfo->pAdapter, pTcb, pBuf, pTcb->PacketLength, NORMAL_QUEUE, DataRate); + } + + PlatformReleaseSpinLock(pP2PInfo->pAdapter, RT_TX_SPINLOCK); + + return; +} + +VOID +p2p_Send_SDComebackRsp( + IN const P2P_INFO *pP2PInfo, + IN const u1Byte *da, + IN u1Byte dialogToken, + IN u2Byte bytesToCopy, + IN BOOLEAN bMoreData + ) +{ + PADAPTER pAdapter = pP2PInfo->pAdapter; + PRT_TCB pTcb; + PRT_TX_LOCAL_BUFFER pBuf; + u1Byte DataRate = P2P_LOWEST_RATE; + + PlatformAcquireSpinLock(pP2PInfo->pAdapter, RT_TX_SPINLOCK); + + if(MgntGetBuffer(pP2PInfo->pAdapter, &pTcb, &pBuf)) + { + FRAME_BUF fbuf; + + FrameBuf_Init(pAdapter->MAX_TRANSMIT_BUFFER_SIZE, 0, pBuf->Buffer.VirtualAddress, &fbuf); + FrameBuf_SetDbgLevel(&fbuf, DBG_LOUD); + + p2p_Construct_SDComebackRsp(pP2PInfo, &fbuf, da, dialogToken, bytesToCopy, bMoreData); + + MgntSendPacket(pP2PInfo->pAdapter, pTcb, pBuf, pTcb->PacketLength, NORMAL_QUEUE, DataRate); + } + + PlatformReleaseSpinLock(pP2PInfo->pAdapter, RT_TX_SPINLOCK); + + return; +} + +#endif |