#include "MP_Precomp.h"

#if WPP_SOFTWARE_TRACE
#include "WDI_Common.tmh"
#endif

#if (WDI_SUPPORT == 1)

VOID
wdi_UnsolicitedIndication(
	IN	PADAPTER		pAdapter,
	IN	BOOLEAN			bAdapterObj,
	IN	PVOID			pRequestId,
	IN	ULONG			Indication,
	IN	NDIS_STATUS		status,
	IN	PUCHAR			pInput,
	IN	ULONG			Length
	)
{
	PRT_GEN_TEMP_BUFFER	pGenBuffer = NULL;
	pu1Byte					pIndicateBuffer = NULL;
	NDIS_STATUS_INDICATION	*indic = NULL;
	WDI_MESSAGE_HEADER	*wdiHdr = NULL;
	NDIS_OID_REQUEST		*req = NULL;

	RT_TRACE(COMP_MLME, DBG_LOUD, ("==>wdi_UnsolicitedIndication(): status indication code = %x, length=%d\n", Indication, Length));

	indic = (NDIS_STATUS_INDICATION *)pInput;
	wdiHdr = (WDI_MESSAGE_HEADER *)(pInput + sizeof(*indic));

	// indication data
	PlatformZeroMemory(indic, sizeof(*indic));
	indic->Header.Type = NDIS_OBJECT_TYPE_STATUS_INDICATION;
	indic->Header.Size = NDIS_SIZEOF_STATUS_INDICATION_REVISION_1;
	indic->Header.Revision = NDIS_STATUS_INDICATION_REVISION_1;
	indic->RequestId = pRequestId;
	indic->SourceHandle = pAdapter;
	indic->PortNumber = 0;
	indic->StatusCode = Indication;
	indic->StatusBuffer = wdiHdr;
	indic->StatusBufferSize = Length - sizeof(*indic);

	// wdi message header
	PlatformZeroMemory(wdiHdr, sizeof(*wdiHdr));
	if( bAdapterObj == TRUE )
	{
		wdiHdr->PortId = WDI_PORT_ANY;
	}
	else
	{
		wdiHdr->PortId = (WDI_PORT_ID)GET_PORT_NUMBER(pAdapter);
	}
	wdiHdr->Reserved = 0;
	wdiHdr->Status = status;
	wdiHdr->TransactionId = 0;
	wdiHdr->IhvSpecificId = 0;

	NdisMIndicateStatusEx(
		pAdapter->pNdisCommon->hNdisAdapter,
		indic
		);

	RT_TRACE(COMP_MLME, DBG_LOUD, ("<== wdi_UnsolicitedIndication()\n"));
}

//
// The following helper functions are used to determined if a
// BSS has the capability of specific wireless mode.
// 2005.01.13, by rcnjko.
//
BOOLEAN
WDIWithWirelessB(
	PRT_WLAN_BSS	pRtBss)
{
	u2Byte i;
	u1Byte rate;

	// Check channels.
	if(pRtBss->ChannelNumber > 14)
	{
		return FALSE;
	}

	// Check supported rates.
	for(i = 0; i < pRtBss->bdSupportRateEXLen; i++)
	{
		rate = pRtBss->bdSupportRateEXBuf[i] & 0x7f;
		if( MgntIsRateValidForWirelessMode(rate, WIRELESS_MODE_B) )
		{
			return TRUE;
		}
	}

	return FALSE;
}

BOOLEAN
WDIWithWirelessG(
	PRT_WLAN_BSS	pRtBss)
{
	u2Byte i;
	u1Byte rate;

	// Check channels.
	if(pRtBss->ChannelNumber > 14)
	{
		return FALSE;
	}

	// Check supported rates.
	for(i = 0; i < pRtBss->bdSupportRateEXLen; i++)
	{
		rate = pRtBss->bdSupportRateEXBuf[i] & 0x7f;
		if( MgntIsRateValidForWirelessMode(rate, WIRELESS_MODE_G) &&
			!MgntIsRateValidForWirelessMode(rate, WIRELESS_MODE_B) )
		{
			return TRUE;
		}
	}

	// Check if it contains ERP information element.
	// <NOTE> Some AP, WAG-302, will not always claim OFDM rates in their ProbeRsp or Beacon
	// but it is in G mode. 2005.08.23, by rcnjko.
	if(pRtBss->bERPInfoValid)
	{
		return TRUE;
	}

	return FALSE;
}

BOOLEAN
WDIWithWirelessA(
	PRT_WLAN_BSS	pRtBss)
{
	u2Byte i;
	u1Byte rate;

	// Check channels.
	if(pRtBss->ChannelNumber <= 14 ||
		pRtBss->ChannelNumber > 184 )
	{
		return FALSE;
	}

	// Check supported rates.
	for(i = 0; i < pRtBss->bdSupportRateEXLen; i++)
	{
		rate = pRtBss->bdSupportRateEXBuf[i] & 0x7f;
		if( MgntIsRateValidForWirelessMode(rate, WIRELESS_MODE_A) )
		{
			return TRUE;
		}
	}

	return FALSE;
}

////
// This routine determine if we should report the BSS scanned
// to upper layer.
// 2005.01.13, by rcnjko.
//
BOOLEAN
WDIFilterRtBss(
	PADAPTER		Adapter,
	PRT_WLAN_BSS	pRtBss
	)
{
	PRT_NDIS6_COMMON pNdisCommon = Adapter->pNdisCommon;
	BOOLEAN bAcceptable = TRUE;
	BOOLEAN bHasB, bHasG, bHasA;

	// Determine the capability of wireless mode of the BSS.
	bHasB = WDIWithWirelessB(pRtBss);
	bHasG = WDIWithWirelessG(pRtBss);
	bHasA = WDIWithWirelessA(pRtBss);

	// <RJ_TODO>
	// 1. Maybe we may need to use a table in the future.
	// 2. Currently, we only consider B/G case.
	if( bHasB && !bHasG && !bHasA )
	{ // The BSS is pure B.
		if( pNdisCommon->RegWirelessMode4ScanList == WIRELESS_MODE_G ||
			pNdisCommon->RegWirelessMode4ScanList == WIRELESS_MODE_A )
		{ // We are pure A or pure G.
			bAcceptable = FALSE;
		}
	}

	if(pRtBss->IE.Length <= sizeof(RT_FIXED_IE_FIELD))
		bAcceptable = FALSE;

	return bAcceptable;
}

static
VOID
wdiext_IndicateP2PDeviceFound(
	IN	ADAPTER		*pAdapter,
	IN	VOID 		*pvDev
	)
{
	WDI_INDICATION_BSS_ENTRY_LIST_PARAMETERS param;
	WDI_BSS_ENTRY_CONTAINER	entry;
	LARGE_INTEGER	CurrentTime;

	P2P_DEV_LIST_ENTRY 			*dev = (P2P_DEV_LIST_ENTRY *)pvDev;
	P2P_FRAME_INFO				*finfo = NULL;

	u1Byte						*buf = NULL;
	ULONG						buflen = 0;

	NDIS_OID_REQUEST			*req = NULL;
	WDI_MESSAGE_HEADER 			*reqWdiHdr = NULL;

	u4Byte						devSpecCtx = 0x07060504;

	// get info of last rx frame
	if(RTIsListEmpty(&dev->rxFrameQ))
		return;

	if(!pAdapter->pPortCommonInfo->WdiData.TaskHandle.pNdisRequest)
		return;

	req = pAdapter->pPortCommonInfo->WdiData.TaskHandle.pNdisRequest;
	reqWdiHdr = (WDI_MESSAGE_HEADER *)req->DATA.METHOD_INFORMATION.InformationBuffer;

	finfo = (P2P_FRAME_INFO *)RTGetTailList(&dev->rxFrameQ);

	// zero
	PlatformZeroMemory(&param, sizeof(param));
	PlatformZeroMemory(&entry, sizeof(entry));

	// optional
	param.Optional.DeviceDescriptor_IsPresent = TRUE;

	// ArrayOfElementsOfWIFI_BSS_ENTRY_CONTAINER DeviceDescriptor
	param.DeviceDescriptor.ElementCount = 1;
	param.DeviceDescriptor.pElements = &entry;

	// WIFI_MAC_ADDRESS_CONTAINER BSSID
	cpMacAddr(entry.BSSID.Address, finfo->msg->bssid);

	// Get current timestamp
	NdisGetCurrentSystemTime(&CurrentTime);

	// WIFI_BYTE_BLOB ProbeResponseFrame, BeaconFrame
	if(P2P_FID_BEACON == finfo->type)
	{
		entry.Optional.BeaconFrame_IsPresent = TRUE;
		entry.BeaconFrame.ElementCount = finfo->frameLen - sMacHdrLng;
		entry.BeaconFrame.pElements = (UINT8 *)finfo->frame + sMacHdrLng;
	}
	else if(P2P_FID_PROBE_RSP == finfo->type)
	{
		entry.Optional.ProbeResponseFrame_IsPresent = TRUE;
		entry.ProbeResponseFrame.ElementCount = finfo->frameLen - sMacHdrLng;
		entry.ProbeResponseFrame.pElements = (UINT8 *)finfo->frame + sMacHdrLng;
	}
	else
		return;

	// WDI_SIGNAL_INFO_CONTAINER SignalInfo
	entry.SignalInfo.RSSI = (INT32)(((finfo->sigStrength + 1) >> 1) - 95);
	entry.SignalInfo.LinkQuality = finfo->sigStrength;

	// WDI_CHANNEL_INFO_CONTAINER ChannelInfo
	entry.ChannelInfo.ChannelNumber = finfo->channel;
	entry.ChannelInfo.BandId = (finfo->channel < 36) ? WDI_BAND_ID_2400 : WDI_BAND_ID_5000;

	// WDI_BYTE_BLOB DeviceSpecificContext, this is OPTIONAL
	entry.Optional.DeviceSpecificContext_IsPresent = TRUE;
	entry.DeviceSpecificContext.ElementCount = sizeof(devSpecCtx);
	entry.DeviceSpecificContext.pElements = (UINT8 *)&devSpecCtx;

	// WDI_AGE_INFO_CONTAINER EntryAgeInfo
	entry.EntryAgeInfo.HostTimeStamp = CurrentTime.QuadPart;// [SDIO-482] in JIRA
	entry.EntryAgeInfo.CachedInformation = 0;

	// Gen tlv
	if(NDIS_STATUS_SUCCESS != GenerateWdiIndicationBssEntryList(
		&param,
		sizeof(NDIS_STATUS_INDICATION) + sizeof(WDI_MESSAGE_HEADER),
		&pAdapter->pPortCommonInfo->WdiData.TlvContext,
		&buflen, &((UINT8 *)buf)))
		return;

	wdi_UnsolicitedIndication(pAdapter,
							FALSE,
							(PVOID)req->RequestId,
							NDIS_STATUS_WDI_INDICATION_BSS_ENTRY_LIST,
							NDIS_STATUS_SUCCESS,
							buf,
							buflen);

	// cleanup
	FreeGenerated((UINT8 *)buf);

	return;
}

VOID
wdiext_IndicateP2PActionFrameReceived(
	IN	VOID 			*pvP2PInfo,
	IN	u4Byte 			eid,
	IN	MEMORY_BUFFER 	*info
	)
{
	P2P_INFO					*pP2PInfo = (P2P_INFO *)pvP2PInfo;
	ADAPTER						*pAdapter = pP2PInfo->pAdapter;

	P2P_EVENT_DATA 				*evtData = (P2P_EVENT_DATA *)info->Buffer;
	u4Byte						ieOffset = FRAME_OFFSET_P2P_PUB_ACT_ELEMENTS;
	RT_STATUS					rtStatus = RT_STATUS_SUCCESS;
	NDIS_STATUS					status = NDIS_STATUS_SUCCESS;

	u1Byte						*buf = NULL;
	ULONG						buflen = 0;

	WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED_PARAMETERS param = {0};

	FunctionIn(COMP_OID_SET);

	// prepare structure, ref N63CIndicateReceivedInvitationResponse
	rtStatus = (ieOffset < evtData->Packet.Length) ? RT_STATUS_SUCCESS : evtData->rtStatus;
	status = NdisStatusFromRtStatus(rtStatus);

	if(NDIS_STATUS_SUCCESS == status)
	{
		param.FrameInfo.Optional.DeviceContext_IsPresent = FALSE;

		if(P2P_EVENT_RECEIVED_PROVISION_DISCOVERY_REQUEST == eid)
			param.FrameInfo.FrameParams.ActionFrameType = WDI_P2P_ACTION_FRAME_PROVISION_DISCOVERY_REQUEST;
		else if(P2P_EVENT_RECEIVED_PROVISION_DISCOVERY_RESPONSE == eid)
			param.FrameInfo.FrameParams.ActionFrameType = WDI_P2P_ACTION_FRAME_PROVISION_DISCOVERY_RESPONSE;
		else if(P2P_EVENT_RECEIVED_GO_NEGOTIATION_REQUEST == eid)
			param.FrameInfo.FrameParams.ActionFrameType = WDI_P2P_ACTION_FRAME_GO_NEGOTIATION_REQUEST;
		else if(P2P_EVENT_RECEIVED_GO_NEGOTIATION_RESPONSE == eid)
			param.FrameInfo.FrameParams.ActionFrameType = WDI_P2P_ACTION_FRAME_GO_NEGOTIATION_RESPONSE;
		else if(P2P_EVENT_RECEIVED_GO_NEGOTIATION_CONFIRM == eid)
			param.FrameInfo.FrameParams.ActionFrameType = WDI_P2P_ACTION_FRAME_GO_NEGOTIATION_CONFIRM;
		else if(P2P_EVENT_RECEIVED_INVITATION_REQUEST == eid)
			param.FrameInfo.FrameParams.ActionFrameType = WDI_P2P_ACTION_FRAME_INVITATION_REQUEST;
		else if(P2P_EVENT_RECEIVED_INVITATION_RESPONSE == eid)
			param.FrameInfo.FrameParams.ActionFrameType = WDI_P2P_ACTION_FRAME_INVITATION_RESPONSE;
		else
			return;

		cpMacAddr(param.FrameInfo.FrameParams.PeerDeviceAddress.Address, evtData->Packet.Buffer + FRAME_OFFSET_ADDRESS2);
		param.FrameInfo.FrameParams.DialogToken = *(evtData->Packet.Buffer + FRAME_OFFSET_P2P_PUB_ACT_DIALOG_TOKEN);
		param.FrameInfo.FrameIEs.ElementCount = evtData->Packet.Length - ieOffset;
		param.FrameInfo.FrameIEs.pElements = evtData->Packet.Buffer + ieOffset;
	}

	// gen TLV
	if(NDIS_STATUS_SUCCESS != GenerateWdiIndicationP2pActionFrameReceived(
		&param,
		sizeof(NDIS_STATUS_INDICATION) + sizeof(WDI_MESSAGE_HEADER),
		&pAdapter->pPortCommonInfo->WdiData.TlvContext,
		&buflen, &((UINT8 *)buf)))
		return;

	wdi_UnsolicitedIndication(pAdapter,
							FALSE,
							NULL,
							NDIS_STATUS_WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED,
							NDIS_STATUS_SUCCESS,
							buf,
							buflen);

	// cleanup
	FreeGenerated((UINT8 *)buf);

	FunctionOut(COMP_OID_SET);

	return;
}

