WDI Sample

Adding WDI sample from partner enablement-China

1 files changed, 660 insertions, 0 deletions

diff --git a/network/wlan/WDI/COMMON/P2P_Attribute.c b/network/wlan/WDI/COMMON/P2P_Attribute.c
new file mode 100644
index 00000000..1c2e20d8
--- /dev/null
+++ b/network/wlan/WDI/COMMON/P2P_Attribute.c
@@ -0,0 +1,660 @@
+#include "Mp_Precomp.h"
+
+#if WPP_SOFTWARE_TRACE
+#include "P2P_Attribute.tmh"
+#endif
+
+#if (P2P_SUPPORT == 1)
+#include "P2P_Internal.h"
+
+#ifdef MOD_TRACE_TAG
+#undef MOD_TRACE_TAG
+#endif
+#define MOD_TRACE_TAG "P2PAttr"
+
+#define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
+#define MACSTR "%02X:%02X:%02X:%02X:%02X:%02X"
+
+#if (P2P_SUPPORT == 1)
+
+//-----------------------------------------------------------------------------
+// Local
+//-----------------------------------------------------------------------------
+
+static
+VOID
+p2pattr_make_DevType(
+	IN  FRAME_BUF				*pBuf,
+	IN  u2Byte					catId,
+	IN  const u1Byte			*oui,
+	IN  u2Byte 					subCatId
+	)
+{
+	FrameBuf_Add_be_u2(pBuf, catId);
+	FrameBuf_Add_Data(pBuf, oui, 4);
+	FrameBuf_Add_be_u2(pBuf, subCatId);
+	
+	return;
+}
+
+static
+VOID
+p2pattr_make_WpsDevType(
+	IN  FRAME_BUF				*pBuf,
+	IN  const P2P_WPS_ATTRIBUTES_DEVICE_TYPE *type
+	)
+{
+	p2pattr_make_DevType(pBuf, type->CategoryId, type->Oui, type->SubCategoryId);
+	
+	return;
+}
+
+static
+VOID
+p2pattr_make_WpsSecDevTypeList(
+	IN  FRAME_BUF				*pBuf,
+	IN  u1Byte					numSecDevType,
+	IN  const P2P_WPS_ATTRIBUTES_DEVICE_TYPE *pSecDevTypeList 
+	)
+{
+	u1Byte 						itTypeList = 0;
+	
+	FrameBuf_Add_u1(pBuf, numSecDevType);
+	for(itTypeList = 0; itTypeList < numSecDevType; itTypeList++)
+	{
+		p2pattr_make_WpsDevType(pBuf, pSecDevTypeList + itTypeList);
+	}
+
+	return;
+}
+
+static
+VOID
+p2pattr_make_DevName(
+	IN  FRAME_BUF				*pBuf,
+	IN  u1Byte					devNameLen,
+	IN  const u1Byte			*devName
+	)
+{
+	FrameBuf_Add_be_u2(pBuf, P2P_WPS_ATTR_TAG_DEVICE_NAME);
+	FrameBuf_Add_be_u2(pBuf, devNameLen);
+	FrameBuf_Add_Data(pBuf, devName, devNameLen);
+
+	return;
+}
+
+static
+VOID
+p2pattr_make_CliInfoDesc(
+	IN  FRAME_BUF				*pBuf,
+	IN  const RT_WLAN_STA		*pCli
+	)
+{
+	const P2P_CLIENT_INFO_DISCRIPTOR 	*pDesc = &pCli->P2PClientInfoDesc;
+	const P2P_WPS_ATTRIBUTES			*pWps = &pDesc->WpsAttributes;
+	u1Byte								*pLen = NULL;
+	u2Byte								initBufLen = 0;
+
+	if(NULL == (pLen = FrameBuf_Add(pBuf, 1))) return;
+
+	initBufLen = FrameBuf_Length(pBuf);
+	
+	FrameBuf_Add_Data(pBuf, pDesc->DeviceAddress, 6);
+	FrameBuf_Add_Data(pBuf, pDesc->InterfaceAddress, 6);
+	FrameBuf_Add_u1(pBuf, pDesc->DeviceCapability);
+	FrameBuf_Add_be_u2(pBuf, pWps->ConfigMethod);
+	p2pattr_make_WpsDevType(pBuf, &pWps->PrimaryDeviceType);
+	p2pattr_make_WpsSecDevTypeList(pBuf, pWps->SecondaryDeviceTypeLength, pWps->SecondaryDeviceTypeList);
+	p2pattr_make_DevName(pBuf, pWps->DeviceNameLength, pWps->DeviceName);
+
+	if(FrameBuf_Length(pBuf) - initBufLen > 0 && FrameBuf_Length(pBuf) - initBufLen < 0xFF)
+	{
+		*pLen = (u1Byte)(FrameBuf_Length(pBuf) - initBufLen);		
+	}
+
+	return;
+}
+
+static
+VOID
+p2pattr_make_CliInfoDescList(
+	IN  FRAME_BUF				*pBuf,
+	IN  const RT_WLAN_STA		*pCliList
+	)
+{
+	u1Byte						itList = 0;
+	
+	for(itList = 0; itList < ASSOCIATE_ENTRY_NUM; itList++)
+	{
+		const RT_WLAN_STA 		*pEntry = pCliList + itList;
+				
+		if(!(pEntry->bUsed && pEntry->bAssociated && pEntry->bP2PClient))
+			continue;
+
+		p2pattr_make_CliInfoDesc(pBuf, pEntry);
+	}
+	
+	return;
+}
+
+static
+VOID
+p2pattr_make_IntfAddrList(
+	IN  FRAME_BUF				*pBuf,
+	IN  u1Byte					numIntfAddr,
+	IN  const pu1Byte			intfAddrList
+	)
+{
+	u1Byte						itList = 0;
+
+	FrameBuf_Add_u1(pBuf, numIntfAddr);
+	
+	for(itList = 0; itList < numIntfAddr; itList++)
+	{
+		FrameBuf_Add_Data(pBuf, intfAddrList + (6 * itList), 6);
+	}
+	
+	return;
+}
+
+VOID
+p2pattr_Make_ChannelEntryList(
+	IN  FRAME_BUF				*pBuf,
+	IN  const P2P_CHANNELS		*commonChannels
+	)
+{
+	u1Byte 						it = 0;
+
+	for(it = 0; it < commonChannels->regClasses; it++)
+	{
+		if(!commonChannels->regClass[it].channels)
+			continue;
+		
+		P2PAttr_Make_ChannelEntry(pBuf, 
+			commonChannels->regClass[it].regClass, 
+			commonChannels->regClass[it].channels, 
+			commonChannels->regClass[it].channel);
+	}
+
+	return;
+}
+
+//-----------------------------------------------------------------------------
+// Exported
+//-----------------------------------------------------------------------------
+
+VOID
+P2PAttr_Update_AttrHdrLen(
+	IN  FRAME_BUF				*pBuf,
+	IN  const u1Byte			*pLen
+	)
+{
+	WriteEF2Byte(pLen, (u2Byte)(FrameBuf_Tail(pBuf) - pLen - 2));
+	return;
+}
+
+VOID
+P2PAttr_Make_Status(
+	IN  FRAME_BUF				*pBuf,
+	IN  u1Byte 					status
+	)
+{
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_STATUS);
+	FrameBuf_Add_le_u2(pBuf, 1);
+	FrameBuf_Add_u1(pBuf, status);
+	
+	//RT_TRACE_F(COMP_P2P, FrameBuf_DbgLevel(pBuf), ("[%s] statue: %u, channel: %u\n", MOD_TRACE_TAG, status));
+
+	return;
+}
+
+VOID
+P2PAttr_Make_MinorReasonCode(
+	IN  FRAME_BUF				*pBuf,
+	IN  u1Byte 					minorReasonCode
+	)
+{
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_MINOR_REASON_CODE);
+	FrameBuf_Add_le_u2(pBuf, 1);
+	FrameBuf_Add_u1(pBuf, minorReasonCode);
+	
+	RT_TRACE_F(COMP_P2P, FrameBuf_DbgLevel(pBuf), ("[%s] minor reason code: %u\n", MOD_TRACE_TAG, minorReasonCode));
+
+	return;
+}
+
+VOID
+P2PAttr_Make_Capability(
+	IN  FRAME_BUF				*pBuf,
+	IN  u1Byte					devCap,
+	IN  u1Byte					grpCap
+	)
+{
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_CAPABILITY);
+	FrameBuf_Add_le_u2(pBuf, 2);
+	FrameBuf_Add_u1(pBuf, devCap);
+	FrameBuf_Add_u1(pBuf, grpCap);
+
+	RT_TRACE_F(COMP_P2P, FrameBuf_DbgLevel(pBuf), ("[%s] devCap: %02X, grpCap: %02X\n", MOD_TRACE_TAG, devCap, grpCap));
+	
+	return;
+}
+
+VOID
+P2PAttr_Make_DevId(
+	IN  FRAME_BUF				*pBuf,
+	IN  const pu1Byte			devAddr
+	)
+{
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_DEVICE_ID);
+	FrameBuf_Add_le_u2(pBuf, 6);
+	FrameBuf_Add_Data(pBuf, devAddr, 6);
+
+	//RT_TRACE_F(COMP_P2P, FrameBuf_DbgLevel(pBuf), ("[%s] devAddr: " MACSTR "\n", MOD_TRACE_TAG, MAC2STR(devAddr)));
+
+	return;
+}
+
+VOID
+P2PAttr_Make_GoIntent(
+	IN  FRAME_BUF				*pBuf,
+	IN  u1Byte					intent
+	)
+{
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_GROUP_OWNER_INTENT);
+	FrameBuf_Add_le_u2(pBuf, 1);
+	FrameBuf_Add_u1(pBuf, intent);
+
+	RT_TRACE_F(COMP_P2P, FrameBuf_DbgLevel(pBuf), ("[%s] intent: %u, tie: %u\n", MOD_TRACE_TAG, intent >> 1, intent & 0x01));
+
+	return;
+}
+
+VOID 
+P2PAttr_Make_ConfigTimeout(
+	IN  FRAME_BUF				*pBuf,
+	IN  u1Byte 					goTimeout,
+	IN  u1Byte 					cliTimeout
+	)
+{
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_CONFIGURATION_TIMEOUT);
+	FrameBuf_Add_le_u2(pBuf, 2);
+	FrameBuf_Add_u1(pBuf, goTimeout);
+	FrameBuf_Add_u1(pBuf, cliTimeout);
+
+	RT_TRACE_F(COMP_P2P, FrameBuf_DbgLevel(pBuf), ("[%s] goTimeout: %u (10ms), cliTimeout: %u (10ms)\n", MOD_TRACE_TAG, goTimeout, cliTimeout));
+
+	return;
+}
+
+VOID
+P2PAttr_Make_ListenChannel(
+	IN  FRAME_BUF				*pBuf,
+	IN  const char *			country,
+	IN  u1Byte					regClass,
+	IN  u1Byte					channel
+	)
+{
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_LISTEN_CHANNEL);
+	FrameBuf_Add_le_u2(pBuf, 5);
+	FrameBuf_Add_Data(pBuf, country, 3);
+	FrameBuf_Add_u1(pBuf, regClass);
+	FrameBuf_Add_u1(pBuf, channel);
+
+	RT_TRACE_F(COMP_P2P, FrameBuf_DbgLevel(pBuf), ("[%s] country: %c%c(0x%02x), reg class: %u, channel: %u\n", MOD_TRACE_TAG, country[0], country[1], country[2], regClass, channel));
+
+	return;
+}
+
+VOID 
+P2PAttr_Make_GroupBssid(
+	IN  FRAME_BUF				*pBuf,
+	IN  const pu1Byte			grpBssid
+	)
+{
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_GROUP_BSSID);
+	FrameBuf_Add_le_u2(pBuf, 6);
+	FrameBuf_Add_Data(pBuf, grpBssid, 6);
+
+	//RT_TRACE_F(COMP_P2P, FrameBuf_DbgLevel(pBuf), ("[%s] grpBssid: " MACSTR "\n", MOD_TRACE_TAG, MAC2STR(grpBssid)));
+
+	return;
+}
+
+VOID 
+P2PAttr_Make_ExtListenTiming(
+	IN  FRAME_BUF				*pBuf,
+	IN  u2Byte					period,
+	IN  u2Byte					interval
+	)
+{
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_EXT_LISTEN_TIMING);
+	FrameBuf_Add_le_u2(pBuf, 4);
+	FrameBuf_Add_le_u2(pBuf, period);
+	FrameBuf_Add_le_u2(pBuf, interval);
+
+	RT_TRACE_F(COMP_P2P, FrameBuf_DbgLevel(pBuf), ("[%s] period: %u (ms), interval: %u (ms)\n", MOD_TRACE_TAG, period, interval));
+
+	return;
+}
+
+VOID 
+P2PAttr_Make_IntendedIntfAddr(
+	IN  FRAME_BUF				*pBuf,
+	IN  const pu1Byte			intfAddr
+	)
+{
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_INTENDED_INTERFACE_ADDRESS);
+	FrameBuf_Add_le_u2(pBuf, 6);
+	FrameBuf_Add_Data(pBuf, intfAddr, 6);
+
+	//RT_TRACE_F(COMP_P2P, FrameBuf_DbgLevel(pBuf), ("[%s] intended intf Addr: " MACSTR "\n", MOD_TRACE_TAG, MAC2STR(intfAddr)));
+
+	return;
+}
+
+VOID
+P2PAttr_Make_Manageability(
+	IN  FRAME_BUF				*pBuf,
+	IN  u1Byte					manageability
+	)
+{
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_MANAGEABILITY);
+	FrameBuf_Add_le_u2(pBuf, 1);
+	FrameBuf_Add_u1(pBuf, manageability);
+
+	RT_TRACE_F(COMP_P2P, FrameBuf_DbgLevel(pBuf), ("[%s] manageability: %u\n", MOD_TRACE_TAG, manageability));
+
+	return;
+}
+
+VOID
+P2PAttr_Make_ChannelEntry(
+	IN  FRAME_BUF				*pBuf,
+	IN  u1Byte					regClass,
+	IN  u1Byte					nChannels,
+	IN  const u1Byte			*channelList
+	)
+{
+	u1Byte						it = 0;
+
+	if(0 == nChannels)
+		return;
+	
+	// Regulatory class
+	FrameBuf_Add_u1(pBuf, regClass);
+
+	// Number of channels
+	FrameBuf_Add_u1(pBuf, nChannels);
+
+	// Channel list
+	for(it = 0; it < nChannels; it++) 
+		FrameBuf_Add_u1(pBuf, channelList[it]);
+
+	return;
+}
+
+VOID
+P2PAttr_Make_ChannelList(
+	IN  FRAME_BUF				*pBuf,
+	IN  P2P_INFO				*pP2PInfo,
+	IN  const P2P_CHANNELS		*channels
+	)
+{
+	u1Byte 						*pLen = NULL;
+
+	if(P2P_ADAPTER_OS_SUPPORT_P2P(pP2PInfo->pAdapter))
+	{
+		// If the default port is connected, then only use the default port channel ----------------------
+		if(MgntLinkStatusQuery(GetDefaultAdapter(pP2PInfo->pAdapter)) == RT_MEDIA_CONNECT)
+		{
+		#if 0
+			#if (MULTICHANNEL_SUPPORT == 1)	// For Compilation: Only PCI-E Support MultiChannel Now
+
+			u1Byte uPortConnected20MhzChannel = MultiChannelGetPortConnected20MhzChannel(GetDefaultAdapter(pP2PInfo->pAdapter));
+			
+			MgntActSet_P2PChannelList(
+					pP2PInfo->pAdapter, 
+					1, 
+					&uPortConnected20MhzChannel
+				);
+			
+			#endif
+		#endif
+		}
+		else
+		{
+			P2PInitializeChannelEntryList(pP2PInfo);
+		}
+	}
+	// ----------------------------------------------------------------------------------
+
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_CHANNEL_LIST);
+	pLen = FrameBuf_Add(pBuf, 2);
+	FrameBuf_Add_Data(pBuf, pP2PInfo->CountryString, sizeof(pP2PInfo->CountryString));
+	p2pattr_Make_ChannelEntryList(pBuf, channels);
+
+	P2PAttr_Update_AttrHdrLen(pBuf, pLen);
+
+	return;
+}
+
+VOID 
+P2PAttr_Make_Noa(
+	IN  FRAME_BUF 				*pBuf,
+	IN  u1Byte					noaIEIndex,
+	IN  BOOLEAN 				bOppPS,
+	IN  u1Byte 					ctWindow,
+	IN  u1Byte					noaDescNum,
+	IN  const P2P_NOA_DESCRIPTOR *noaDesc
+	)
+{
+	pu1Byte						pLen = NULL;
+	u1Byte						oppPsAndCtWindow = 0;
+	u1Byte						itNoaDesc = 0;
+
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_NOTICE_OF_ABSENCE);
+	if(NULL == (pLen = FrameBuf_Add(pBuf, 2))) return;
+
+	FrameBuf_Add_u1(pBuf, noaIEIndex);
+
+	oppPsAndCtWindow = 0;
+	oppPsAndCtWindow |= (bOppPS) ? BIT7 : 0;
+	oppPsAndCtWindow |= (ctWindow & (~BIT7));
+	FrameBuf_Add_u1(pBuf, oppPsAndCtWindow);
+
+	for(itNoaDesc = 0; itNoaDesc < noaDescNum; itNoaDesc++)
+	{
+		if(!noaDesc[itNoaDesc].bValid) continue;
+
+		FrameBuf_Add_u1(pBuf, noaDesc[itNoaDesc].CountOrType);
+		FrameBuf_Add_le_u4(pBuf, noaDesc[itNoaDesc].Duration);
+		FrameBuf_Add_le_u4(pBuf, noaDesc[itNoaDesc].Interval);
+		FrameBuf_Add_le_u4(pBuf, noaDesc[itNoaDesc].StartTime);
+	}
+
+	P2PAttr_Update_AttrHdrLen(pBuf, pLen);
+
+	return;
+}
+
+VOID
+P2PAttr_Make_NoaFromPsSet(
+	IN  FRAME_BUF				*pBuf,
+	IN  const P2P_POWERSAVE_SET	*pPs
+	)
+{
+	pu1Byte						pLen = NULL;
+	u4Byte						itNoaDesc = 0;
+
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_NOTICE_OF_ABSENCE);
+	if(NULL == (pLen = FrameBuf_Add(pBuf, 2))) return;
+
+	for(itNoaDesc = 0; itNoaDesc < P2P_MAX_NUM_NOA_DESC; itNoaDesc++)
+	{
+		u1Byte					countType = 0;
+		
+		if(FALSE == pPs->NoASet[itNoaDesc].bNoAEn) continue;
+
+		if(2 < pPs->NoASet[itNoaDesc].NoACnt || pPs->NoASet[itNoaDesc].NoACnt < 1)
+			countType = 1;
+		else 
+			countType = pPs->NoASet[itNoaDesc].NoACnt;
+			
+		FrameBuf_Add_u1(pBuf, countType);
+		FrameBuf_Add_le_u4(pBuf, pPs->NoASet[itNoaDesc].NoADur);
+		FrameBuf_Add_le_u4(pBuf, pPs->NoASet[itNoaDesc].NoAInt);
+	}
+	
+	P2PAttr_Update_AttrHdrLen(pBuf, pLen);
+
+	return;
+}
+
+VOID
+P2PAttr_Make_DevInfo(
+	IN  FRAME_BUF				*pBuf,
+	IN  const u1Byte			*devAddr,
+	IN  u2Byte					configMethods,
+	IN  const P2P_WPS_ATTRIBUTES_DEVICE_TYPE *pPrimDevType,
+	IN  u1Byte 					numSecDevType,
+	IN  const P2P_WPS_ATTRIBUTES_DEVICE_TYPE *pSecDevTypeList,
+	IN  u1Byte					devNameLen,
+	IN  const u1Byte			*devName
+	)
+{
+	u1Byte						*pLen = NULL;
+	u1Byte						itTypeList = 0;
+	
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_DEVICE_INFO);
+	if(NULL == (pLen = FrameBuf_Add(pBuf, 2))) return;
+
+	FrameBuf_Add_Data(pBuf, devAddr, 6);
+	FrameBuf_Add_be_u2(pBuf, configMethods);
+	p2pattr_make_WpsDevType(pBuf, pPrimDevType);
+	p2pattr_make_WpsSecDevTypeList(pBuf, numSecDevType, pSecDevTypeList);
+	p2pattr_make_DevName(pBuf, devNameLen, devName);
+
+	P2PAttr_Update_AttrHdrLen(pBuf, pLen);
+
+	//FrameBuf_DumpFrom(pBuf, pLen - 1, COMP_P2P, FrameBuf_DbgLevel(pBuf), __FUNCTION__);
+
+	return;
+}
+
+VOID
+P2PAttr_Make_GroupInfo(
+	IN  FRAME_BUF				*pBuf,
+	IN  const RT_WLAN_STA		*pCliList
+	)
+{
+	
+	pu1Byte						pLen = NULL;
+	FRAME_BUF					tBuf;
+
+	FrameBuf_Init(FrameBuf_TailRoom(pBuf), 0, FrameBuf_MTail(pBuf), &tBuf);
+
+	FrameBuf_Add_u1(&tBuf, P2P_ATTR_GROUP_INFO);
+	if(NULL == (pLen = FrameBuf_Add(&tBuf, 2))) return;
+
+	p2pattr_make_CliInfoDescList(&tBuf, pCliList);
+
+	P2PAttr_Update_AttrHdrLen(&tBuf, pLen);
+
+	if(0 == FrameBuf_Length(&tBuf))
+	{
+		// Clause 3.2.4: the p2p group owner shall not 
+		// include a p2p group info subelement if it 
+		// has zero connected p2p clients
+		return;
+	}
+
+	FrameBuf_Add(pBuf, FrameBuf_Length(&tBuf));
+
+	//FrameBuf_DumpFrom(pBuf, pLen - 1, COMP_P2P, FrameBuf_DbgLevel(pBuf), __FUNCTION__);
+
+	return;
+}
+
+VOID 
+P2PAttr_Make_GroupId(
+	IN  FRAME_BUF				*pBuf,
+	IN  const pu1Byte			grpDevAddr,
+	IN  const pu1Byte			grpSsid,
+	IN  u1Byte					grpSsidLen
+	)
+{
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_GROUP_ID);
+	FrameBuf_Add_le_u2(pBuf, 6 + grpSsidLen);
+	FrameBuf_Add_Data(pBuf, grpDevAddr, 6);
+	FrameBuf_Add_Data(pBuf, grpSsid, grpSsidLen);
+
+	//RT_TRACE_F(COMP_P2P, FrameBuf_DbgLevel(pBuf), ("[%s] grpDevAddr: " MACSTR "\n", MOD_TRACE_TAG, MAC2STR(grpDevAddr)));
+	RT_PRINT_DATA(COMP_P2P, FrameBuf_DbgLevel(pBuf), "grpSsid", grpSsid, grpSsidLen);
+
+	return;
+}
+
+
+VOID 
+P2PAttr_Make_Interface(
+	IN  FRAME_BUF				*pBuf,
+	IN  const pu1Byte			devAddr,
+	IN  u1Byte					numIntfAddr,
+	IN  const pu1Byte			intfAddrList
+	)
+{
+	pu1Byte						pLen = NULL;
+
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_INTERFACE);
+	if(NULL == (pLen = FrameBuf_Add(pBuf, 2))) return;
+
+	FrameBuf_Add_Data(pBuf, devAddr, 6);
+	p2pattr_make_IntfAddrList(pBuf, numIntfAddr, intfAddrList);
+
+	P2PAttr_Update_AttrHdrLen(pBuf, pLen);
+
+	//FrameBuf_DumpFrom(pBuf, pLen - 1, COMP_P2P, DBG_LOUD, __FUNCTION__);
+
+	return;
+}
+
+VOID
+P2PAttr_Make_OperatingChannel(
+	IN  FRAME_BUF				*pBuf,
+	IN  const char *			country,
+	IN  u1Byte					regClass,
+	IN  u1Byte					channel
+	)
+{
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_OP_CHANNEL);
+	FrameBuf_Add_le_u2(pBuf, 5);
+	FrameBuf_Add_Data(pBuf, country, 3);
+	FrameBuf_Add_u1(pBuf, regClass);
+	FrameBuf_Add_u1(pBuf, channel);
+	
+	RT_TRACE_F(COMP_P2P, FrameBuf_DbgLevel(pBuf), ("[%s] country: 0x%02X%02X%02X, reg class: %u, channel: %u\n", MOD_TRACE_TAG, country[0], country[1], country[2], regClass, channel));
+
+	return;
+}
+
+VOID 
+P2PAttr_Make_InvitationFlags(
+	IN  FRAME_BUF				*pBuf,
+	IN  u1Byte					flags
+	)
+{
+	FrameBuf_Add_u1(pBuf, P2P_ATTR_INVITATION_FLAGS);
+	FrameBuf_Add_le_u2(pBuf, 1);
+	FrameBuf_Add_u1(pBuf, flags);
+
+	RT_TRACE_F(COMP_P2P, FrameBuf_DbgLevel(pBuf), ("[%s] flags: 0x%02X\n", MOD_TRACE_TAG, flags));
+
+	return;
+}
+
+#endif
+
+#undef MOD_TRACE_TAG
+
+#endif