VOID
wdiext_IndicateBSSEntry(
	IN	PADAPTER	pAdapter
	)
{
	PMGNT_INFO									pMgntInfo = &(pAdapter->MgntInfo);
	WDI_INDICATION_BSS_ENTRY_LIST_PARAMETERS	param;
	WDI_BSS_ENTRY_CONTAINER					entry;
	RT_802_11_BSSID_LIST 						RtBssList = {0};
	PRT_WLAN_BSS								pRtBss = NULL;
	u4Byte										i = 0;
	ULONG										buflen = 0;
	u1Byte										*buf = NULL;
	NDIS_OID_REQUEST							*req = NULL;
	WDI_MESSAGE_HEADER 						*reqWdiHdr = NULL;
	u4Byte										devSpecCtx = 0x07060504;
	LARGE_INTEGER	CurrentTime;

	if(!pAdapter->pPortCommonInfo->WdiData.TaskHandle.pNdisRequest)
		return;

	FunctionIn(COMP_MLME);

	//Get scan list
	RtBssList.NumberOfItems = 0;
	RtBssList.pbssidentry = pAdapter->bssDescList;
	if( (pMgntInfo->bPrepareRoaming == TRUE) && (pMgntInfo->PrepareRoamState ==RT_PREPARE_ROAM_NORMAL_ROAM_BETTER_AP) )
	{
		RT_TRACE(COMP_MLME, DBG_LOUD, ("Skip scan triggered by Roam\n"));
		FunctionOut(COMP_MLME);
		return;
	}
	else
	{
#if BSS_LIST_CACHE
		MgntActQuery_802_11_BSSID_LIST(pAdapter, &RtBssList, FALSE);
#else
		RT_TRACE(COMP_MLME, DBG_LOUD, ("Indicate actual scan result of BSS list\n"));
		MgntActQuery_802_11_BSSID_LIST(pAdapter, &RtBssList, TRUE);
#endif
	}

	req = pAdapter->pPortCommonInfo->WdiData.TaskHandle.pNdisRequest;
	reqWdiHdr = (WDI_MESSAGE_HEADER *)req->DATA.METHOD_INFORMATION.InformationBuffer;

	//Indicate BSS entry one by one.
	for (i=0; i<RtBssList.NumberOfItems; i++)
	{
		if(RtBssList.pbssidentry[i].IE.Length <= sizeof(RT_FIXED_IE_FIELD))
		{
			continue;
		}
		pRtBss = &(RtBssList.pbssidentry[i]);

		// Determine if we shall report the BSS found by RegWirelessMode4ScanList.
		if(!WDIFilterRtBss(pAdapter, pRtBss))
		{
			// Skip this BSS.
			continue;
		}

		// zero
		PlatformZeroMemory(&param, sizeof(param));
		PlatformZeroMemory(&entry, sizeof(entry));

		// optional
		param.Optional.DeviceDescriptor_IsPresent = TRUE;

		// ArrayOfElementsOfWIFI_BSS_ENTRY_CONTAINER DeviceDescriptor
		param.DeviceDescriptor.ElementCount = 1;
		param.DeviceDescriptor.pElements = &entry;

		// WIFI_MAC_ADDRESS_CONTAINER BSSID
		cpMacAddr(entry.BSSID.Address, pRtBss->bdBssIdBuf);

		// WIFI_BYTE_BLOB ProbeResponseFrame, BeaconFrame
		if(pRtBss->BssPacketType & BSS_PKT_PROBE_RSP)
		{
			entry.Optional.ProbeResponseFrame_IsPresent = TRUE;
			entry.ProbeResponseFrame.ElementCount = pRtBss->IE.Length;
			entry.ProbeResponseFrame.pElements = (UINT8 *)pRtBss->IE.Octet;
		}
		else if(pRtBss->BssPacketType & BSS_PKT_BEACON)
		{
			entry.Optional.BeaconFrame_IsPresent = TRUE;
			entry.BeaconFrame.ElementCount = pRtBss->IE.Length;
			entry.BeaconFrame.pElements = (UINT8 *)pRtBss->IE.Octet;
		}
		else
		{
			FunctionOut(COMP_MLME);
			return;
		}

		// WDI_SIGNAL_INFO_CONTAINER SignalInfo
		pRtBss->RecvSignalPower = 0xffffffce;
		entry.SignalInfo.RSSI = (INT32)pRtBss->CumRecvSignalPower;
		entry.SignalInfo.LinkQuality = (UINT32)pRtBss->RSSI;

		// WDI_CHANNEL_INFO_CONTAINER ChannelInfo
		entry.ChannelInfo.ChannelNumber = (UINT32)pRtBss->ChannelNumber;
		entry.ChannelInfo.BandId = (pRtBss->ChannelNumber < 36) ? WDI_BAND_ID_2400 : WDI_BAND_ID_5000;
		RT_TRACE(COMP_MLME, DBG_LOUD, ("pRtBss->ChannelNumber=%d\n", pRtBss->ChannelNumber));

		// WDI_BYTE_BLOB DeviceSpecificContext, this is OPTIONAL
		entry.Optional.DeviceSpecificContext_IsPresent = TRUE;
		entry.DeviceSpecificContext.ElementCount = sizeof(devSpecCtx);
		entry.DeviceSpecificContext.pElements = (UINT8 *)&devSpecCtx;

		NdisGetCurrentSystemTime(&CurrentTime);

		// WDI_AGE_INFO_CONTAINER EntryAgeInfo
		entry.EntryAgeInfo.HostTimeStamp = CurrentTime.QuadPart;// [SDIO-482] in JIRA
		entry.EntryAgeInfo.CachedInformation = 0;

		// Gen tlv
		if(NDIS_STATUS_SUCCESS != GenerateWdiIndicationBssEntryList(
			&param,
			sizeof(NDIS_STATUS_INDICATION) + sizeof(WDI_MESSAGE_HEADER),
			&pAdapter->pPortCommonInfo->WdiData.TlvContext,
			&buflen, &((UINT8 *)buf)))
		{
			FunctionOut(COMP_MLME);
			return;
		}

		wdi_UnsolicitedIndication(pAdapter,
								FALSE,
								(PVOID)req->RequestId,
								NDIS_STATUS_WDI_INDICATION_BSS_ENTRY_LIST,
								NDIS_STATUS_SUCCESS,
								buf,
								buflen);

		// cleanup
		FreeGenerated((UINT8 *)buf);
	}

	FunctionOut(COMP_MLME);

	return;
}

VOID
wdiext_IndicateBSSEntryBySSID(
	IN	PADAPTER	pAdapter,
	IN	WDI_SSID	*pSSID
	)
{
	PMGNT_INFO									pMgntInfo = &(pAdapter->MgntInfo);
	WDI_INDICATION_BSS_ENTRY_LIST_PARAMETERS	param;
	WDI_BSS_ENTRY_CONTAINER						entry;
	RT_802_11_BSSID_LIST 						RtBssList = {0};
	PRT_WLAN_BSS								pRtBss = NULL;
	u4Byte										i = 0;
	ULONG										buflen = 0;
	u1Byte										*buf = NULL;
	NDIS_OID_REQUEST							*req = NULL;
	WDI_MESSAGE_HEADER 							*reqWdiHdr = NULL;
	u4Byte										devSpecCtx = 0x07060504;
	BOOL										bWildCardSSID = TRUE;
	LARGE_INTEGER	CurrentTime;

	if(!pAdapter->pPortCommonInfo->WdiData.TaskHandle.pNdisRequest)
		return;

	FunctionIn(COMP_MLME);

	if(pSSID->ElementCount != 0)
		bWildCardSSID = FALSE;

	//Get scan list
	RtBssList.NumberOfItems = 0;
	RtBssList.pbssidentry = pAdapter->bssDescList;
	if( (pMgntInfo->bPrepareRoaming == TRUE) && (pMgntInfo->PrepareRoamState ==RT_PREPARE_ROAM_NORMAL_ROAM_BETTER_AP) )
	{
		RT_TRACE(COMP_MLME, DBG_LOUD, ("Skip scan triggered by Roam\n"));
		FunctionOut(COMP_MLME);
		return;
	}
	else
	{
#if BSS_LIST_CACHE
		MgntActQuery_802_11_BSSID_LIST(pAdapter, &RtBssList, FALSE);
#else
		RT_TRACE(COMP_MLME, DBG_LOUD, ("Indicate actual scan result of BSS list\n"));
		MgntActQuery_802_11_BSSID_LIST(pAdapter, &RtBssList, TRUE);
#endif
	}

	req = pAdapter->pPortCommonInfo->WdiData.TaskHandle.pNdisRequest;
	reqWdiHdr = (WDI_MESSAGE_HEADER *)req->DATA.METHOD_INFORMATION.InformationBuffer;

	//Indicate BSS entry one by one.
	for (i=0; i<RtBssList.NumberOfItems; i++)
	{
		if(RtBssList.pbssidentry[i].IE.Length <= sizeof(RT_FIXED_IE_FIELD))
		{
			continue;
		}
		pRtBss = &(RtBssList.pbssidentry[i]);

		// Determine if we shall report the BSS found by RegWirelessMode4ScanList.
		if(!WDIFilterRtBss(pAdapter, pRtBss))
		{
			// Skip this BSS.
			continue;
		}

		if(!bWildCardSSID)
		{
			if(RtBssList.pbssidentry[i].bdSsIdLen != pSSID->ElementCount ||
				NdisEqualMemory(RtBssList.pbssidentry[i].bdSsIdBuf, pSSID->pElements, pSSID->ElementCount) == 0)
			{
				//UE specify SSID to update, skip this one
				continue;
			}
		}

		// zero
		PlatformZeroMemory(&param, sizeof(param));
		PlatformZeroMemory(&entry, sizeof(entry));

		// optional
		param.Optional.DeviceDescriptor_IsPresent = TRUE;

		// ArrayOfElementsOfWIFI_BSS_ENTRY_CONTAINER DeviceDescriptor
		param.DeviceDescriptor.ElementCount = 1;
		param.DeviceDescriptor.pElements = &entry;

		// WIFI_MAC_ADDRESS_CONTAINER BSSID
		cpMacAddr(entry.BSSID.Address, pRtBss->bdBssIdBuf);

		// WIFI_BYTE_BLOB ProbeResponseFrame, BeaconFrame
		if(pRtBss->BssPacketType & BSS_PKT_PROBE_RSP)
		{
			entry.Optional.ProbeResponseFrame_IsPresent = TRUE;
			entry.ProbeResponseFrame.ElementCount = pRtBss->IE.Length;
			entry.ProbeResponseFrame.pElements = (UINT8 *)pRtBss->IE.Octet;
		}
		else if(pRtBss->BssPacketType & BSS_PKT_BEACON)
		{
			entry.Optional.BeaconFrame_IsPresent = TRUE;
			entry.BeaconFrame.ElementCount = pRtBss->IE.Length;
			entry.BeaconFrame.pElements = (UINT8 *)pRtBss->IE.Octet;
		}
		else
		{
			FunctionOut(COMP_MLME);
			return;
		}

		// WDI_SIGNAL_INFO_CONTAINER SignalInfo
		pRtBss->RecvSignalPower = 0xffffffce;
		entry.SignalInfo.RSSI = (INT32)pRtBss->CumRecvSignalPower;
		entry.SignalInfo.LinkQuality = (UINT32)pRtBss->RSSI;

		// WDI_CHANNEL_INFO_CONTAINER ChannelInfo
		entry.ChannelInfo.ChannelNumber = (UINT32)pRtBss->ChannelNumber;
		entry.ChannelInfo.BandId = (pRtBss->ChannelNumber < 36) ? WDI_BAND_ID_2400 : WDI_BAND_ID_5000;
		RT_TRACE(COMP_MLME, DBG_LOUD, ("pRtBss->ChannelNumber=%d\n", pRtBss->ChannelNumber));

		// WDI_BYTE_BLOB DeviceSpecificContext, this is OPTIONAL
		entry.Optional.DeviceSpecificContext_IsPresent = TRUE;
		entry.DeviceSpecificContext.ElementCount = sizeof(devSpecCtx);
		entry.DeviceSpecificContext.pElements = (UINT8 *)&devSpecCtx;

		NdisGetCurrentSystemTime(&CurrentTime);

		// WDI_AGE_INFO_CONTAINER EntryAgeInfo
		entry.EntryAgeInfo.HostTimeStamp = CurrentTime.QuadPart;// [SDIO-482] in JIRA
		entry.EntryAgeInfo.CachedInformation = 0;

		// Gen tlv
		if(NDIS_STATUS_SUCCESS != GenerateWdiIndicationBssEntryList(
			&param,
			sizeof(NDIS_STATUS_INDICATION) + sizeof(WDI_MESSAGE_HEADER),
			&pAdapter->pPortCommonInfo->WdiData.TlvContext,
			&buflen, &((UINT8 *)buf)))
		{
			FunctionOut(COMP_MLME);
			return;
		}

		wdi_UnsolicitedIndication(pAdapter,
								FALSE,
								(PVOID)req->RequestId,
								NDIS_STATUS_WDI_INDICATION_BSS_ENTRY_LIST,
								NDIS_STATUS_SUCCESS,
								buf,
								buflen);

		// cleanup
		FreeGenerated((UINT8 *)buf);
	}

	FunctionOut(COMP_MLME);

	return;
}


VOID
wdiext_IndicateAssociationResult(
	IN	PADAPTER	pAdapter
	)
{
	PMGNT_INFO									pMgntInfo = &(pAdapter->MgntInfo);
	WDI_INDICATION_ASSOCIATION_RESULT_LIST	AsocResultList;
	WDI_ASSOCIATION_RESULT_CONTAINER			AsocResult;
	RT_AUTH_MODE								AuthMode = RT_802_11AuthModeOpen;
	u4Byte										AuthAlgo = 0, UnicastCipher = 0, McastDataCipher = 0, McastMgntCipher = 0;
	u1Byte										FourAddrSupport = FALSE, PortAuthorized = FALSE, WMMQos = FALSE;
	u4Byte										DSInfo = 0, AssocComeBackTime = 0, BandID = 0;
	WDI_PHY_TYPE								PhyType = WDI_PHY_TYPE_UNKNOWN;
	PUCHAR										pOutput = NULL;
	ULONG										length = 0;
	NDIS_STATUS									ndisStatus = NDIS_STATUS_SUCCESS;

	MgntActQuery_802_11_AUTHENTICATION_MODE( pAdapter, &AuthMode );
	AuthAlgo = N6CAuthModeToDot11( &AuthMode );
	UnicastCipher = N6CEncAlgorithmToDot11( &(pMgntInfo->SecurityInfo.PairwiseEncAlgorithm) );
	McastDataCipher = N6CEncAlgorithmToDot11( &(pMgntInfo->SecurityInfo.GroupEncAlgorithm) );
	if( pMgntInfo->bInBIPMFPMode && TEST_FLAG(pMgntInfo->targetAKMSuite, AKM_RSNA_1X_SHA256 | AKM_RSNA_PSK_SHA256))
		McastMgntCipher = WDI_CIPHER_ALGO_BIP;
	else
		McastMgntCipher = WDI_CIPHER_ALGO_NONE;		// PMF ?
	WMMQos = (pMgntInfo->pStaQos->QosCapability > QOS_DISABLE)?TRUE:FALSE;

	RT_TRACE(COMP_MLME, DBG_LOUD, ("wdiext_IndicateAssociationResult WMMQos = %d\n", WMMQos));
	DSInfo = WDI_DS_UNKNOWN;
	if( pMgntInfo->RspStatusCode == 30 && pMgntInfo->TIE.Length != 0)
	{
		if(pMgntInfo->TIE.Octet[0] == 3 )
		{
			AssocComeBackTime = (u4Byte)(pMgntInfo->TIE.Octet[1] & 0xff);
			AssocComeBackTime += (u4Byte)(pMgntInfo->TIE.Octet[2] << 8) & 0xff;
			AssocComeBackTime += (u4Byte)(pMgntInfo->TIE.Octet[3] << 16) & 0xff;
			AssocComeBackTime += (u4Byte)(pMgntInfo->TIE.Octet[4] << 24) & 0xff;
		}
		else
			AssocComeBackTime = 0;
	}
	else
		AssocComeBackTime = 0;
	if(pMgntInfo->dot11CurrentChannelNumber < 36)
		BandID = WDI_BAND_ID_2400;
	else
		BandID = WDI_BAND_ID_5000;

	switch (pMgntInfo->dot11CurrentWirelessMode)
	{
		default:
			PhyType = WDI_PHY_TYPE_OFDM;
			break;

		case WIRELESS_MODE_A:
			PhyType = WDI_PHY_TYPE_OFDM;
			break;

		case WIRELESS_MODE_G:
			PhyType = WDI_PHY_TYPE_ERP;
			break;

		case WIRELESS_MODE_B:
			PhyType = WDI_PHY_TYPE_HRDSSS;
			break;

		case WIRELESS_MODE_N_24G:
		case WIRELESS_MODE_N_5G:
		case WIRELESS_MODE_AUTO:
			PhyType = WDI_PHY_TYPE_HT;
			break;

		case WIRELESS_MODE_AC_5G:
		case WIRELESS_MODE_AC_ONLY:
		case WIRELESS_MODE_AC_24G:
			PhyType = WDI_PHY_TYPE_VHT;
			break;


	}

	PlatformZeroMemory(&AsocResult, sizeof(WDI_ASSOCIATION_RESULT_CONTAINER));

	PlatformMoveMemory(AsocResult.BSSID.Address, pMgntInfo->Bssid, 6);
	AsocResultList.AssociationResults.ElementCount = 1;
	AsocResultList.AssociationResults.pElements = &AsocResult;
	AsocResult.AssociationResultParameters.AssociationStatus = (pMgntInfo->mAssoc)?WDI_ASSOC_STATUS_SUCCESS:WDI_ASSOC_STATUS_FAILURE;
	AsocResult.AssociationResultParameters.StatusCode = pMgntInfo->RspStatusCode;
	AsocResult.AssociationResultParameters.ReAssociation = pMgntInfo->AsocInfo.FlagReAsocReq;
	AsocResult.AssociationResultParameters.AuthAlgorithm = AuthAlgo;
	AsocResult.AssociationResultParameters.UnicastCipherAlgorithm = UnicastCipher;
	AsocResult.AssociationResultParameters.MulticastDataCipherAlgorithm = McastDataCipher;
	AsocResult.AssociationResultParameters.MulticastMgmtCipherAlgorithm = McastMgntCipher;
	AsocResult.AssociationResultParameters.FourAddressSupported = FourAddrSupport;
	AsocResult.AssociationResultParameters.PortAuthorized = PortAuthorized;
	AsocResult.AssociationResultParameters.WMMQoSEnabled = WMMQos;
	AsocResult.AssociationResultParameters.DSInfo = DSInfo;
	AsocResult.AssociationResultParameters.AssociationComebackTime = AssocComeBackTime;
	AsocResult.AssociationResultParameters.BandID = BandID;
	AsocResult.Optional.AssociationRequestFrame_IsPresent = TRUE;
	AsocResult.AssociationRequestFrame.ElementCount = MMPDU_BODY_LEN(pMgntInfo->AsocInfo.AsocReqLength);
	AsocResult.AssociationRequestFrame.pElements = MMPDU_BODY(pMgntInfo->AsocInfo.AsocReq);
	AsocResult.Optional.AssociationResponseFrame_IsPresent = TRUE;
	AsocResult.AssociationResponseFrame.ElementCount = MMPDU_BODY_LEN(pMgntInfo->AsocInfo.AsocRespLength);
	AsocResult.AssociationResponseFrame.pElements = MMPDU_BODY(pMgntInfo->AsocInfo.AsocResp);
	AsocResult.Optional.BeaconProbeResponse_IsPresent = TRUE;
	AsocResult.BeaconProbeResponse.ElementCount = MMPDU_BODY_LEN(pMgntInfo->AsocInfo.BeaconLength);
	AsocResult.BeaconProbeResponse.pElements = MMPDU_BODY(pMgntInfo->AsocInfo.Beacon);
#if 0
	AsocResult.Optional.ActivePhyTypeList_IsPresent = TRUE;
#endif
	AsocResult.ActivePhyTypeList.ElementCount = 1;
	AsocResult.ActivePhyTypeList.pElements = &PhyType;

	ndisStatus = GenerateWdiIndicationAssociationResult(
					&AsocResultList,
					sizeof(NDIS_STATUS_INDICATION)+sizeof(WDI_MESSAGE_HEADER),
					&pAdapter->pPortCommonInfo->WdiData.TlvContext,
					&length,
					&pOutput);
	if(NDIS_STATUS_SUCCESS == ndisStatus)
	{
		RT_TRACE(COMP_MLME, DBG_LOUD, ("GenerateWdiIndicationAssociationResult(): return length %d\n", length));
		RT_PRINT_DATA(COMP_MLME, DBG_TRACE, ("buffer\n"), pOutput, length);
		RT_TRACE(COMP_MLME, DBG_LOUD, ("SendUnsolictedIndication(): EthertypeEncapTable_IsPresent %d\n", AsocResult.Optional.EthertypeEncapTable_IsPresent));

		ndisStatus = WDI_AddDatapathPeer(pAdapter, AsocResult.BSSID.Address);

		wdi_UnsolicitedIndication(pAdapter,
								FALSE,
								(PVOID)pAdapter->pPortCommonInfo->WdiData.TaskHandle.pNdisRequest->RequestId,
								NDIS_STATUS_WDI_INDICATION_ASSOCIATION_RESULT,
								NDIS_STATUS_SUCCESS,
								pOutput,
								length);

		FreeGenerated(pOutput);
	}
	else
	{
		RT_TRACE(COMP_MLME, DBG_LOUD, ("GenerateWdiIndicationAssociationResult(): generate TLV failure\n"));
	}

	if( NDIS_STATUS_SUCCESS != ndisStatus )
	{
		RT_TRACE(COMP_MLME, DBG_WARNING, ("wdiext_IndicateAssociationResult: fail to create peer, so disconnect with this AP[%2x:%2x:%2x:%2x:%2x:%2x]\n", AsocResult.BSSID.Address[0],AsocResult.BSSID.Address[1],AsocResult.BSSID.Address[2], AsocResult.BSSID.Address[3], AsocResult.BSSID.Address[4], AsocResult.BSSID.Address[5]));
		MgntDisconnectAP(pAdapter, inactivity);
	}
}

//
// Description:
//	Indicate unsolicited event WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED to WDI.
//
RT_STATUS
wdiext_IndicateFtAssocNeeded(
	IN	PADAPTER	pAdapter
	)
{
	RT_STATUS											rtStatus = RT_STATUS_SUCCESS;
	NDIS_STATUS											ndisStatus = NDIS_STATUS_SUCCESS;
	PMGNT_INFO											pMgntInfo = &(pAdapter->MgntInfo);
	WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS	param;
	pu1Byte												pIndicBuf = NULL;
	ULONG												indicBufLen = 0;

	PlatformZeroMemory(&param, sizeof(WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS));

	do
	{
		if(pMgntInfo->AsocInfo.AuthSeq1Length < sMacHdrLng)
		{
			RT_TRACE_F(COMP_INDIC, DBG_WARNING, ("Too short of AuthSeq2Length = %d\n", pMgntInfo->AsocInfo.AuthSeq1Length));
			rtStatus = RT_STATUS_INVALID_DATA;
			break;
		}

		if(pMgntInfo->AsocInfo.AuthSeq2Length < sMacHdrLng)
		{
			RT_TRACE_F(COMP_INDIC, DBG_WARNING, ("Too short of AuthSeq2Length = %d\n", pMgntInfo->AsocInfo.AuthSeq2Length));
			rtStatus = RT_STATUS_INVALID_DATA;
			break;
		}

		cpMacAddr(param.BssId.Address, pMgntInfo->Bssid);

		param.AuthRequest.ElementCount = MMPDU_BODY_LEN(pMgntInfo->AsocInfo.AuthSeq1Length);
		param.AuthRequest.pElements = MMPDU_BODY(pMgntInfo->AsocInfo.AuthSeq1);

		param.AuthResponse.ElementCount = MMPDU_BODY_LEN(pMgntInfo->AsocInfo.AuthSeq2Length);
		param.AuthResponse.pElements = MMPDU_BODY(pMgntInfo->AsocInfo.AuthSeq2);

		// Gen tlv
		if(NDIS_STATUS_SUCCESS != (ndisStatus =
			GenerateWdiIndicationFtAssocParamsNeeded(
				&param,
				sizeof(NDIS_STATUS_INDICATION) + sizeof(WDI_MESSAGE_HEADER),
				&pAdapter->pPortCommonInfo->WdiData.TlvContext,
				&indicBufLen,
				&((UINT8 *)pIndicBuf))))
		{
			RT_TRACE_F(COMP_INDIC, DBG_SERIOUS, ("Fail (ndisStatus = 0x%08X) from GenerateWdiIndicationFtAssocParamsNeeded()\n", ndisStatus));
			rtStatus = RT_STATUS_OS_API_FAILED;
			break;
		}

		RT_PRINT_DATA(COMP_INDIC, DBG_LOUD, "NDIS_STATUS_WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED:\n", pIndicBuf, indicBufLen);
		wdi_UnsolicitedIndication(pAdapter,
							FALSE,
							NULL,
							NDIS_STATUS_WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED,
							NDIS_STATUS_SUCCESS,
							pIndicBuf,
							indicBufLen);
	}while(FALSE);

	if(pIndicBuf)
	{
		// cleanup
		FreeGenerated((UINT8 *)pIndicBuf);
	}

	return rtStatus;
}

VOID
wdiext_IndicateDisassociation(
	IN	ADAPTER		*pAdapter,
	IN	u1Byte		*addr,
	IN	u4Byte		frameLen,
	IN	u1Byte		*frame,
	IN	BOOLEAN		bDisassoc,
	IN	u2Byte		reason
	)
{
	WDI_INDICATION_DISASSOCIATION_PARAMETERS param;

	u1Byte						*buf = NULL;
	ULONG						buflen = 0;

	if(0 < frameLen && frameLen < sMacHdrLng)
	{
		RT_TRACE_F(COMP_OID_SET, DBG_LOUD, ("invalid deauth/disassociation len: %u\n", frameLen));
		return;
	}

	PlatformZeroMemory(&param, sizeof(param));

	param.Optional.DeauthFrame_IsPresent = (FALSE == bDisassoc) && frameLen;
	param.Optional.DisassociationFrame_IsPresent = (TRUE == bDisassoc) && frameLen;
	param.Optional.NeedPeerStateCleanup_IsPresent = FALSE;

	cpMacAddr(param.DisconnectIndicationParameters.MacAddress.Address, addr);
	param.DisconnectIndicationParameters.DisassociationWABIReason = bDisassoc
		? WDI_ASSOC_STATUS_PEER_DISASSOCIATED
		: WDI_ASSOC_STATUS_PEER_DEAUTHENTICATED;

	if(frameLen)
	{
		if(bDisassoc)
		{
			param.DisassociationFrame.ElementCount = frameLen - sMacHdrLng;
			param.DisassociationFrame.pElements = frame + sMacHdrLng;
		}
		else
		{
			param.DeauthFrame.ElementCount = frameLen - sMacHdrLng;
			param.DeauthFrame.pElements = frame + sMacHdrLng;
		}
	}

	// Gen tlv
	if(NDIS_STATUS_SUCCESS != GenerateWdiIndicationDisassociation(
		&param,
		sizeof(NDIS_STATUS_INDICATION) + sizeof(WDI_MESSAGE_HEADER),
		&pAdapter->pPortCommonInfo->WdiData.TlvContext,
		&buflen, &((UINT8 *)buf)))
		return;

	wdi_UnsolicitedIndication(pAdapter,
							FALSE,
							NULL,
							NDIS_STATUS_WDI_INDICATION_DISASSOCIATION,
							NDIS_STATUS_SUCCESS,
							buf,
							buflen);

	// cleanup
	FreeGenerated((UINT8 *)buf);

	return;
}

VOID
wdiext_IndicateRadioStatus(
	IN	PADAPTER	pAdapter
	)
{
	PMGNT_INFO									pMgntInfo = &(pAdapter->MgntInfo);
	WDI_INDICATION_RADIO_STATUS_PARAMETERS	Params = {0};
	PUCHAR										pOutput = NULL;
	ULONG										length = 0;
	NDIS_STATUS									ndisStatus = NDIS_STATUS_SUCCESS;
	PWDI_DATA_STRUCT							pWdi = &(pAdapter->pPortCommonInfo->WdiData);
	PRT_OID_HANDLER							pOidHandle = &(pWdi->TaskHandle);

	Params.RadioState.SoftwareState = (pMgntInfo->RfOffReason&RF_CHANGE_BY_SW)?0:1;
	Params.RadioState.HardwareState = (pMgntInfo->RfOffReason&RF_CHANGE_BY_HW)?0:1;

	RT_TRACE(COMP_RF, DBG_LOUD, ("wdiext_IndicateRadioStatus(): Params.RadioState.SoftwareState is %d, Params.RadioState.HardwareState is %d\n", Params.RadioState.SoftwareState, Params.RadioState.HardwareState));

	ndisStatus = GenerateWdiIndicationRadioStatus(
				&Params,
				sizeof(NDIS_STATUS_INDICATION) + sizeof(WDI_MESSAGE_HEADER),
				&pAdapter->pPortCommonInfo->WdiData.TlvContext,
				&length,
				&pOutput);

	if(NDIS_STATUS_SUCCESS == ndisStatus)
	{
		wdi_UnsolicitedIndication(pAdapter,
							TRUE,
							NULL,
							NDIS_STATUS_WDI_INDICATION_RADIO_STATUS,
							NDIS_STATUS_SUCCESS,
							pOutput,
							length);

		FreeGenerated(pOutput);
		pOutput = NULL;
	}
	ndisStatus = NDIS_STATUS_NOT_SUPPORTED;
}

VOID
wdiext_IndicateLinkStateChanged(
	IN	PADAPTER	pAdapter,
	IN	BOOLEAN		bForceLinkQuality,
	IN	u1Byte		ucLinkQuality
	)
{
	PMGNT_INFO										pMgntInfo = &(pAdapter->MgntInfo);
	WDI_INDICATION_LINK_STATE_CHANGE_PARAMETERS	Params = {0};
	PUCHAR											pOutput = NULL;
	ULONG											length = 0;
	NDIS_STATUS										ndisStatus = NDIS_STATUS_SUCCESS;

	if (pMgntInfo->mAssoc || pMgntInfo->mIbss)
	{
		Params.LinkStateChangeParameters.LinkQuality = GetSignalQuality(pAdapter);
	}
	else
	{
		Params.LinkStateChangeParameters.LinkQuality = 0;
	}

	if(bForceLinkQuality)
	{
		Params.LinkStateChangeParameters.LinkQuality = ucLinkQuality;
	}

	Params.LinkStateChangeParameters.TxLinkSpeed = MgntActQuery_RT_11N_USER_SHOW_RATES(pAdapter , pMgntInfo->bForcedShowRxRate, FALSE)*1000/2;
	Params.LinkStateChangeParameters.RxLinkSpeed = pMgntInfo->HighestOperaRate*1000/2;
	cpMacAddr(Params.LinkStateChangeParameters.PeerMACAddress.Address, pMgntInfo->Bssid);

	RT_TRACE(COMP_MLME, DBG_LOUD, ("wdiext_IndicateLinkStateChanged(): Params.LinkStateChangeParameters.TxLinkSpeed is %d\n", Params.LinkStateChangeParameters.TxLinkSpeed));
	RT_TRACE(COMP_MLME, DBG_LOUD, ("wdiext_IndicateLinkStateChanged(): Params.LinkStateChangeParameters.RxLinkSpeed is %d\n", Params.LinkStateChangeParameters.RxLinkSpeed));

	ndisStatus = GenerateWdiIndicationLinkStateChange(
				&Params,
				sizeof(NDIS_STATUS_INDICATION)+sizeof(WDI_MESSAGE_HEADER),
				&pAdapter->pPortCommonInfo->WdiData.TlvContext,
				&length,
				&pOutput);

	if(NDIS_STATUS_SUCCESS == ndisStatus)
	{
		wdi_UnsolicitedIndication(pAdapter,
								FALSE,
								NULL,
								NDIS_STATUS_WDI_INDICATION_LINK_STATE_CHANGE,
								ndisStatus,
								pOutput,
								length);

		FreeGenerated(pOutput);
		pOutput = NULL;
	}
}

VOID
wdiext_IndicateRoamingNeeded(
	IN	PADAPTER	pAdapter,
	IN	u2Byte		IndicationReason
	)
{
	PMGNT_INFO										pMgntInfo = &(pAdapter->MgntInfo);
	WDI_INDICATION_ROAMING_NEEDED_PARAMETERS		Params = {0};
	PUCHAR											pOutput = NULL;
	ULONG											length = 0;
	NDIS_STATUS										ndisStatus = NDIS_STATUS_SUCCESS;

	pMgntInfo->bPrepareRoaming = TRUE;

	Params.RoamingReason = IndicationReason;
	RT_TRACE_F(COMP_MLME, DBG_LOUD, ("Params.RoamingReason %d\n", Params.RoamingReason));

	ndisStatus = GenerateWdiIndicationRoamingNeeded(
				&Params,
				sizeof(NDIS_STATUS_INDICATION)+sizeof(WDI_MESSAGE_HEADER),
				&pAdapter->pPortCommonInfo->WdiData.TlvContext,
				&length,
				&pOutput);

	if(NDIS_STATUS_SUCCESS == ndisStatus)
	{
		wdi_UnsolicitedIndication(pAdapter,
								FALSE,
								NULL,
								NDIS_STATUS_WDI_INDICATION_ROAMING_NEEDED,
								ndisStatus,
								pOutput,
								length);

		FreeGenerated(pOutput);
		pOutput = NULL;
	}
}

static
VOID
wdiext_IndicateP2POpChnl(
	IN  ADAPTER					*pAdapter,
	IN	P2P_INFO				*pP2PInfo
	)
{
	WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL_PARAMETERS param;

	u1Byte						*buf = NULL;
	ULONG						buflen = 0;

	NDIS_OID_REQUEST			*req = NULL;
	WDI_MESSAGE_HEADER 			*reqWdiHdr = NULL;

	if(!pAdapter->pPortCommonInfo->WdiData.TaskHandle.pNdisRequest)
		return;

	req = pAdapter->pPortCommonInfo->WdiData.TaskHandle.pNdisRequest;
	reqWdiHdr = (WDI_MESSAGE_HEADER *)req->DATA.METHOD_INFORMATION.InformationBuffer;

	// zero
	PlatformZeroMemory(&param, sizeof(param));

	// fill
	PlatformMoveMemory(param.Channel.CountryOrRegionString, pP2PInfo->CountryString, sizeof(pP2PInfo->CountryString));
	param.Channel.OperatingClass = pP2PInfo->RegulatoryClass;
	param.Channel.ChannelNumber = pP2PInfo->OperatingChannel;

	param.IndicateReason = WDI_P2P_CHANNEL_INDICATE_REASON_NEW_CONNECTION;
	if(pP2PInfo->bChannelSwitch)
	{
		param.IndicateReason = pP2PInfo->P2PChannelIndicationReason;
	}

	// Gen tlv
	if(NDIS_STATUS_SUCCESS != GenerateWdiIndicationP2pGroupOperatingChannel(
		&param,
		sizeof(NDIS_STATUS_INDICATION) + sizeof(WDI_MESSAGE_HEADER),
		&pAdapter->pPortCommonInfo->WdiData.TlvContext,
		&buflen, &((UINT8 *)buf)))
		return;

	wdi_UnsolicitedIndication(pAdapter,
							FALSE,
							(PVOID)req->RequestId,
							NDIS_STATUS_WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL,
							NDIS_STATUS_SUCCESS,
							buf,
							buflen);

	// cleanup
	FreeGenerated((UINT8 *)buf);

	return;
}


PVOID
wdi_FindGroupPeerByPort(
	IN	PADAPTER	pAdapter,
	IN	u2Byte		PortNumber
)
{
	PADAPTER			pDefaultAdapter = GetDefaultAdapter(pAdapter);
	PRT_PEER_ENTRY		pPeerEntry = NULL;
	u1Byte				i;

	for(i = 0; i < MP_DEFAULT_NUMBER_OF_PORT; i++)
	{
		pPeerEntry = &pDefaultAdapter->RxPeerTable[i];
		if( pPeerEntry->bUsed == TRUE )
		{
			if( pPeerEntry->uPortId == PortNumber )
			{
				return (PVOID)pPeerEntry;
			}
		}
	}

	return NULL;
}

PVOID
wdi_FindPeerByAddr(
	IN	PADAPTER		pAdapter,
	IN	pu1Byte			pAddr
)
{
	PADAPTER		pDefaultAdapter = GetDefaultAdapter(pAdapter);
	PRT_PEER_ENTRY	pPeerEntry = NULL;
	u1Byte			i = 0, count = 0;

	count = pDefaultAdapter->RxPeerUsedCount;
	for(i = MP_DEFAULT_NUMBER_OF_PORT; i < MAX_PEER_NUM; i++)
	{
		if( count == 0 )
			break;

		pPeerEntry = &pDefaultAdapter->RxPeerTable[i];
		if( pPeerEntry->bUsed == TRUE )
		{
			count--;
			if( PlatformCompareMemory(pPeerEntry->PeerAddr, pAddr, 6) == 0 )
			{
				return (PVOID)pPeerEntry;
			}
		}
	}

	return NULL;
}

PVOID
wdi_GetAvailablePeer(
	IN	PADAPTER		pAdapter,
	IN	pu1Byte			pAddr
)
{
	PADAPTER		pDefaultAdapter = GetDefaultAdapter(pAdapter);
	WDI_PORT_ID	PortId = (WDI_PORT_ID)pAdapter->pNdis62Common->PortNumber;
	PRT_PEER_ENTRY	pCurPeerEntry = NULL, pPeerEntry = NULL;
	u1Byte			i = 0, UnusedIndex = 0, count = 0;
	BOOLEAN			bFound = FALSE;

	FunctionIn(COMP_MLME);

	count = pDefaultAdapter->RxPeerUsedCount;

	for(i = MP_DEFAULT_NUMBER_OF_PORT; i < MAX_PEER_NUM; i++)
	{
		if( (count == 0) && (bFound == TRUE) )
			break;

		pPeerEntry = &pDefaultAdapter->RxPeerTable[i];

		if( (pPeerEntry->bUsed == FALSE) && (bFound == FALSE) )
		{
			bFound = TRUE;
			UnusedIndex = i;
		}
		else if( pPeerEntry->bUsed == TRUE )
		{
			count--;
			if( PlatformCompareMemory(pPeerEntry->PeerAddr, pAddr, 6) == 0 )
			{
				RT_TRACE(COMP_MLME, DBG_WARNING, ("wdi_GetAvailablePeer: The addres [%2x:%2x:%2x:%2x:%2x:%2x] had associated with specified Peer %d\n", pAddr[0], pAddr[1], pAddr[2], pAddr[3], pAddr[4], pAddr[5], pPeerEntry->uPeerId));
				FunctionOut(COMP_MLME);
				return (PVOID)pPeerEntry;
			}
		}
	}

	if( (i == MAX_PEER_NUM) && (bFound == FALSE) )
	{
		RT_TRACE(COMP_MLME, DBG_WARNING, ("wdi_GetAvailablePeer: Peer is already full, so cannot find an unused peer to associate [%2x:%2x:%2x:%2x:%2x:%2x]\n", pAddr[0], pAddr[1], pAddr[2], pAddr[3], pAddr[4], pAddr[5]));
		FunctionOut(COMP_MLME);
		return NULL;
	}

	pDefaultAdapter->RxPeerUsedCount++;

	pCurPeerEntry = &pDefaultAdapter->RxPeerTable[UnusedIndex];
	pCurPeerEntry->bUsed = TRUE;
	pCurPeerEntry->uPeerId = UnusedIndex;
	pCurPeerEntry->uPortId = (u2Byte)PortId;
	PlatformMoveMemory(pCurPeerEntry->PeerAddr, pAddr, 6);

	RT_TRACE(COMP_MLME, DBG_LOUD, ("wdi_GetAvailablePeer: Port %d associate the addres [%2x:%2x:%2x:%2x:%2x:%2x] at Peer %d\n", (u2Byte)PortId, pAddr[0], pAddr[1], pAddr[2], pAddr[3], pAddr[4], pAddr[5], UnusedIndex));

	FunctionOut(COMP_MLME);

	return (PVOID)pCurPeerEntry;
}

VOID
wdi_NotifyPeerData(
	IN	PADAPTER				pAdapter,
	IN	u1Byte					ExTid,
	IN	u2Byte					Pid,
	IN	RT_RX_INDICATION_LEVEL	level,
	IN	PNDIS_STATUS			pNdisStatus
)
{
	PWDI_DATA_STRUCT	pWdi = &(pAdapter->pPortCommonInfo->WdiData);
	PADAPTER			pDefaultAdapter = GetDefaultAdapter(pAdapter);
	PRT_NDIS6_COMMON	pDefaultNdisCommon = pDefaultAdapter->pNdisCommon;
	PADAPTER			pTempAdapter = NULL;
	PRT_NDIS6_COMMON	pNdisCommon = pAdapter->pNdisCommon;
	WDI_PEER_ID			PeerId = (WDI_PEER_ID)Pid;
	WDI_EXTENDED_TID	ExtendTid = (WDI_EXTENDED_TID)ExTid;
	KIRQL				Irql = 0;
	BOOLEAN				bLackResource = FALSE;

	PlatformAcquireSpinLock(pAdapter, RT_RX_CONTROL_SPINLOCK);
	if( (pNdisCommon->bRxControlState != RT_RX_STOP) && (pDefaultNdisCommon->bRxDataPathState != RT_RX_PAUSE) )
	{
		pNdisCommon->bRxControlState = RT_RX_NOTIFYING;
		PlatformReleaseSpinLock(pAdapter, RT_RX_CONTROL_SPINLOCK);

		PlatformAcquireSpinLock(pAdapter, RT_RX_SPINLOCK);
		bLackResource = RxCheckResource(pAdapter)?FALSE:TRUE;
		PlatformReleaseSpinLock(pAdapter, RT_RX_SPINLOCK);

		if( bLackResource )
			RT_TRACE(COMP_RECV, DBG_WARNING, ("wdi_NotifyPeerData(): RFD is less than lower bound (%d)\n", RFD_LOWER_BOUND));

		Irql =	KeGetCurrentIrql();
		// Prefast warning C6387: '_Param_(5)' could be '0':  this does not adhere to the specification for the function 'RxInorderDataIndication'.
		// False positive, caller gurantee pNdisStatus valid.
#pragma warning( disable:6387 )
		if(Irql > PASSIVE_LEVEL )
		{
			RT_TRACE(COMP_RECV, DBG_TRACE, ("wdi_NotifyPeerData(): it is DISPATCH level\n"));
			if( bLackResource )
				pWdi->WdiDataApi.RxInorderDataIndication(pWdi->DataPathHandle, WDI_RX_INDICATION_DISPATCH_GENERAL_WITH_LOW_RESOURCES, PeerId, ExtendTid, NULL, pNdisStatus);
			else
				pWdi->WdiDataApi.RxInorderDataIndication(pWdi->DataPathHandle, WDI_RX_INDICATION_DISPATCH_GENERAL, PeerId, ExtendTid, NULL, pNdisStatus);
		}
		else
		{
			RT_TRACE(COMP_RECV, DBG_TRACE, ("wdi_NotifyPeerData(): it is PASSIVE level\n"));
			if( bLackResource )
				pWdi->WdiDataApi.RxInorderDataIndication(pWdi->DataPathHandle, WDI_RX_INDICATION_PASSIVE_WITH_LOW_RESOURCES, PeerId, ExtendTid, NULL, pNdisStatus);
			else
				pWdi->WdiDataApi.RxInorderDataIndication(pWdi->DataPathHandle, WDI_RX_INDICATION_PASSIVE, PeerId, ExtendTid, NULL, pNdisStatus);
		}

		PlatformAcquireSpinLock(pAdapter, RT_RX_CONTROL_SPINLOCK);
		if( pNdisCommon->bRxControlState == RT_RX_PREPARE_STOP )
		{
			RT_TRACE(COMP_INIT, DBG_WARNING, ("Driver change Rx control state to stop mode and stop to notify Rx manager data in queue\n"));
			pTempAdapter = GetDefaultAdapter(pAdapter);
			do
			{
				pNdisCommon = pTempAdapter->pNdisCommon;
				if( pNdisCommon->bRxControlState == RT_RX_PREPARE_STOP )
				{
					pNdisCommon->bRxControlState = RT_RX_STOP;
					GLWdiTxRxStatistics.numWdiRxStop++;
				}
				pTempAdapter = GetNextExtAdapter(pTempAdapter);
			}while(pTempAdapter != NULL );

			PlatformReleaseSpinLock(pAdapter, RT_RX_CONTROL_SPINLOCK);
			RT_TRACE(COMP_INIT, DBG_WARNING, ("Driver call RxStopConfirm for Rx manager\n"));
			pWdi->WdiDataApi.RxStopConfirm(pWdi->DataPathHandle);
		}
		else if( pNdisCommon->bRxControlState == RT_RX_NOTIFYING )
		{
			pNdisCommon->bRxControlState = RT_RX_NORMAL;
			PlatformReleaseSpinLock(pAdapter, RT_RX_CONTROL_SPINLOCK);
		}
		else
		{
			RT_TRACE(COMP_INIT, DBG_WARNING, ("wdi_NotifyPeerData: Unknown case and RxControlState is %d\n", pNdisCommon->bRxControlState));
			PlatformReleaseSpinLock(pAdapter, RT_RX_CONTROL_SPINLOCK);
		}
	}
	else
	{
		PlatformReleaseSpinLock(pAdapter, RT_RX_CONTROL_SPINLOCK);
		*pNdisStatus = NDIS_STATUS_MEDIA_BUSY;
		RT_TRACE(COMP_RECV, DBG_WARNING, ("Stop to notify Rx manager data in queue\n"));
	}
}

NDIS_STATUS
WDI_Initialize(
	IN	PDRIVER_OBJECT							pDriverObject,
	IN	PUNICODE_STRING							RegistryPath,
	IN	PNDIS_MINIPORT_DRIVER_CHARACTERISTICS	pMChars
	)
{
	NDIS_STATUS		Status = NDIS_STATUS_SUCCESS;
	NDIS_MINIPORT_DRIVER_WDI_CHARACTERISTICS  WdiChar = {0};

    pMChars->ShutdownHandlerEx				= N6SdioShutdown;//ok
	pMChars->DevicePnPEventNotifyHandler	= N6SdioPnPEventNotify;//ok
	pMChars->UnloadHandler					= N6SdioUnload;//ok
	pMChars->OidRequestHandler				= N6SdioOidRequest;
	pMChars->CancelOidRequestHandler		= N6SdioCancelOidRequest;
	pMChars->SetOptionsHandler				= N6SdioSetOptions;// MPSetOptions;
	pMChars->CheckForHangHandlerEx			= NULL;	// Need check
	pMChars->DirectOidRequestHandler		= N6CDirectOidRequest;
	pMChars->CancelDirectOidRequestHandler	= N6CCancelDirectOidRequest;

	// WorkAround for 0x9F BSOD
	pMChars->ResetHandlerEx 				= N6SdioReset;

	RtlZeroMemory(&WdiChar, sizeof(WdiChar));

	WdiChar.WdiVersion				= WDI_VERSION_LATEST;

	WdiChar.Header.Type				= NDIS_OBJECT_TYPE_MINIPORT_WDI_CHARACTERISTICS,
	WdiChar.Header.Size				= NDIS_SIZEOF_MINIPORT_WDI_CHARACTERISTICS_REVISION_1;
	WdiChar.Header.Revision			= NDIS_MINIPORT_DRIVER_WDI_CHARACTERISTICS_REVISION_1;

	WdiChar.AllocateAdapterHandler  = N6SdioWdi_AllocateAdapter;
	WdiChar.FreeAdapterHandler      = N6SdioWdi_FreeAdapter;
	WdiChar.OpenAdapterHandler      = N6SdioWdi_OpenAdapter;
	WdiChar.CloseAdapterHandler     = N6SdioWdi_CloseAdapter;
	WdiChar.TalTxRxInitializeHandler    = N6SdioWdi_TalTxRxInitialize;
	WdiChar.TalTxRxDeinitializeHandler  = N6SdioWdi_TalTxRxDeinitialize;

	WdiChar.HangDiagnoseHandler		= N6SdioWdi_HangDiagnose;

	// Optional handler
	WdiChar.StartOperationHandler       = N6SdioWdi_StartOperation;
	WdiChar.StopOperationHandler        = N6SdioWdi_StopOperation;

	Status = NdisMRegisterWdiMiniportDriver(
				pDriverObject,
				RegistryPath,
				&GlobalRtDriverContext,
				pMChars,
				&WdiChar,
				&(GlobalRtDriverContext.NdisContext.Ndis6MiniportDriverHandle)
				);
    RT_TRACE(COMP_INIT, DBG_LOUD, ("WDI register WDI miniport! Status 0x%x\n", Status));

	return Status;
}


VOID
WDI_DeInitialize(
	IN  NDIS_HANDLE			DriverHandle
	)
{
	NdisMDeregisterWdiMiniportDriver(DriverHandle);
}

VOID
WDI_InitRxQueue(
	IN  PADAPTER		pAdapter
	)
{
	PADAPTER		pDefaultAdapter = GetDefaultAdapter(pAdapter);
	u2Byte			index = 0;
	PRT_PEER_ENTRY	pPeerEntry = NULL;

	PlatformAcquireSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);
	for(index=0; index < MAX_PEER_NUM; index++)
	{
		RTInitializeSListHead( &(pDefaultAdapter->RxPeerQueue[index]) );
	}
	for(index=0; index < MAX_PEER_NUM; index++)
	{
		pPeerEntry = &pDefaultAdapter->RxPeerTable[index];
		PlatformZeroMemory(pPeerEntry, sizeof(RT_PEER_ENTRY));
	}
	pDefaultAdapter->RxPeerUsedCount = 0;
	PlatformReleaseSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);
}

VOID
WDI_DeInitRxQueue(
	IN  PADAPTER		pAdapter
	)
{
	PADAPTER			pDefaultAdapter = GetDefaultAdapter(pAdapter);
	u2Byte				index = 0;
	PNET_BUFFER_LIST	pNetBufferList=NULL;

	RT_TRACE(COMP_INIT, DBG_LOUD, ("[WDI], WDI_DeInitRxQueue() ==> \n"));
	PlatformAcquireSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);
	for(index=0; index<MAX_PEER_NUM; index++)
	{
		if( !N6CIsNblWaitQueueEmpty(pDefaultAdapter->RxPeerQueue[index]) )
		{
			RT_TRACE(COMP_INIT, DBG_LOUD, ("[WDI], Free MDLs/NBLs for Peer ID %d \n", index));
			pNetBufferList = N6CGetHeadNblWaitQueue(pDefaultAdapter->RxPeerQueue[index]);
			RTInitializeSListHead( &(pDefaultAdapter->RxPeerQueue[index]) );
			PlatformReleaseSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);
			WDI_FreeRxFrame(pAdapter, pNetBufferList);
			PlatformAcquireSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);
		}
	}
	PlatformReleaseSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);
	RT_TRACE(COMP_INIT, DBG_LOUD, ("[WDI], WDI_DeInitRxQueue() <== \n"));
}


VOID
WDI_PnPNotiry(
	IN  PADAPTER				pAdapter
	)
{
	PWDI_DATA_STRUCT		pWdi = &(pAdapter->pPortCommonInfo->WdiData);

	if( pWdi->TaskHandle.Status & RT_OID_HANDLER_STATUS_SET )
	{
		OidHandle_Complete(pAdapter, OIDHANDLE_TYPE_TASK);
	}

	if( pWdi->PropertyHandle.Status & RT_OID_HANDLER_STATUS_SET )
	{
		OidHandle_Complete(pAdapter, OIDHANDLE_TYPE_PROPERTY);
	}
}


NDIS_STATUS
WDI_HandleOidRequest(
	IN  NDIS_HANDLE			MiniportAdapterContext,
	IN  PNDIS_OID_REQUEST	pNdisRequest
	)
{
	return N6WdiHandleOidRequest(MiniportAdapterContext, pNdisRequest);
}


VOID
WdiExt_IndicateApAssocReqReceived(
	IN  ADAPTER					*pAdapter,
	IN  u4Byte					assocReqLen,
	IN  u1Byte					*assocReq
	)
{
	WDI_INDICATION_AP_ASSOCIATION_REQUEST_PARAMETERS param;
	OCTET_STRING				osAssocReq = {0};
	u2Byte						ieOffset = 0;

	u1Byte						*buf = NULL;
	ULONG						buflen = 0;

	if(assocReqLen < sMacHdrLng)
	{
		RT_TRACE_F(COMP_OID_SET, DBG_LOUD, ("invalid assoc req len: %u\n", assocReqLen));
		return;
	}

	PlatformZeroMemory(&param, sizeof(param));

	cpMacAddr(param.IncomingRequestInfo.AssocRequestParams.PeerMacAddress.Address,
		assocReq + FRAME_OFFSET_ADDRESS2
		);

	param.IncomingRequestInfo.AssocRequestParams.IsReassociationRequest =
		(Type_Reasoc_Req == GET_80211_HDR_TYPE(assocReq)) ? TRUE : FALSE;

	FillOctetString(osAssocReq, assocReq, (u2Byte)assocReqLen);

	if(!PacketGetIeOffset(&osAssocReq, &ieOffset))
	{
		RT_TRACE_F(COMP_OID_SET, DBG_LOUD, ("PacketGetIeOffset returns FALSE\n"));
		return;
	}

	param.IncomingRequestInfo.AssocRequestFrame.ElementCount = osAssocReq.Length - sMacHdrLng;
	param.IncomingRequestInfo.AssocRequestFrame.pElements = osAssocReq.Octet + sMacHdrLng;

	// Gen tlv
	if(NDIS_STATUS_SUCCESS != GenerateWdiIndicationApAssociationRequestReceived(
		&param,
		sizeof(NDIS_STATUS_INDICATION) + sizeof(WDI_MESSAGE_HEADER),
		&pAdapter->pPortCommonInfo->WdiData.TlvContext,
		&buflen, &((UINT8 *)buf)))
		return;

	wdi_UnsolicitedIndication(pAdapter,
							FALSE,
							NULL,
							NDIS_STATUS_WDI_INDICATION_AP_ASSOCIATION_REQUEST_RECEIVED,
							NDIS_STATUS_SUCCESS,
							buf,
							buflen);

	// cleanup
	FreeGenerated((UINT8 *)buf);

	return;
}

VOID
WdiExt_IndicateApAssocRspSent(
	IN  ADAPTER					*pAdapter,
	IN  u2Byte					status
	)
{
	RT_OID_HANDLER				*task = &pAdapter->pPortCommonInfo->WdiData.TaskHandle;

	RT_TRACE_F(COMP_OID_SET, DBG_LOUD, ("indicate association rsp sent\n"));

	if(FALSE == OidHandle_VerifyTask(pAdapter, OID_WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE))
	{
		RT_TRACE(COMP_OID_SET, DBG_WARNING,
			("WdiExt_IndicateApAssocRspSent(): skip indication because OidHandle_VerifyTask() returns FALSE\n"));
		return;
	}

	if(task->pvCtx)
	{
		if(WDI_CMD_SendApAssociationResponseComplete(
				pAdapter,
				(NDIS_OID_REQUEST *)task->pvCtx,
				StatusCode_success == status ? RT_STATUS_SUCCESS : RT_STATUS_FAILURE))
		{// set pvCtx to NULL only when it is freed in WDI_CMD_SendApAssociationResponseComplete
			task->pvCtx = NULL;
		}
	}

	return;
}

RT_STATUS
WDIAllocateMetaData(
	IN	PADAPTER	pAdapter,
	IN	PNET_BUFFER_LIST	pNBL,
	IN	PRT_RFD				pRfd
)
{
	PWDI_DATA_STRUCT	pWdi = &(pAdapter->pPortCommonInfo->WdiData);
	PWDI_FRAME_METADATA	pWdiFrameMeta = NULL;

	pWdiFrameMeta = pWdi->WdiDataApi.AllocateWiFiFrameMetaData(pWdi->DataPathHandle);
	if( pWdiFrameMeta == NULL )
		return RT_STATUS_FAILURE;

	pWdiFrameMeta->u.rxMetaData.PayloadType = WDI_FRAME_MSDU;
	pWdiFrameMeta->pNBL = pNBL;

	RT_TRACE(COMP_RECV, DBG_TRACE, ("PayloadType %d\n", pWdiFrameMeta->u.rxMetaData.PayloadType));

	MP_SET_PACKET_RFD_RESERVED_0(pNBL, pWdiFrameMeta);

	return RT_STATUS_SUCCESS;
}


VOID
WDIFreeMetaData(
	IN	PADAPTER	pAdapter,
	IN	PNET_BUFFER_LIST	pNBL
)
{
	PWDI_DATA_STRUCT	pWdi = &(pAdapter->pPortCommonInfo->WdiData);
	PWDI_FRAME_METADATA	pWdiFrameMeta = NULL;

	pWdiFrameMeta = MP_GET_PACKET_RFD_RESERVED_0(pNBL);

	if( pWdiFrameMeta != NULL )
		pWdi->WdiDataApi.FreeWiFiFrameMetaData(pWdi->DataPathHandle, pWdiFrameMeta);
	else
		return;

	return;
}

u4Byte
WDI_InsertDataInQueue(
	IN	PADAPTER			pAdapter,
	IN	PRT_RFD				pRfd,
	IN	PNET_BUFFER_LIST	pNBL
)
{
	PADAPTER			pDefaultAdapter = GetDefaultAdapter(pAdapter);
	u2Byte				PortNumber = (u2Byte)pAdapter->pNdis62Common->PortNumber;
	OCTET_STRING		osMpdu = {NULL, 0};
	u4Byte				PeerId = 0;
	PRT_PEER_ENTRY		pPeerEntry = NULL;
	PNET_BUFFER_LIST	pCurrNetBufferList = NULL, pNextNetBufferList = NULL;

	FillOctetString(osMpdu, pRfd->Buffer.VirtualAddress + pRfd->FragOffset, pRfd->FragLength);

	PlatformAcquireSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);

/****************************************************************************************************
* 20150707 Sinda
* We insert frames in queue as below rules
* 1. Can find the peer with MAC address
* 2. Cannot find the peer with MAC address and insert frames in queue of group peer
****************************************************************************************************/
	pPeerEntry = (PRT_PEER_ENTRY)wdi_FindPeerByAddr(pAdapter, Frame_pTaddr(osMpdu));
	if( pPeerEntry != NULL )
		PeerId = pPeerEntry->uPeerId;
	else
	{
		pPeerEntry = (PRT_PEER_ENTRY)wdi_FindGroupPeerByPort(pAdapter, PortNumber);
		if( pPeerEntry == NULL )
		{
			PlatformReleaseSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);
			return 0;
		}
		else
			PeerId = pPeerEntry->uPeerId;
	}

	if(pPeerEntry->bUsed == TRUE)
	{
		RT_TRACE(COMP_RECV, DBG_TRACE, ("WDI_InsertDataInQueue: Port %d, PeerId %d\n", PortNumber, PeerId));
		for (pCurrNetBufferList = pNBL; pCurrNetBufferList != NULL; pCurrNetBufferList = pNextNetBufferList)
		{
			pNextNetBufferList = NET_BUFFER_LIST_NEXT_NBL(pCurrNetBufferList);
			NET_BUFFER_LIST_NEXT_NBL(pCurrNetBufferList) = NULL;
			N6CAddNblWaitQueue(&pDefaultAdapter->RxPeerQueue[PeerId], pCurrNetBufferList, FALSE);
		}
		PlatformReleaseSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);
		return PeerId + 1;
	}
	else
	{
		PlatformReleaseSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);
		return 0;
	}
}

BOOLEAN
WDI_NotifyDataInQueue(
	IN	PADAPTER				pAdapter,
	IN	u1Byte					ExTid,
	IN	u2Byte					PeerId,
	IN	RT_RX_INDICATION_LEVEL	level
)
{
	PADAPTER			pDefaultAdapter = GetDefaultAdapter(pAdapter);
	PRT_NDIS6_COMMON	pDefaultNdisCommon = pDefaultAdapter->pNdisCommon;
	NDIS_STATUS			status = NDIS_STATUS_SUCCESS;

	RT_TRACE(COMP_RECV, DBG_TRACE, ("WDI_NotifyDataInQueue: PeerId %d, ExTid %d\n", PeerId, ExTid));

	wdi_NotifyPeerData(pAdapter, ExTid, PeerId, level, &status);
	if( status == NDIS_STATUS_PAUSED )
	{
		RT_TRACE_F(COMP_INIT, DBG_WARNING, ("Rx manager pause frame and wait for it to be ready. return value (%d)\n", status));
		PlatformAcquireSpinLock(pAdapter, RT_RX_CONTROL_SPINLOCK);
		pDefaultNdisCommon->bRxDataPathState = RT_RX_PAUSE;
		GLWdiTxRxStatistics.numWdiRxPause++;
		PlatformReleaseSpinLock(pAdapter, RT_RX_CONTROL_SPINLOCK);
		return FALSE;
	}
	else
		return TRUE;
}


VOID
WDI_CompletePacket(
	IN	PADAPTER			pAdapter,
	IN	PNET_BUFFER_LIST	pNBL
)
{
	PWDI_DATA_STRUCT		pWdi = &(pAdapter->pPortCommonInfo->WdiData);
	u2Byte					count = 0;
	WDI_FRAME_ID			FrameID[100] = {0};
	PWDI_FRAME_METADATA	pFrameMeta = NULL;
	BOOLEAN					bIndicateSendComplete = FALSE;

	GLWdiTxRxStatistics.numWdiCompletePkt++;

	//RT_TRACE(COMP_INIT, DBG_LOUD, ("[WDI], WDI_CompletePacket() ==>\n"));
	// complete only one packet
	pFrameMeta = (PWDI_FRAME_METADATA)pNBL->MiniportReserved[0];
	NET_BUFFER_LIST_NEXT_NBL(pNBL) = NULL;
	NET_BUFFER_LIST_STATUS(pNBL) = NDIS_STATUS_SUCCESS;
	FrameID[count] = pFrameMeta->FrameID;

	if(pFrameMeta->u.txMetaData.bTxCompleteRequired == TRUE)
		bIndicateSendComplete = TRUE;

	pWdi->WdiDataApi.TxTransferCompleteIndication(pWdi->DataPathHandle,WDI_TxFrameStatus_Ok,pNBL);
	if(bIndicateSendComplete)
	{
		pWdi->WdiDataApi.TxSendCompleteIndication(pWdi->DataPathHandle, WDI_TxFrameStatus_Ok, count, FrameID, NULL);
	}
}


VOID
WDI_IndicateScanComplete(
	PADAPTER		pAdapter,
	RT_STATUS		status
	)
{
	PMGNT_INFO			pMgntInfo = &(pAdapter->MgntInfo);

	if(FALSE == OidHandle_VerifyTask(pAdapter, OID_WDI_TASK_SCAN))
		return;

	OidHandle_Complete(pAdapter, OIDHANDLE_TYPE_TASK);
}

VOID
WDI_IndicateBssList(
	PADAPTER		pAdapter,
	RT_STATUS		status
	)
{
	wdiext_IndicateBSSEntry(pAdapter);
}

VOID
WDI_IndicateBssListBySSID(
	PADAPTER		pAdapter,
	WDI_SSID		*pSSID
	)
{
	wdiext_IndicateBSSEntryBySSID(pAdapter, pSSID);
}

VOID
WDI_IndicateConnectionComplete(
	PADAPTER		pAdapter,
	RT_STATUS		status
	)
{
	PMGNT_INFO			pMgntInfo = &(pAdapter->MgntInfo);

	if(FALSE == OidHandle_VerifyTask(pAdapter, OID_WDI_TASK_CONNECT))
		return;

	OidHandle_Complete(pAdapter, OIDHANDLE_TYPE_TASK);
}


VOID
WDI_IndicateAssociationComplete(
	PADAPTER		pAdapter,
	RT_STATUS		status
	)
{
	if( status == RT_STATUS_SUCCESS )
	{
		wdiext_IndicateAssociationResult(pAdapter);
		wdiext_IndicateLinkStateChanged(pAdapter, FALSE, 0);
	}
}


VOID
WDI_IndicateDisassociation(
	PADAPTER	pAdapter,
	u2Byte		reason,
	pu1Byte		pAddr
)
{
	PMGNT_INFO	pMgntInfo = &(pAdapter->MgntInfo);

	if(ACTING_AS_AP(pAdapter))
	{// AP mode
		RT_WLAN_STA *sta = pMgntInfo->pCurrentSta;

		RT_ASSERT(sta, ("%s(): sta is NULL!!!\n", __FUNCTION__));

		if(NULL == sta)
		{
			RT_TRACE_F(COMP_AP, DBG_SERIOUS, ("pMgntInfo->pCurrentSta is NULL!\n"));
			return;
		}

		wdiext_IndicateDisassociation(pAdapter, sta->MacAddr, 0, NULL, TRUE, reason);
	}
	else
	{// Client mode
		wdiext_IndicateDisassociation(pAdapter, pMgntInfo->Bssid, 0, NULL, TRUE, reason);
	}

	if( pAddr != NULL )
	{
		WDI_DeleteDatapathPeer(pAdapter, pAddr);
	}
}

VOID
WDI_IndicateNLODiscovery(
	PADAPTER		pAdapter
	)
{
	WDI_INDICATION_NLO_DISCOVERY_PARAMETERS		param;
	PWDI_BSS_ENTRY_CONTAINER					pEntry;

	PRT_NLO_INFO			pNLOInfo	= &(pAdapter->MgntInfo.NLOInfo);
	PRT_WLAN_BSS			pRtBss 		= NULL;
	RT_802_11_BSSID_LIST 	RtBssList	= {0};
	u4Byte					i 			= 0;
	u4Byte					j 			= 0;
	u4Byte					nBss		= 0;
	ULONG					buflen 		= 0;
	pu1Byte					buf 		= NULL;
	pu1Byte					pBssList	= NULL;
	u4Byte					devSpecCtx 	= 0x07060504;
	BOOLEAN					Hit			= FALSE;
	LARGE_INTEGER			CurrentTime;

	if(!pAdapter->pPortCommonInfo->WdiData.TaskHandle.pNdisRequest)
		return;

	FunctionIn(COMP_POWER);

	// zero
	PlatformZeroMemory(&param, sizeof(param));

	//Get scan list
	RtBssList.NumberOfItems = 0;
	RtBssList.pbssidentry = pAdapter->bssDescList;

	MgntActQuery_802_11_BSSID_LIST(pAdapter, &RtBssList, FALSE);

	PlatformAllocateMemoryWithZero(pAdapter, (PVOID *)&pEntry, sizeof(WDI_BSS_ENTRY_CONTAINER)*RtBssList.NumberOfItems);

	param.DeviceDescriptor.pElements = pEntry;
	nBss = 0;


	// Indicate those found BSS which we desired
	for ( i=0 ; i<RtBssList.NumberOfItems ; i++)
	{
		Hit = FALSE;

		if(RtBssList.pbssidentry[i].IE.Length <= sizeof(RT_FIXED_IE_FIELD))
		{
			continue;
		}

		pRtBss = &(RtBssList.pbssidentry[i]);

		// Determine if we shall report the BSS found by RegWirelessMode4ScanList.
		if(!WDIFilterRtBss(pAdapter, pRtBss))
		{
			// Skip this BSS.
			continue;
		}

		for( j=0 ; j<pNLOInfo->NumDot11OffloadNetwork ; ++j )
		{
			// Compare to check whether it is what we desired or not
			if(!PlatformCompareMemory(pNLOInfo->dDot11OffloadNetworkList[j].ssidbuf, pRtBss->bdSsIdBuf, 32))
			{
				++nBss;
				Hit = TRUE;
			}
		}

		if( !Hit )	// This BSS is not we desired.
			continue;

		// WIFI_MAC_ADDRESS_CONTAINER BSSID
		cpMacAddr(pEntry->BSSID.Address, pRtBss->bdBssIdBuf);

		// WIFI_BYTE_BLOB ProbeResponseFrame, BeaconFrame
		if(pRtBss->BssPacketType & BSS_PKT_BEACON)
		{
			pEntry->Optional.BeaconFrame_IsPresent = TRUE;
			pEntry->BeaconFrame.ElementCount = pRtBss->IE.Length;
			pEntry->BeaconFrame.pElements = (UINT8 *)pRtBss->IE.Octet;
		}
		else if(pRtBss->BssPacketType & BSS_PKT_PROBE_RSP)
		{
			pEntry->Optional.ProbeResponseFrame_IsPresent = TRUE;
			pEntry->ProbeResponseFrame.ElementCount = pRtBss->IE.Length;
			pEntry->ProbeResponseFrame.pElements = (UINT8 *)pRtBss->IE.Octet;
		}
		else
		{
			RT_TRACE(COMP_POWER, DBG_LOUD, ("Unknown BssPacketType: %u\n", pRtBss->BssPacketType));
			FunctionOut(COMP_POWER);
			return;
		}

		// WDI_SIGNAL_INFO_CONTAINER SignalInfo
		pRtBss->RecvSignalPower = 0xffffffce;
		pEntry->SignalInfo.RSSI = (INT32)pRtBss->CumRecvSignalPower;
		pEntry->SignalInfo.LinkQuality = (UINT32)pRtBss->RSSI;

		// WDI_CHANNEL_INFO_CONTAINER ChannelInfo
		pEntry->ChannelInfo.ChannelNumber = (UINT32)pRtBss->ChannelNumber;
		pEntry->ChannelInfo.BandId = (pRtBss->ChannelNumber < 36) ? WDI_BAND_ID_2400 : WDI_BAND_ID_5000;
		RT_TRACE(COMP_POWER, DBG_LOUD, ("pRtBss->ChannelNumber=%d, ", pRtBss->ChannelNumber));
		RT_TRACE(COMP_POWER, DBG_LOUD, ("%x:%x:%x:%x:%x:%x, ",
			pEntry->BSSID.Address[0], pEntry->BSSID.Address[1],
			pEntry->BSSID.Address[2], pEntry->BSSID.Address[3],
			pEntry->BSSID.Address[4], pEntry->BSSID.Address[5]));
		RT_TRACE(COMP_POWER, DBG_LOUD, ("SSID: %s\n", pRtBss->bdSsIdBuf));

		// WDI_BYTE_BLOB DeviceSpecificContext, this is OPTIONAL
		pEntry->Optional.DeviceSpecificContext_IsPresent = TRUE;
		pEntry->DeviceSpecificContext.ElementCount = sizeof(devSpecCtx);
		pEntry->DeviceSpecificContext.pElements = (UINT8 *)&devSpecCtx;

		// Get current timestamp
		NdisGetCurrentSystemTime(&CurrentTime);

		// WDI_AGE_INFO_CONTAINER EntryAgeInfo
		pEntry->EntryAgeInfo.HostTimeStamp = CurrentTime.QuadPart;  // [SDIO-482] in JIRA
		pEntry->EntryAgeInfo.CachedInformation = 0;
	}

	if(nBss == 0)
	{
		RT_TRACE(COMP_POWER, DBG_LOUD, ("WDI_IndicateNLODiscovery(): Error, # of Hit SSID is ZERO.\n"));
		FunctionOut(COMP_POWER);
		return;
	}

	param.DeviceDescriptor.ElementCount = nBss;

	RT_TRACE(COMP_POWER, DBG_LOUD, ("# of BSS Found: %u\n", param.DeviceDescriptor.ElementCount));

	// Gen tlv
	if(NDIS_STATUS_SUCCESS != GenerateWdiIndicationNloDiscovery(
		&param,
		sizeof(NDIS_STATUS_INDICATION) + sizeof(WDI_MESSAGE_HEADER),
		&pAdapter->pPortCommonInfo->WdiData.TlvContext,
		&buflen, &((UINT8 *)buf)))
	{
		RT_TRACE(COMP_POWER, DBG_LOUD, ("WDI_IndicateNLODiscovery(): GenerateWdiIndicationNloDiscovery Failed\n"));
		FunctionOut(COMP_POWER);
		return;
	}

	wdi_UnsolicitedIndication(	pAdapter,
								FALSE,
								NULL,
								NDIS_STATUS_WDI_INDICATION_NLO_DISCOVERY,
								NDIS_STATUS_SUCCESS,
								buf,
								buflen);

	// cleanup
	FreeGenerated((UINT8 *)buf);

	FunctionOut(COMP_POWER);
}


VOID
WDI_IndicateCurrentPhyStatus(
	PADAPTER		pAdapter
	)
{
	wdiext_IndicateRadioStatus(pAdapter);
}


VOID
WDI_IndicateP2PEvent(
	VOID 			*pvP2PInfo,
	u4Byte 			EventID,
	MEMORY_BUFFER	*pInformation

	)
{
	P2P_INFO				*pP2PInfo = (P2P_INFO *)pvP2PInfo;
	RT_OID_HANDLER			*task = &pP2PInfo->pAdapter->pPortCommonInfo->WdiData.TaskHandle;

	if(P2P_EVENT_DEV_FOUND == EventID)
	{
		wdiext_IndicateP2PDeviceFound(pP2PInfo->pAdapter, pInformation->Buffer);
	}
	else if(P2P_EVENT_RECEIVED_PROVISION_DISCOVERY_REQUEST == EventID
		|| P2P_EVENT_RECEIVED_GO_NEGOTIATION_REQUEST == EventID
		|| P2P_EVENT_RECEIVED_INVITATION_REQUEST == EventID
		)
	{// rx req action
		WDI_CMD_PreIndicateRxP2pActionFrameCb(pvP2PInfo, EventID, pInformation);
		wdiext_IndicateP2PActionFrameReceived(pvP2PInfo, EventID, pInformation);
		WDI_CMD_PostIndicateRxP2pActionFrameCb(pvP2PInfo, EventID, pInformation);
	}
	else if(P2P_EVENT_RECEIVED_PROVISION_DISCOVERY_RESPONSE == EventID
		|| P2P_EVENT_RECEIVED_INVITATION_RESPONSE == EventID
		|| P2P_EVENT_RECEIVED_GO_NEGOTIATION_RESPONSE == EventID
		|| P2P_EVENT_RECEIVED_GO_NEGOTIATION_CONFIRM == EventID
		)
	{// rx rsp action
		WDI_CMD_PreIndicateRxP2pActionFrameCb(pvP2PInfo, EventID, pInformation);

		// indicate in the corresp. OffChnlTx complete cb
		//wdiext_IndicateP2PActionFrameReceived(pvP2PInfo, EventID, pInformation);

		WDI_CMD_PostIndicateRxP2pActionFrameCb(pvP2PInfo, EventID, pInformation);
	}
	else if(P2P_EVENT_GO_OPERATING_CHANNEL == EventID)
	{
		wdiext_IndicateP2POpChnl(pP2PInfo->pAdapter, pP2PInfo);
	}

	return;
}


BOOLEAN
WDI_CompleteCreateDeleteMac(
	IN  PADAPTER				pAdapter,
	IN  NDIS_STATUS				status
	)
{
	PPORT_HELPER			pPortHelper = pAdapter->pPortCommonInfo->pPortHelper;
	BOOLEAN					bCompleteStatus = FALSE;

	if(pPortHelper->bCreateMac)
		bCompleteStatus = WDI_CMD_CreatePortComplete(pAdapter, pPortHelper->pCreateDeleteOID, status);
	else if(pPortHelper->bDeleteMac)
		bCompleteStatus = WDI_CMD_DeletePortComplete(pAdapter, pPortHelper->pCreateDeleteOID, status);

	return bCompleteStatus;
}

VOID
WDI_IndicateLinkStateChanged(
	PADAPTER		pAdapter,
	BOOLEAN			bForceLinkQuality,
	u1Byte			ucLinkQuality
	)
{
	wdiext_IndicateLinkStateChanged(pAdapter, bForceLinkQuality, ucLinkQuality);
}

RT_STATUS
WDI_IndicateActionFrame(
	IN	PADAPTER		pAdapter,
	IN	POCTET_STRING	posMpdu
)
{
	NDIS_STATUS_INDICATION		*indic = NULL;
	WDI_MESSAGE_HEADER			*wdiHdr = NULL;

	u1Byte						*buf = NULL;
	ULONG						buflen = 0;

	WDI_INDICATION_ACTION_FRAME_RECEIVED_PARAMETERS param = {0};

	RT_TRACE(COMP_OID_SET, DBG_WARNING, ("WDI_IndicateActionFrame +\n"));


	// TODO: fill the valid info into param
	PlatformMoveMemory(param.SourceAddress.Address,Frame_pSaddr(*posMpdu),6);
	param.ActionFrameBody.pElements = posMpdu->Octet+24;//get rid of header
	param.ActionFrameBody.ElementCount = posMpdu->Length;

	// TODO: double check here to make sure channel correct
	param.ChannelInfo.ChannelNumber = RT_GetChannelNumber(pAdapter);
	param.ChannelInfo.BandId = WDI_BAND_ID_2400;

	if(NDIS_STATUS_SUCCESS != GenerateWdiIndicationActionFrameReceived(
			&param,
			sizeof(*indic) + sizeof(*wdiHdr),
			&pAdapter->pPortCommonInfo->WdiData.TlvContext,
			&buflen, &((UINT8 *)buf)))
	{
		RT_TRACE(COMP_OID_SET, DBG_WARNING, ("ActionFrame generate tlv failed\n"));
		return NDIS_STATUS_FAILURE;
	}

	indic = (NDIS_STATUS_INDICATION *)buf;
	wdiHdr = (WDI_MESSAGE_HEADER *)(buf + sizeof(*indic));

	PlatformZeroMemory(indic, sizeof(*indic));
	indic->Header.Type = NDIS_OBJECT_TYPE_STATUS_INDICATION;
	indic->Header.Size = NDIS_SIZEOF_STATUS_INDICATION_REVISION_1;
	indic->Header.Revision = NDIS_STATUS_INDICATION_REVISION_1;
	indic->SourceHandle = pAdapter;
	indic->PortNumber = 0;
	indic->StatusCode = NDIS_STATUS_WDI_INDICATION_ACTION_FRAME_RECEIVED;
	indic->RequestId = 0; // ?
	indic->StatusBuffer = wdiHdr;
	indic->StatusBufferSize = buflen - sizeof(*indic);

	wdiHdr->PortId = (WDI_PORT_ID)(GET_PORT_NUMBER(pAdapter));
	wdiHdr->Reserved = 0;
	wdiHdr->Status = NDIS_STATUS_SUCCESS;
	wdiHdr->TransactionId = 0;
	wdiHdr->IhvSpecificId = 0;

	NdisMIndicateStatusEx(pAdapter->pNdisCommon->hNdisAdapter, indic);

	FreeGenerated((UINT8 *)buf);

	return RT_STATUS_SUCCESS;
}

VOID
WDI_IndicateWakeReason(
	IN PADAPTER		pAdapter,
	IN BOOLEAN		bWakePacket,
	IN pu1Byte		pBuffer,
	IN u2Byte		BufferLen
	)
{
	WDI_INDICATION_WAKE_REASON_PARAMETERS		param;

	PMGNT_INFO					pMgntInfo 	= &(pAdapter->MgntInfo);
	PRT_POWER_SAVE_CONTROL		pPSC		= GET_POWER_SAVE_CONTROL(pMgntInfo);
	pu1Byte						pWakePktbuf	= NULL;
	BOOLEAN						bIndicate 	= TRUE;
	u1Byte						*buf 		= NULL;
	ULONG						buflen 		= 0;

	PlatformZeroMemory(&param, sizeof(WDI_INDICATION_WAKE_REASON_PARAMETERS));

	if(bWakePacket)
	{
		if(pPSC->WakeUpReason == WOL_REASON_MAGIC_PKT)
			param.Optional.WakePacket_IsPresent = 1;
		else if(pPSC->WakeUpReason == WOL_REASON_PATTERN_PKT)
			param.Optional.WakePacketPatternId_IsPresent = 1;
		else
		{
			RT_TRACE(COMP_POWER, DBG_SERIOUS, ("WDI_IndicateWakeReason(): Unknown pPSC->WakeUpReason(%#x)\n", pPSC->WakeUpReason));
		}

		param.WakeEventCode = WDI_WAKE_REASON_CODE_PACKET;
		param.WakePacketPatternId = pPSC->MagicPacketPatternId;

		PlatformAllocateMemoryWithZero(pAdapter, (PVOID *)&pWakePktbuf, BufferLen);

		PlatformMoveMemory(pWakePktbuf, pBuffer, BufferLen);

		param.WakePacket.ElementCount = 1;
		param.WakePacket.pElements = pWakePktbuf;

		RT_PRINT_DATA(COMP_POWER, DBG_LOUD, "WDI_IndicateWakeReason(): packet\n", param.WakePacket.pElements, BufferLen);
	}
	else
	{
		if(pPSC->WakeUpReason == WOL_REASON_AP_LOST ||
			pPSC->WakeUpReason == WOL_REASON_DEAUTH ||
			pPSC->WakeUpReason == WOL_REASON_DISASSOC)
		{
			param.WakeEventCode = WDI_WAKE_REASON_CODE_AP_ASSOCIATION_LOST;
		}
		else if(pPSC->WakeUpReason == WOL_REASON_NLO_SSID_MATCH)
		{
			param.WakeEventCode = WDI_WAKE_REASON_CODE_NLO_DISCOVERY;
		}
		else if(pPSC->WakeUpReason == WOL_REASON_PTK_UPDATE)
		{
			param.WakeEventCode = WDI_WAKE_REASON_CODE_4WAY_HANDSHAKE_REQUEST;
		}
		else
		{
			param.WakeEventCode = NdisWakeReasonUnspecified;
			bIndicate = FALSE;
		}
	}

	if(bIndicate)
	{
		RT_TRACE(COMP_POWER, DBG_LOUD, ("WDI_IndicateWakeReason(): WakeEventCode(%#X)\n", param.WakeEventCode));

		// Gen tlv
		if(NDIS_STATUS_SUCCESS != GenerateWdiIndicationWakeReasonFromIhv(
			&param,
			sizeof(NDIS_STATUS_INDICATION) + sizeof(WDI_MESSAGE_HEADER),
			&pAdapter->pPortCommonInfo->WdiData.TlvContext,
			&buflen, &((UINT8 *)buf)))
		{
				RT_TRACE(COMP_POWER, DBG_LOUD, ("WDI_IndicateWakeReason(): GenerateWdiIndicationWakeReasonFromIhv Failed\n"));
				return;
		}

		wdi_UnsolicitedIndication(pAdapter,
								FALSE,
								NULL,
								NDIS_STATUS_WDI_INDICATION_WAKE_REASON,
								NDIS_STATUS_SUCCESS,
								buf,
								buflen);

		// cleanup
		FreeGenerated((UINT8 *)buf);
	}

}


VOID
WDI_IndicateRoamingNeeded(
	PADAPTER				pAdapter,
	RT_PREPARE_ROAM_TYPE	IndicationReason
	)
{
	PMGNT_INFO	pMgntInfo = &(pAdapter->MgntInfo);

	pMgntInfo->PrepareRoamState = IndicationReason;

	switch(IndicationReason)
	{
		case RT_PREPARE_ROAM_DEAUTH_DISASSOC:
			wdiext_IndicateRoamingNeeded(pAdapter, WDI_ASSOC_STATUS_PEER_DEAUTHENTICATED);
			break;
		case RT_PREPARE_ROAM_NORMAL_ROAM_POOR_LINK:
			wdiext_IndicateRoamingNeeded(pAdapter, WDI_ASSOC_STATUS_DISASSOCIATE_NOT_VISIBLE);
			break;
		case RT_PREPARE_ROAM_NORMAL_ROAM_BETTER_AP:
			wdiext_IndicateRoamingNeeded(pAdapter, WDI_ASSOC_STATUS_ROAMING_BETTER_AP_FOUND);
			break;
		default:
			break;
	}
}

VOID
WDI_IndicateRoamingComplete(
	PADAPTER		pAdapter
	)
{
	PMGNT_INFO			pMgntInfo = GetDefaultMgntInfo(pAdapter);

	if(FALSE == OidHandle_VerifyTask(pAdapter, OID_WDI_TASK_ROAM))
		return;

	OidHandle_Complete(pAdapter, OIDHANDLE_TYPE_TASK);
}

VOID
WDI_AddGroupPeer(
	IN  PADAPTER 	pAdapter,
	IN  u2Byte		PortNumber
	)
{
	PADAPTER			pDefaultAdapter = GetDefaultAdapter(pAdapter);
	PWDI_DATA_STRUCT	pWdi = &(pAdapter->pPortCommonInfo->WdiData);
	WDI_MAC_ADDRESS	PeerAddr = {0};
	PRT_PEER_ENTRY		pPeerEntry = NULL;
	u1Byte				i = 0;

	FunctionIn(COMP_INIT);

	PlatformAcquireSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);
	for(i = 0; i < MP_DEFAULT_NUMBER_OF_PORT; i++)
	{
		pPeerEntry = &pDefaultAdapter->RxPeerTable[i];
		if( pPeerEntry->bUsed == FALSE )
		{
			RT_TRACE(COMP_INIT, DBG_LOUD, ("WDI_AddGroupPeer: create group peer %d for port %d\n", i, PortNumber));
			break;
		}
	}

	if( i == MP_DEFAULT_NUMBER_OF_PORT )
	{
		RT_TRACE(COMP_INIT, DBG_WARNING, ("WDI_AddGroupPeer: there is no available group peer for port %d\n", PortNumber));
		FunctionOut(COMP_INIT);
		PlatformReleaseSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);
		return ;
	}

	pPeerEntry->bUsed = TRUE;
	pPeerEntry->uPeerId = i;
	pPeerEntry->uPortId = PortNumber;
	PlatformMoveMemory(pPeerEntry->PeerAddr, MAC_BROADCAST_ADDR, 6);
	PlatformMoveMemory(PeerAddr.Address, pPeerEntry->PeerAddr, 6);
	pWdi->WdiDataApi.PeerCreateIndication(pWdi->DataPathHandle, (WDI_PORT_ID)pPeerEntry->uPortId, (WDI_PEER_ID)pPeerEntry->uPeerId, PeerAddr);

	PlatformReleaseSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);

	FunctionOut(COMP_INIT);
}

VOID
WDI_DeleteGroupPeer(
	IN  PADAPTER 	pAdapter,
	IN  u2Byte		PortNumber
	)
{
	PWDI_DATA_STRUCT	pWdi = &(pAdapter->pPortCommonInfo->WdiData);
	PADAPTER			pDefaultAdapter = GetDefaultAdapter(pAdapter);
	NDIS_STATUS 		ndisStatus = NDIS_STATUS_SUCCESS;
	WDI_PEER_ID			PeerId = 0;
	PRT_PEER_ENTRY		pPeerEntry = NULL;
	u1Byte				i;

	FunctionIn(COMP_INIT);

	PlatformAcquireSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);

	pPeerEntry = (PRT_PEER_ENTRY)wdi_FindGroupPeerByPort(pAdapter, PortNumber);
	if( pPeerEntry == NULL )
	{
		RT_TRACE(COMP_INIT, DBG_WARNING, ("wdi_FindPeerByAddr: Cannot find group peer of port %d\n", PortNumber));
		FunctionOut(COMP_INIT);
		PlatformReleaseSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);
		return ;
	}
	else
	{
		PeerId = (WDI_PEER_ID)pPeerEntry->uPeerId;
		pPeerEntry->bUsed = FALSE;

		PlatformZeroMemory(pPeerEntry->PeerAddr, 6);

		pWdi->WdiDataApi.PeerDeleteIndication(pWdi->DataPathHandle, (WDI_PORT_ID)PortNumber, PeerId, &ndisStatus);

		WDI_FreeRxFrame(pAdapter, (PNET_BUFFER_LIST)N6CGetHeadNblWaitQueue(pDefaultAdapter->RxPeerQueue[PeerId]));
		RTInitializeSListHead(&pDefaultAdapter->RxPeerQueue[PeerId]);

		RT_TRACE(COMP_INIT, DBG_LOUD, ("WDI_DeleteGroupPeer: delete group peer %d of port %d, Status: %d\n", PeerId, PortNumber, ndisStatus));
	}

	PlatformReleaseSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);

	FunctionOut(COMP_INIT);
}

NDIS_STATUS
WDI_AddDatapathPeer(
	IN	PADAPTER 	pAdapter,
	IN	pu1Byte		pAddr)
{
	PADAPTER			pDefaultAdapter = GetDefaultAdapter(pAdapter);
	PWDI_DATA_STRUCT	pWdi = &(pAdapter->pPortCommonInfo->WdiData);
	WDI_PEER_ID			HashPeer = 0, RelocatePeer = 0;
	WDI_PORT_ID		PortId = (WDI_PORT_ID)pAdapter->pNdis62Common->PortNumber;
	WDI_MAC_ADDRESS	PeerAddr = {0};
	PRT_PEER_ENTRY		pPeerEntry = NULL;

	FunctionIn(COMP_MLME);

	PlatformAcquireSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);

	pPeerEntry = (PRT_PEER_ENTRY)wdi_GetAvailablePeer(pAdapter, pAddr);
	if( pPeerEntry != NULL )
	{
		PlatformMoveMemory(PeerAddr.Address, pPeerEntry->PeerAddr, 6);
		pWdi->WdiDataApi.PeerCreateIndication(pWdi->DataPathHandle, (WDI_PORT_ID)pPeerEntry->uPortId, (WDI_PEER_ID)pPeerEntry->uPeerId, PeerAddr);

		PlatformReleaseSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);

		FunctionOut(COMP_MLME);

		return NDIS_STATUS_SUCCESS;
	}

	PlatformReleaseSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);

	FunctionOut(COMP_MLME);

	return NDIS_STATUS_FAILURE;
}

void WDI_DeleteDatapathPeer(
	IN	PADAPTER	pAdapter,
	IN	pu1Byte		pAddr
)
{
	PWDI_DATA_STRUCT	pWdi = &(pAdapter->pPortCommonInfo->WdiData);
	PADAPTER			pDefaultAdapter = GetDefaultAdapter(pAdapter);
	WDI_PORT_ID		PortId = 0;
	NDIS_STATUS 		ndisStatus = NDIS_STATUS_SUCCESS;
	WDI_PEER_ID			PeerId = 0;
	PRT_PEER_ENTRY		pPeerEntry = NULL;

	FunctionIn(COMP_MLME);

	PlatformAcquireSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);

	pPeerEntry = (PRT_PEER_ENTRY)wdi_FindPeerByAddr(pAdapter, pAddr);
	if( pPeerEntry == NULL )
	{
		RT_TRACE(COMP_MLME, DBG_WARNING, ("wdi_FindPeerByAddr: Cannot find the addres [%2x:%2x:%2x:%2x:%2x:%2x] associated at any peer\n", pAddr[0], pAddr[1], pAddr[2], pAddr[3], pAddr[4], pAddr[5]));
		FunctionOut(COMP_MLME);
		PlatformReleaseSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);
		return ;
	}
	RT_TRACE(COMP_INIT, DBG_LOUD, ("WDI_DeleteDatapathPeer: Find the addres [%2x:%2x:%2x:%2x:%2x:%2x] associated at Peer %d\n", pAddr[0], pAddr[1], pAddr[2], pAddr[3], pAddr[4], pAddr[5], pPeerEntry->uPeerId));

	pDefaultAdapter->RxPeerUsedCount--;
	PeerId = (WDI_PEER_ID)pPeerEntry->uPeerId;
	PortId = (WDI_PORT_ID)pPeerEntry->uPortId;
	pPeerEntry->bUsed = FALSE;
	PlatformZeroMemory(pPeerEntry->PeerAddr, 6);

	pWdi->WdiDataApi.PeerDeleteIndication(pWdi->DataPathHandle, PortId, PeerId, &ndisStatus);

	WDI_FreeRxFrame(pAdapter, (PNET_BUFFER_LIST)N6CGetHeadNblWaitQueue(pDefaultAdapter->RxPeerQueue[PeerId]));
	RTInitializeSListHead(&pDefaultAdapter->RxPeerQueue[PeerId]);

	PlatformReleaseSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);

	RT_TRACE(COMP_MLME, DBG_LOUD, ("WDI_DeleteDatapathPeer: delete peer %d, Status: %d\n", PeerId, ndisStatus));

	FunctionOut(COMP_MLME);
}

VOID
WDI_FetchNBLByPort(
	IN		PADAPTER			pAdapter,
	IN		u2Byte				Port_ID,
	OUT		PNET_BUFFER_LIST	*ppNetBufferList
)
{
	PADAPTER				pDefaultAdapter = GetDefaultAdapter(pAdapter);
	u2Byte					index = 0;
	PRT_SINGLE_LIST_ENTRY	pFirst = NULL, pTemp = NULL;

	*ppNetBufferList = NULL;

	RT_TRACE(COMP_RECV, DBG_LOUD, ("WDI_FetchNBLByPort: fetch frames of all peers at port %d\n", Port_ID));

	if( Port_ID != WDI_PORT_ANY )
	{
		PlatformAcquireSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);
		for(index = 0; index < MAX_PEER_NUM; index++)
		{
			if( (pDefaultAdapter->RxPeerTable[index].bUsed == TRUE) && (pDefaultAdapter->RxPeerTable[index].uPortId == Port_ID) )
			{
				if(N6CIsNblWaitQueueEmpty(pDefaultAdapter->RxPeerQueue[index]))
					continue;

				pTemp = RTGetHeadSList(&pDefaultAdapter->RxPeerQueue[index]);
				if( pFirst == NULL )
				{
					pFirst = pTemp;
				}
				else
				{
					N6CConcatenateTwoList(pFirst, pTemp);
				}
				RTInitializeSListHead(&pDefaultAdapter->RxPeerQueue[index]);
			}
		}

		if( pFirst != NULL )
		{
			*ppNetBufferList = RT_GET_NBL_FROM_QUEUE_LINK(pFirst);
		}
		PlatformReleaseSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);
	}
	else
	{
		PlatformAcquireSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);
		for(index = 0; index < MAX_PEER_NUM; index++)
		{
			if( (pDefaultAdapter->RxPeerTable[index].bUsed == TRUE) )
			{
				if(N6CIsNblWaitQueueEmpty(pDefaultAdapter->RxPeerQueue[index]))
					continue;

				pTemp = RTGetHeadSList(&pDefaultAdapter->RxPeerQueue[index]);
				if( pFirst == NULL )
				{
					pFirst = pTemp;
				}
				else
				{
					N6CConcatenateTwoList(pFirst, pTemp);
				}
				RTInitializeSListHead(&pDefaultAdapter->RxPeerQueue[index]);
			}
		}

		if( pFirst != NULL )
		{
			*ppNetBufferList = RT_GET_NBL_FROM_QUEUE_LINK(pFirst);
		}
		PlatformReleaseSpinLock(pAdapter, RT_RX_QUEUE_SPINLOCK);
	}
}

VOID
WDI_FreeRxFrame(
	IN	PADAPTER	pAdapter,
	IN	PNET_BUFFER_LIST pNetBufferList
)
{
	PADAPTER			pDefaultAdapter = GetDefaultAdapter(pAdapter);
	PRT_RFD				pRfd = NULL;
	PMDL				pCurrMdl = NULL, pNextMdl = NULL;
	PNET_BUFFER_LIST		pNextNBL = NULL;
	u4Byte				Count;
	PRT_NDIS6_COMMON	pNdisCommon = pAdapter->pNdisCommon;

	FunctionIn(COMP_RECV);

	if( pNetBufferList == NULL )
	{
		RT_TRACE(COMP_RECV, DBG_TRACE, ("WDI_FreeRxFrame: pNetBufferList is NULL\n"));
		FunctionOut(COMP_RECV);
		return;
	}

	do
	{
		//Get next NBL
		pNextNBL = NET_BUFFER_LIST_NEXT_NBL(pNetBufferList);

		//Get RFD from NBL
		pRfd = MP_GET_PACKET_RFD(pNetBufferList);

		//Free all MDL
		for (pCurrMdl = NET_BUFFER_FIRST_MDL( NET_BUFFER_LIST_FIRST_NB(pNetBufferList) );
			pCurrMdl != NULL;
			pCurrMdl = pNextMdl)
		{
			pNextMdl = NDIS_MDL_LINKAGE(pCurrMdl);
			NdisFreeMdl(pCurrMdl);
		}

		//Free Rx metadata
		WDIFreeMetaData(pAdapter, pNetBufferList);

		//Free NBL
		NdisFreeNetBufferList(pNetBufferList);

		//Re-calculate reference count
		PlatformAcquireSpinLock(pAdapter, RT_RX_REF_CNT_SPINLOCK);
		RT_DEC_RCV_REF(pDefaultAdapter);
		Count = RT_GET_RCV_REF(pDefaultAdapter);
		GLWdiTxRxStatistics.numRxReturnNBLFromUE++;
		PlatformReleaseSpinLock(pAdapter, RT_RX_REF_CNT_SPINLOCK);

		//Return RFD to RFD list
		if( pRfd != NULL )
		{
			ReturnRFDList(pAdapter, pRfd);
		}

		//Assign NextNBL pointer
		pNetBufferList = pNextNBL;
	}while(pNetBufferList!=NULL);

	if (Count == 0)
	{
		NdisSetEvent(&pNdisCommon->AllPacketReturnedEvent);

		if(pAdapter->MgntInfo.NdisVersion >= RT_NDIS_VERSION_6_20)
		{
			PADAPTER pTempAdapter = GetFirstExtAdapter(pAdapter);
			while(pTempAdapter != NULL)
			{
				NdisSetEvent(&pTempAdapter->pNdisCommon->AllPacketReturnedEvent);
				pTempAdapter = GetNextExtAdapter(pTempAdapter);
			}
		}
	}

	FunctionOut(COMP_RECV);
}

VOID
WDI_IndicateTKIPMICFailure(
	PADAPTER		pAdapter
	)
{
	PMGNT_INFO				pMgntInfo;
	pMgntInfo = &(pAdapter->MgntInfo);
	PUCHAR											pOutput = NULL;
	ULONG											length = 0;
	NDIS_STATUS 									ndisStatus = NDIS_STATUS_SUCCESS;
	WDI_INDICATION_TKIP_MIC_FAILURE_PARAMETERS 		Params={0};

	FunctionIn(COMP_SEC);


	Params.FailureInfo.DefaultKeyFailure = FALSE;
	Params.FailureInfo.KeyIndex=0;
	//WDI_TKIPFailureParam.PeerMacAddress=pMgntInfo->Bssid;
	cpMacAddr(Params.FailureInfo.PeerMacAddress.Address, pMgntInfo->Bssid);



	ndisStatus = GenerateWdiIndicationTkipMicFailure(
				&Params,
				sizeof(NDIS_STATUS_INDICATION)+sizeof(WDI_MESSAGE_HEADER),
				&pAdapter->pPortCommonInfo->WdiData.TlvContext,
				&length,
				&pOutput);

	if(NDIS_STATUS_SUCCESS == ndisStatus)
	{
		wdi_UnsolicitedIndication(pAdapter,
								FALSE,
								NULL,
								NDIS_STATUS_WDI_INDICATION_TKIP_MIC_FAILURE,
								ndisStatus,
								pOutput,
								length);

		FreeGenerated(pOutput);
		pOutput = NULL;
	}
	FunctionOut(COMP_SEC);


}

VOID
WDI_TxCreditCheck(
	IN  PADAPTER		pAdapter
	)
{
	PWDI_DATA_STRUCT	pWdi = &(pAdapter->pPortCommonInfo->WdiData);
	u4Byte				preTxPauseReason;
	u2Byte				txCredit=0;

	GLWdiTxRxStatistics.numCheckTxPause++;
	GLWdiTxRxStatistics.monitorTxPauseReason = pWdi->txPauseReason;

	// First check if we have pause indication before.
	// not to acquire tx lock frequently, so we do not acquire tx lock when read, but remember
	// we should acquire tx lock when need to change the pause reason.
	if(pWdi->txPauseReason)
	{
		PlatformAcquireSpinLock(pAdapter, RT_TX_SPINLOCK);

		txCredit = *Get_NUM_IDLE_TCB(pAdapter);
		preTxPauseReason = pWdi->txPauseReason;

		RT_TRACE(COMP_INIT, DBG_LOUD, ("[WDI], WDI_TxCreditCheck(): txCredit=%d\n", txCredit));

		if(txCredit > (pAdapter->RT_TCB_NUM/4))
		{
			GLWdiTxRxStatistics.numTxResourceAvailable++;

			if( (preTxPauseReason&WDI_TX_PAUSE_REASON_CREDIT) == WDI_TX_PAUSE_REASON_CREDIT)
			{
				RT_TRACE(COMP_INIT, DBG_LOUD, ("[WDI], WDI_TxCreditCheck(): TxPauseReason = 0x%x!!!\n", preTxPauseReason));
				GLWdiTxRxStatistics.numWdiTxRestartIndicate++;
				RT_TRACE(COMP_INIT, DBG_LOUD, ("[WDI], WDI_TxCreditCheck(): TxSendRestart: %d times!!!\n",
					GLWdiTxRxStatistics.numWdiTxRestartIndicate));

				pWdi->txPauseReason &= ~WDI_TX_PAUSE_REASON_CREDIT;
				PlatformReleaseSpinLock(pAdapter, RT_TX_SPINLOCK);

				// Before indicate to WDI, release the tx lock.
				pWdi->WdiDataApi.TxSendRestartIndication(pWdi->DataPathHandle,
														WDI_PORT_ANY,
														WDI_PEER_ANY,
	    													WDI_EXT_TID_UNKNOWN,
	    													WDI_TX_PAUSE_REASON_CREDIT);
				RT_TRACE(COMP_INIT, DBG_LOUD, ("[WDI], WDI_TxCreditCheck(): pWdi->txPauseReason = 0x%x\n", pWdi->txPauseReason));
			}
			else
			{
				PlatformReleaseSpinLock(pAdapter, RT_TX_SPINLOCK);
			}
		}
		else
		{
			PlatformReleaseSpinLock(pAdapter, RT_TX_SPINLOCK);
		}
	}
}

VOID
WDI_IndicateFWStalled(
	IN  PADAPTER				pAdapter
	)
{
	PWDI_DATA_STRUCT			pWdi = &(pAdapter->pPortCommonInfo->WdiData);
	NDIS_STATUS_INDICATION		statusIndication = {0};
	WDI_MESSAGE_HEADER			WdiHeader = {0};

	if(!pWdi->bWdiLEPLDR)
		return;

	RT_TRACE(COMP_OID_SET, DBG_LOUD, ("==> WDI_IndicateFWStalled\n"));

	N6_ASSIGN_OBJECT_HEADER(
		statusIndication.Header,
		NDIS_OBJECT_TYPE_STATUS_INDICATION,
		NDIS_SIZEOF_STATUS_INDICATION_REVISION_1,
		NDIS_STATUS_INDICATION_REVISION_1);

	WdiHeader.PortId = 0xFFFF;
	WdiHeader.Status = NDIS_STATUS_SUCCESS;
	WdiHeader.TransactionId = 0;

	statusIndication.RequestId = NULL;
	statusIndication.SourceHandle = pAdapter;
	statusIndication.StatusBuffer = &WdiHeader;
	statusIndication.StatusBufferSize = sizeof(WDI_MESSAGE_HEADER);

	statusIndication.StatusCode = NDIS_STATUS_WDI_INDICATION_FIRMWARE_STALLED;

	NdisMIndicateStatusEx(
		pAdapter->pNdisCommon->hNdisAdapter,
		&statusIndication
		);
}

VOID
WDI_UpdateDefaultSetting(
	IN  PADAPTER				pAdapter
	)
{
	PRT_NDIS_COMMON			pNdisCommon = pAdapter->pNdisCommon;
	PWDI_DATA_STRUCT	pWdi = &(pAdapter->pPortCommonInfo->WdiData);

	// Enable for LE Hang detection and recovery function
	pWdi->bWdiLEPLDR = pNdisCommon->RegHangDetection;

	RT_TRACE(COMP_INIT, DBG_LOUD, ("WDI_UpdateDefaultSetting(): bWdiLEPLDR(%d)\n", pWdi->bWdiLEPLDR));
}

//
// Description:
//	Indicate the specific (non-common for all platform) event/status to WDI.
// Arguments:
//	[in] pAdapter -
//		The adapter context.
//	[in] event -
//		The event of the indication.
//	[in] pInfoBuffer -
//		The pointer to the input information. It can be NULL.
//	[in] InfoBruuferLen -
//		The length in byte for pInfoBuffer.
// Return:
//	It may return RT_STATUS_SUCCESS if this function completes successfully, or RT_STATUS_PENDING
//	for the asynchrous process.
// By Bruce, 2015-12-16.
//
RT_STATUS
WDI_IndicateGeneralEvent(
	IN	PADAPTER		pAdapter,
	IN	u4Byte			Event,
	IN	PVOID			pInfoBuffer,
	IN	u4Byte			InfoBruuferLen
	)
{
	RT_STATUS	rtStatus = RT_STATUS_SUCCESS;

	switch(Event)
	{
	default:
		{
			RT_TRACE_F(COMP_INDIC, DBG_WARNING, ("Unrecognized event = 0x%08X\n", Event));
			rtStatus = RT_STATUS_NOT_RECOGNIZED;
		}
		break;




	case RT_CUSTOM_EVENT_WDI_FT_ASSOC_NEEDED:
		{
			rtStatus = wdiext_IndicateFtAssocNeeded(pAdapter);
		}
		break;
	}
	return rtStatus;
}

#endif