Re-submit for WDI sample driver to GitHub

Submit WDI sample driver to GitHub for RS1.

13 files changed, 6036 insertions, 0 deletions

diff --git a/network/wlan/WDI/PLATFORM/NdisComm/Mp_Precomp.h b/network/wlan/WDI/PLATFORM/NdisComm/Mp_Precomp.h
new file mode 100644
index 00000000..4215bf67
--- /dev/null
+++ b/network/wlan/WDI/PLATFORM/NdisComm/Mp_Precomp.h
@@ -0,0 +1,2 @@
+#include <Precomp.h>
+
diff --git a/network/wlan/WDI/PLATFORM/NdisComm/NdisComm.c b/network/wlan/WDI/PLATFORM/NdisComm/NdisComm.c
new file mode 100644
index 00000000..8c5f90a2
--- /dev/null
+++ b/network/wlan/WDI/PLATFORM/NdisComm/NdisComm.c
@@ -0,0 +1,2519 @@
+#include "Mp_Precomp.h"
+
+#if WPP_SOFTWARE_TRACE
+#include "NdisComm.tmh"
+#endif
+
+
+//
+// Description:
+//	Translate RT_STATUS to Ndis Status.
+// Arguments:
+//	[in] rtStatus -
+//		RT defined status.
+// Return:
+//	NDIS_STATU_XXX
+// Remark:
+//	This function translates some known RT status to NDIS_STATUS_XXX.
+//	If the input RT status is unrecognized, return NDIS_STATUS_FAILURE.
+// By Bruce, 2012-03-07.
+//
+NDIS_STATUS
+NdisStatusFromRtStatus(
+	IN	u4Byte	rtStatus
+	)
+{	
+	switch(rtStatus)
+	{
+	default:
+		return NDIS_STATUS_FAILURE;
+		
+	case RT_STATUS_SUCCESS:
+		return NDIS_STATUS_SUCCESS;
+
+	case RT_STATUS_FAILURE:
+		return NDIS_STATUS_FAILURE;
+
+	case RT_STATUS_PENDING:
+		return NDIS_STATUS_PENDING;
+
+	case RT_STATUS_RESOURCE:
+		return NDIS_STATUS_RESOURCES;
+
+	case RT_STATUS_INVALID_CONTEXT:
+	case RT_STATUS_INVALID_PARAMETER:
+	case RT_STATUS_MALFORMED_PKT:
+		return NDIS_STATUS_INVALID_DATA;
+
+	case RT_STATUS_NOT_SUPPORT:
+		return NDIS_STATUS_NOT_SUPPORTED;
+
+	case RT_STATUS_BUFFER_TOO_SHORT:
+		return NDIS_STATUS_BUFFER_TOO_SHORT;
+
+	case RT_STATUS_INVALID_LENGTH:
+		return NDIS_STATUS_INVALID_LENGTH;
+
+	case RT_STATUS_NOT_RECOGNIZED:
+		return NDIS_STATUS_NOT_RECOGNIZED;
+
+	case RT_STATUS_MEDIA_BUSY:
+		return NDIS_STATUS_MEDIA_BUSY;
+
+	case RT_STATUS_INVALID_DATA:
+		return NDIS_STATUS_INVALID_DATA;
+	}
+}
+
+
+VOID
+_PlatformInitializeSpinLock(
+	PVOID				Adapter,
+	RT_SPINLOCK_TYPE	type
+	)
+{
+	PADAPTER			pDefaultAdapter = GetDefaultAdapter((PADAPTER)Adapter);
+	PNDIS_ADAPTER_TYPE	pDevice = GET_NDIS_ADAPTER(pDefaultAdapter);
+
+	switch(type)
+	{
+	case RT_RX_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->RxSpinLock) );
+		pDefaultAdapter->bRxLocked = FALSE;
+		break;
+
+	case RT_RX_CONTROL_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->RxControlSpinLock));
+		break;
+
+	case RT_RX_QUEUE_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->RxQueueSpinLock));
+		break;
+
+	case RT_TX_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->TxSpinLock) );
+		pDefaultAdapter->bTxLocked = FALSE;
+		break;
+
+	case RT_RM_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->RmSpinLock) );
+		break;
+
+	case RT_CAM_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->CamSpinLock) );
+		break;
+
+	case RT_SCAN_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->ScanSpinLock) );
+		break;
+		
+	case RT_LOG_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->LogSpinLock) );
+		break;
+		
+	case RT_BW_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->BwSpinLock) );
+		break;
+
+	case RT_CHNLOP_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->ChnlOpSpinLock) );
+		break;
+
+	case RT_RF_OPERATE_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->RFWriteSpinLock));
+		break;
+
+	case RT_INITIAL_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->InitialSpinLock));
+		break;
+		
+	case RT_RF_STATE_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->RFStateSpinLock));
+		break;	
+
+	case RT_PORT_SPINLOCK:
+		NdisAllocateSpinLock(&(pDevice->PortLock) );
+		break;
+		
+	case RT_H2C_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->H2CSpinLock));
+		break;
+		
+#if VISTA_USB_RX_REVISE
+	case RT_USBRX_CONTEXT_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->UsbRxContextLock) );
+		break;
+
+	case RT_USBRX_POSTPROC_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->UsbRxIndicateLock) );
+		break;
+#endif
+
+	case RT_WAPI_OPTION_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->WapiOptionSpinLock));
+		break;
+	case RT_WAPI_RX_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->WapiRxSpinLock));
+		break;
+
+	case RT_BUFFER_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->BufferSpinLock));
+		break;
+
+	case RT_GEN_TEMP_BUF_SPINLOCK:
+		NdisAllocateSpinLock(&(pDevice->GenBufSpinLock));
+		break;
+		
+	case RT_AWB_SPINLOCK:
+		NdisAllocateSpinLock(&(pDevice->AwbSpinLock));
+		break;
+		
+	case RT_FW_PS_SPINLOCK:
+		NdisAllocateSpinLock(&(pDevice->FwPSSpinLock));
+		break;
+
+	case RT_HW_TIMER_SPIN_LOCK:
+		NdisAllocateSpinLock(&(pDevice->HwTimerSpinLock));
+		break;
+        
+	case RT_P2P_SPIN_LOCK:
+		NdisAllocateSpinLock(&(pDevice->P2PSpinLock));
+		break;
+
+    case RT_MPT_WI_SPINLOCK:
+        NdisAllocateSpinLock(&(pDevice->MptWorkItemSpinLock));
+		break;
+
+	case RT_DBG_SPIN_LOCK:
+		NdisAllocateSpinLock(&(pDevice->ndisDbgWorkItemSpinLock));
+		break;
+
+	case RT_IQK_SPINLOCK:
+		NdisAllocateSpinLock(&(pDevice->IQKSpinLock));
+		break;
+
+	case RT_DYN_TXPWRTBL_SPINLOCK:
+		NdisAllocateSpinLock(&(pDevice->DynTxPwrTblSpinLock));
+		break;
+
+	case RT_CHNLLIST_SPINLOCK:
+		NdisAllocateSpinLock(&(pDevice->ChnlListSpinLock));
+		break;
+
+	case RT_PENDED_OID_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->PendedOidSpinLock));
+		break;
+		
+	case RT_INDIC_SPINLOCK:
+		NdisAllocateSpinLock(&(pDevice->IndicSpinLock));
+		break;
+		
+	case RT_RFD_SPINLOCK:
+		NdisAllocateSpinLock(&(pDevice->RfdSpinLock));
+		break;
+		
+#if DRV_LOG_REGISTRY
+	case RT_DRV_STATE_SPINLOCK:
+		NdisAllocateSpinLock(&(pDevice->DrvStateSpinLock));
+		break;
+#endif
+
+#if (AUTO_CHNL_SEL_NHM == 1)			
+	case RT_ACS_SPINLOCK:
+		NdisAllocateSpinLock(&(pDevice->AcsSpinLock));
+		break;	
+#endif
+
+	case RT_RX_REF_CNT_SPINLOCK:
+		NdisAllocateSpinLock(&(pDevice->RxRefCntSpinLock));
+		break;
+
+	case RT_SYNC_IO_CNT_SPINLOCK:
+		NdisAllocateSpinLock( &(pDevice->SyncIoCntSpinLock));
+		break;
+
+	default:
+		break;
+	}
+}
+
+
+VOID
+_PlatformFreeSpinLock(
+	PVOID				Adapter,
+	RT_SPINLOCK_TYPE	type
+	)
+{
+	PADAPTER			pDefaultAdapter = GetDefaultAdapter((PADAPTER)Adapter);
+
+	PNDIS_ADAPTER_TYPE	pDevice = GET_NDIS_ADAPTER(pDefaultAdapter);
+
+	switch(type)
+	{
+	case RT_RX_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->RxSpinLock) );
+		break;
+
+	case RT_RX_CONTROL_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->RxControlSpinLock));
+		break;
+
+	case RT_RX_QUEUE_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->RxQueueSpinLock));
+		break;
+
+	case RT_TX_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->TxSpinLock) );
+		break;
+
+	case RT_RM_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->RmSpinLock) );
+		break;
+
+	case RT_CAM_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->CamSpinLock) );
+		break;
+
+	case RT_SCAN_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->ScanSpinLock) );
+		break;
+
+	case RT_LOG_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->LogSpinLock) );
+		break;
+
+	case RT_BW_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->BwSpinLock) );
+		break;
+
+	case RT_CHNLOP_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->ChnlOpSpinLock) );
+		break;
+
+	case RT_RF_OPERATE_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->RFWriteSpinLock));
+		break;
+
+	case RT_INITIAL_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->InitialSpinLock));
+		break;
+		
+	case RT_RF_STATE_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->RFStateSpinLock));
+		break;	
+
+
+	case RT_PORT_SPINLOCK:
+		NdisFreeSpinLock(&(pDevice->PortLock) );
+		break;
+
+	case RT_H2C_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->H2CSpinLock));
+		break;
+
+#if VISTA_USB_RX_REVISE
+	case RT_USBRX_CONTEXT_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->UsbRxContextLock) );
+		break;
+
+	case RT_USBRX_POSTPROC_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->UsbRxIndicateLock) );
+		break;
+#endif
+
+	case RT_WAPI_OPTION_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->WapiOptionSpinLock));
+		break;
+	case RT_WAPI_RX_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->WapiRxSpinLock));
+		break;
+
+	case RT_BUFFER_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->BufferSpinLock) );
+		break;
+		
+	case RT_AWB_SPINLOCK:
+		NdisFreeSpinLock(&(pDevice->AwbSpinLock));
+		break;
+
+	case RT_FW_PS_SPINLOCK:
+		NdisFreeSpinLock(&(pDevice->FwPSSpinLock));
+		break;
+
+	case RT_HW_TIMER_SPIN_LOCK:
+		NdisFreeSpinLock(&(pDevice->HwTimerSpinLock));
+		break;
+
+	case RT_P2P_SPIN_LOCK:
+		NdisFreeSpinLock(&(pDevice->P2PSpinLock));
+		break;
+
+	case RT_MPT_WI_SPINLOCK:
+		NdisFreeSpinLock(&(pDevice->MptWorkItemSpinLock));
+		break;
+
+	case RT_DBG_SPIN_LOCK:
+		NdisFreeSpinLock(&(pDevice->ndisDbgWorkItemSpinLock));
+		break;
+
+	case RT_IQK_SPINLOCK:
+		NdisFreeSpinLock(&(pDevice->IQKSpinLock));
+		break;
+
+	case RT_DYN_TXPWRTBL_SPINLOCK:
+		NdisFreeSpinLock(&(pDevice->DynTxPwrTblSpinLock));
+		break;
+
+	case RT_CHNLLIST_SPINLOCK:
+		NdisFreeSpinLock(&(pDevice->ChnlListSpinLock));
+		break;		
+		
+	case RT_PENDED_OID_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->PendedOidSpinLock));
+		break;
+	case RT_RFD_SPINLOCK:
+		NdisFreeSpinLock(&(pDevice->RfdSpinLock));
+		break;
+				
+	case RT_INDIC_SPINLOCK:
+		NdisFreeSpinLock(&(pDevice->IndicSpinLock));
+		break;		
+
+#if DRV_LOG_REGISTRY
+	case RT_DRV_STATE_SPINLOCK:
+		NdisFreeSpinLock(&(pDevice->DrvStateSpinLock));
+		break;
+#endif	
+				
+#if (AUTO_CHNL_SEL_NHM == 1)	
+	case RT_ACS_SPINLOCK:
+		NdisFreeSpinLock(&(pDevice->AcsSpinLock));
+		break;
+#endif
+				
+case RT_RX_REF_CNT_SPINLOCK:
+		NdisFreeSpinLock(&(pDevice->RxRefCntSpinLock));
+		break;
+
+	case RT_SYNC_IO_CNT_SPINLOCK:
+		NdisFreeSpinLock( &(pDevice->SyncIoCntSpinLock));
+		break;
+		
+	default:
+		break;
+	}
+}
+
+#pragma warning( disable: 28167 ) // Prefast says we don't annotated the change.
+_IRQL_raises_(DISPATCH_LEVEL)
+VOID
+_PlatformAcquireSpinLock(
+	PVOID				Adapter,
+	RT_SPINLOCK_TYPE	type
+	)
+{
+	PADAPTER			pDefaultAdapter = GetDefaultAdapter((PADAPTER)Adapter);
+	PNDIS_ADAPTER_TYPE	pDevice = GET_NDIS_ADAPTER(pDefaultAdapter);
+
+	switch(type)
+	{
+	case RT_RX_SPINLOCK:
+		NdisAcquireSpinLock( &(pDevice->RxSpinLock) );
+		pDefaultAdapter->bRxLocked = TRUE;
+		break;
+
+	case RT_RX_CONTROL_SPINLOCK:
+		NdisAcquireSpinLock( &(pDevice->RxControlSpinLock));
+		break;
+
+	case RT_RX_QUEUE_SPINLOCK:
+		NdisAcquireSpinLock( &(pDevice->RxQueueSpinLock));
+		break;
+
+	case RT_TX_SPINLOCK:
+		NdisAcquireSpinLock( &(pDevice->TxSpinLock) );
+		pDefaultAdapter->bTxLocked = TRUE;
+		break;
+
+	case RT_RM_SPINLOCK:
+		NdisAcquireSpinLock( &(pDevice->RmSpinLock) );
+		break;
+
+	case RT_CAM_SPINLOCK:
+		NdisAcquireSpinLock( &(pDevice->CamSpinLock) );
+		break;
+
+	case RT_SCAN_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->ScanSpinLock) );
+		break;
+
+	case RT_LOG_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->LogSpinLock) );
+		break;
+
+	case RT_BW_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->BwSpinLock) );
+		break;
+
+	case RT_CHNLOP_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->ChnlOpSpinLock) );
+		break;
+
+	case RT_RF_OPERATE_SPINLOCK:
+		NdisAcquireSpinLock( &(pDevice->RFWriteSpinLock));
+		break;
+
+	case RT_INITIAL_SPINLOCK:
+		NdisAcquireSpinLock( &(pDevice->InitialSpinLock));
+		break;
+		
+	case RT_RF_STATE_SPINLOCK:
+		NdisAcquireSpinLock( &(pDevice->RFStateSpinLock));
+		break;	
+
+	
+	case RT_PORT_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->PortLock) );
+		break;
+
+	case RT_H2C_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->H2CSpinLock) );
+		break;	
+		
+#if VISTA_USB_RX_REVISE
+	case RT_USBRX_CONTEXT_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->UsbRxContextLock) );
+		break;
+
+	case RT_USBRX_POSTPROC_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->UsbRxIndicateLock) );
+		break;
+#endif
+
+	case RT_WAPI_OPTION_SPINLOCK:
+		NdisAcquireSpinLock( &(pDevice->WapiOptionSpinLock));
+		break;
+	case RT_WAPI_RX_SPINLOCK:
+		NdisAcquireSpinLock( &(pDevice->WapiRxSpinLock));
+		break;
+
+	case RT_BUFFER_SPINLOCK:
+		NdisAcquireSpinLock( &(pDevice->BufferSpinLock) );
+		break;
+
+	case RT_GEN_TEMP_BUF_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->GenBufSpinLock));
+		break;
+
+	case RT_AWB_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->AwbSpinLock));
+		break;	
+		
+	case RT_FW_PS_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->FwPSSpinLock));
+		break;
+
+	case RT_HW_TIMER_SPIN_LOCK:
+		NdisAcquireSpinLock(&(pDevice->HwTimerSpinLock));
+		break;
+
+	case RT_P2P_SPIN_LOCK:
+		NdisAcquireSpinLock(&(pDevice->P2PSpinLock));
+        break;
+
+    case RT_MPT_WI_SPINLOCK:
+        NdisAcquireSpinLock(&(pDevice->MptWorkItemSpinLock));
+		break;
+		
+	case RT_DBG_SPIN_LOCK:
+		NdisAcquireSpinLock(&(pDevice->ndisDbgWorkItemSpinLock));
+		break;
+		
+	case RT_IQK_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->IQKSpinLock));
+		break;
+
+	case RT_DYN_TXPWRTBL_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->DynTxPwrTblSpinLock));
+		break;
+
+	case RT_CHNLLIST_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->ChnlListSpinLock));
+		break;
+
+	case RT_PENDED_OID_SPINLOCK:
+		NdisAcquireSpinLock( &(pDevice->PendedOidSpinLock));
+		break;
+		
+	case RT_INDIC_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->IndicSpinLock));
+		break;
+
+	case RT_RFD_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->RfdSpinLock));
+		break;
+
+#if DRV_LOG_REGISTRY
+	case RT_DRV_STATE_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->DrvStateSpinLock));
+		break;	
+#endif
+			
+#if (AUTO_CHNL_SEL_NHM == 1)				
+	case RT_ACS_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->AcsSpinLock));
+		break;
+#endif
+			
+	case RT_RX_REF_CNT_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->RxRefCntSpinLock));
+		break;
+
+	case RT_SYNC_IO_CNT_SPINLOCK:
+		NdisAcquireSpinLock( &(pDevice->SyncIoCntSpinLock));
+		break;
+
+
+	case RT_CUSTOM_SCAN_SPINLOCK:
+		NdisAcquireSpinLock(&(pDevice->CustomScanSpinLock));
+		break;
+			
+	default:
+		break;
+	}
+}
+
+#pragma warning( disable: 28167 ) // Prefast says we don't annotated the change.
+_IRQL_requires_(DISPATCH_LEVEL)
+VOID
+_PlatformReleaseSpinLock(
+	PVOID				Adapter,
+	RT_SPINLOCK_TYPE	type
+	)
+{
+	PADAPTER			pDefaultAdapter = GetDefaultAdapter((PADAPTER)Adapter);
+	PNDIS_ADAPTER_TYPE	pDevice = GET_NDIS_ADAPTER(pDefaultAdapter);
+
+	switch(type)
+	{
+	case RT_RX_SPINLOCK:
+		pDefaultAdapter->bRxLocked = FALSE;	
+		NdisReleaseSpinLock( &(pDevice->RxSpinLock) );
+		break;
+
+	case RT_RX_CONTROL_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->RxControlSpinLock));
+		break;
+
+	case RT_RX_QUEUE_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->RxQueueSpinLock));
+		break;
+
+	case RT_TX_SPINLOCK:
+		pDefaultAdapter->bTxLocked = FALSE;	
+		NdisReleaseSpinLock( &(pDevice->TxSpinLock) );
+		break;
+
+	case RT_RM_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->RmSpinLock) );
+		break;
+
+	case RT_CAM_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->CamSpinLock) );
+		break;
+
+	case RT_SCAN_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->ScanSpinLock) );
+		break;
+
+	case RT_LOG_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->LogSpinLock) );
+		break;
+
+	case RT_BW_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->BwSpinLock) );
+		break;
+
+	case RT_CHNLOP_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->ChnlOpSpinLock) );
+		break;
+
+	case RT_RF_OPERATE_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->RFWriteSpinLock));
+		break;
+
+	case RT_INITIAL_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->InitialSpinLock));
+		break;
+		
+	case RT_RF_STATE_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->RFStateSpinLock));
+		break;
+
+
+	case RT_PORT_SPINLOCK:
+		NdisReleaseSpinLock(&(pDevice->PortLock) );
+		break;
+
+	case RT_H2C_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->H2CSpinLock));
+		break;
+		
+#if VISTA_USB_RX_REVISE
+	case RT_USBRX_CONTEXT_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->UsbRxContextLock) );
+		break;
+
+	case RT_USBRX_POSTPROC_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->UsbRxIndicateLock) );
+		break;
+#endif
+
+	case RT_WAPI_OPTION_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->WapiOptionSpinLock));
+		break;
+	case RT_WAPI_RX_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->WapiRxSpinLock));
+		break;
+
+	case RT_BUFFER_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->BufferSpinLock) );
+		break;
+
+	case RT_GEN_TEMP_BUF_SPINLOCK:
+		NdisReleaseSpinLock(&(pDevice->GenBufSpinLock));
+		break;
+
+	case RT_AWB_SPINLOCK:
+		NdisReleaseSpinLock(&(pDevice->AwbSpinLock));
+		break;	
+
+	case RT_FW_PS_SPINLOCK:
+		NdisReleaseSpinLock(&(pDevice->FwPSSpinLock));
+		break;
+
+	case RT_HW_TIMER_SPIN_LOCK:
+		NdisReleaseSpinLock(&(pDevice->HwTimerSpinLock));
+		break;
+
+	case RT_P2P_SPIN_LOCK:
+		NdisReleaseSpinLock(&(pDevice->P2PSpinLock));
+		break;
+
+	case RT_MPT_WI_SPINLOCK:
+		NdisReleaseSpinLock(&(pDevice->MptWorkItemSpinLock));
+		break;
+		
+	case RT_DBG_SPIN_LOCK:
+		NdisReleaseSpinLock(&(pDevice->ndisDbgWorkItemSpinLock));
+		break;
+		
+	case RT_IQK_SPINLOCK:
+		NdisReleaseSpinLock(&(pDevice->IQKSpinLock));
+		break;
+
+	case RT_DYN_TXPWRTBL_SPINLOCK:
+		NdisReleaseSpinLock(&(pDevice->DynTxPwrTblSpinLock));
+		break;
+
+	case RT_CHNLLIST_SPINLOCK:
+		NdisReleaseSpinLock(&(pDevice->ChnlListSpinLock));
+		break;
+
+	case RT_PENDED_OID_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->PendedOidSpinLock));
+		break;
+
+	case RT_RFD_SPINLOCK:
+		NdisReleaseSpinLock(&(pDevice->RfdSpinLock));
+		break;
+		
+	case RT_INDIC_SPINLOCK:
+		NdisReleaseSpinLock(&(pDevice->IndicSpinLock));
+		break;
+
+#if DRV_LOG_REGISTRY
+	case RT_DRV_STATE_SPINLOCK:
+		NdisReleaseSpinLock(&(pDevice->DrvStateSpinLock));
+		break;
+#endif
+		
+#if (AUTO_CHNL_SEL_NHM == 1)		
+	case RT_ACS_SPINLOCK:
+		NdisReleaseSpinLock(&(pDevice->AcsSpinLock));
+		break;
+#endif
+		
+	case RT_RX_REF_CNT_SPINLOCK:
+		NdisReleaseSpinLock(&(pDevice->RxRefCntSpinLock));
+		break;
+
+	case RT_SYNC_IO_CNT_SPINLOCK:
+		NdisReleaseSpinLock( &(pDevice->SyncIoCntSpinLock));
+		break;
+
+
+	case RT_CUSTOM_SCAN_SPINLOCK:
+		NdisReleaseSpinLock(&(pDevice->CustomScanSpinLock));
+		break;
+		
+	default:
+		break;
+	}
+}
+
+u4Byte
+PlatformAtomicExchange(
+	pu4Byte				target,
+	u4Byte				value
+	)
+{
+	return InterlockedExchange(target, value);
+}
+
+// 20100211 Joseph: Since there is no support to InterlockedAnd() and InterlockedOr() function for XP platform,
+// we just implement the same function as DDK does.
+u4Byte
+PlatformAtomicAnd(
+	pu1Byte				target,
+	u1Byte				value
+	)
+{
+    u4Byte i, j;
+    u4Byte tmp = (0xffffff00|value);
+
+    j = *target;
+    do {
+	i = j;
+	j = InterlockedCompareExchange((pu4Byte)target, (i&tmp), i);
+    } while (i != j);
+
+    return j;
+}
+
+// 20100211 Joseph: Since there is no support to InterlockedAnd() and InterlockedOr() function for XP platform,
+// we just implement the same function as DDK does.
+u4Byte
+PlatformAtomicOr(
+	pu1Byte				target,
+	u1Byte				value
+	)
+{
+    u4Byte i, j;
+    u4Byte tmp = (0x00000000|value);
+
+    j = *target;
+    do {
+	i = j;
+	j = InterlockedCompareExchange((pu4Byte)target, (i|tmp), i);
+    } while (i != j);
+
+    return j;
+}
+
+
+VOID
+PlatformInitializeMutex(
+	IN PPlatformMutex	Mutex
+	)
+{
+	KeInitializeMutex(Mutex, 0);
+}
+
+VOID
+PlatformAcquireMutex(
+	IN PPlatformMutex	Mutex
+	)
+{
+	LARGE_INTEGER lTimeout;
+
+	if (KeGetCurrentIrql() == DISPATCH_LEVEL) 
+	{
+		lTimeout.QuadPart = 0;
+		KeWaitForMutexObject(Mutex, Executive, KernelMode, FALSE, &lTimeout);
+	}
+	else 
+		KeWaitForMutexObject(Mutex, Executive, KernelMode, FALSE, NULL);
+}
+
+
+VOID
+PlatformReleaseMutex(
+	IN PPlatformMutex	Mutex
+	)
+{
+	KeReleaseMutex(Mutex, FALSE);
+}
+
+VOID
+PlatformCriticalSectionEnter(
+	IN PADAPTER			pAdapter,
+	IN PPlatformMutex	Mutex,
+	IN RT_SPINLOCK_TYPE	Spinlock
+	)
+{
+	PlatformAcquireMutex(Mutex);
+}
+
+VOID
+PlatformCriticalSectionLeave(
+	IN PADAPTER			pAdapter,
+	IN PPlatformMutex	Mutex,
+	IN RT_SPINLOCK_TYPE	Spinlock
+	)
+{
+	PlatformReleaseMutex(Mutex);
+}
+
+
+
+//=========================================================================
+//
+// Get the unused instance index, if there is no index found, return 0xff
+//
+//=========================================================================
+
+
+u8Byte
+PlatformDivision64(
+	IN u8Byte	x,
+	IN u8Byte	y
+)
+{
+	return ((x) / (y));
+}
+
+u8Byte
+PlatformModular64(
+	IN u8Byte	x,
+	IN u8Byte	y
+)
+{
+	return ((x) % (y));
+}
+
+//==========================================================================
+//Platform function about Thread Create and Free
+//==========================================================================
+
+VOID
+Ndis6EventTrigerThreadCallback(
+	IN	PVOID	pContext
+	)
+{
+	PRT_THREAD	pRtThread = (PRT_THREAD)pContext;
+	PADAPTER	Adapter =  ((PRT_THREAD)pContext)->Adapter;
+	PRT_NDIS_COMMON	pNdisCommon = Adapter->pNdisCommon;
+	PRT_THREAD_PLATFORM_EXT	pPlatformExt = (PRT_THREAD_PLATFORM_EXT)pRtThread->pPlatformExt;
+
+	if( pPlatformExt == NULL )
+		return;
+
+	NdisAcquireSpinLock(&(pPlatformExt->Lock));
+	
+	if(pRtThread->Status & RT_THREAD_STATUS_CANCEL)
+	{
+		RT_TRACE(COMP_INIT, DBG_LOUD, ("Ndis6EventTrigerThreadCallback CANCEL! \n"));
+		NdisReleaseSpinLock(&(pPlatformExt->Lock)); 
+		goto Exit;
+	}
+	pRtThread->Status |=RT_THREAD_STATUS_FIRED;
+
+	NdisReleaseSpinLock(&(pPlatformExt->Lock)); 
+
+	while(!RT_DRIVER_STOP(Adapter))
+	{
+		NdisAcquireSpinLock(&(pPlatformExt->Lock));
+		if(pRtThread->Status & RT_THREAD_STATUS_CANCEL)
+		{
+			NdisReleaseSpinLock(&(pPlatformExt->Lock));
+			break;
+		}
+		else
+			NdisReleaseSpinLock(&(pPlatformExt->Lock));
+		
+		if(NdisWaitEvent(&pPlatformExt->TrigerEvent, pPlatformExt->Period))
+		{
+			NdisAcquireSpinLock(&(pPlatformExt->Lock));
+			
+			NdisResetEvent(&(pPlatformExt->TrigerEvent));
+
+			if(pRtThread->Status & RT_THREAD_STATUS_CANCEL)
+			{
+				NdisReleaseSpinLock(&(pPlatformExt->Lock));
+				break;
+			}
+			else
+				NdisReleaseSpinLock(&(pPlatformExt->Lock));
+
+			pRtThread->CallbackFunc(pRtThread);
+			
+			NdisAcquireSpinLock(&(pPlatformExt->Lock));
+			pRtThread->ScheduleCnt++;
+			NdisReleaseSpinLock(&(pPlatformExt->Lock));
+		}
+	}
+	
+Exit:
+
+	if(pRtThread->PreTheradExitCb != NULL)
+	{			 
+		pRtThread->PreTheradExitCb(pRtThread);	
+	}
+	
+	NdisAcquireSpinLock(&(pPlatformExt->Lock));
+	pRtThread->RefCnt--;
+	pRtThread->Status &= ~RT_THREAD_STATUS_FIRED;
+	pRtThread->Status &= ~RT_THREAD_STATUS_SET;
+	NdisSetEvent(&(pPlatformExt->CompleteEvent));
+	NdisReleaseSpinLock(&(pPlatformExt->Lock));
+
+     if(Adapter->bSWInitReady)
+      {
+        	NdisAcquireSpinLock(&(pNdisCommon->ThreadLock));
+        	
+        	pNdisCommon->OutStandingThreadCnt--;
+
+        	//
+        	// Check if driver is waiting us to unload.
+        	//	
+        	if(pNdisCommon->OutStandingThreadCnt == 0)
+        	{
+        		NdisReleaseSpinLock(&(pNdisCommon->ThreadLock));
+        		NdisSetEvent(&(pNdisCommon->AllThreadCompletedEvent));
+        	}
+        	else
+        	{
+        		NdisReleaseSpinLock(&(pNdisCommon->ThreadLock));
+        	}	
+     }
+
+	PsTerminateSystemThread(STATUS_SUCCESS);// terminate the thread.
+
+}
+
+VOID
+Ndis6ThreadCallback(
+	IN	PVOID	pContext
+	)
+{
+	PRT_THREAD	pRtThread = (PRT_THREAD)pContext;
+	PADAPTER	Adapter =  ((PRT_THREAD)pContext)->Adapter;
+	PRT_NDIS_COMMON	pNdisCommon = Adapter->pNdisCommon;
+	PRT_THREAD_PLATFORM_EXT	pPlatformExt = (PRT_THREAD_PLATFORM_EXT)pRtThread->pPlatformExt;
+
+	if( pPlatformExt == NULL )
+		return;
+
+	NdisAcquireSpinLock(&(pPlatformExt->Lock));
+	
+	if(pRtThread->Status & RT_THREAD_STATUS_CANCEL)
+	{
+		NdisReleaseSpinLock(&(pPlatformExt->Lock)); 
+		goto Exit;
+	}
+	pRtThread->Status |=RT_THREAD_STATUS_FIRED;
+	NdisReleaseSpinLock(&(pPlatformExt->Lock)); 
+
+
+	if(!RT_DRIVER_STOP(Adapter))
+	{
+	
+		pRtThread->CallbackFunc(pRtThread);
+		
+		NdisAcquireSpinLock(&(pPlatformExt->Lock));
+		pRtThread->ScheduleCnt++;
+		NdisReleaseSpinLock(&(pPlatformExt->Lock));
+	}
+	
+Exit:	
+	NdisAcquireSpinLock(&(pPlatformExt->Lock));
+	pRtThread->RefCnt--;
+	pRtThread->Status &= ~RT_THREAD_STATUS_FIRED;
+	pRtThread->Status &= ~RT_THREAD_STATUS_SET;
+	NdisSetEvent(&(pPlatformExt->CompleteEvent));
+	NdisReleaseSpinLock(&(pPlatformExt->Lock)); 
+
+	NdisAcquireSpinLock(&(pNdisCommon->ThreadLock));
+	pNdisCommon->OutStandingThreadCnt--;
+
+	//
+	// Check if driver is waiting us to unload.
+	//	
+	if(pNdisCommon->OutStandingThreadCnt == 0)
+	{
+		NdisReleaseSpinLock(&(pNdisCommon->ThreadLock));
+		NdisSetEvent(&(pNdisCommon->AllThreadCompletedEvent));
+	}
+	else
+	{
+		NdisReleaseSpinLock(&(pNdisCommon->ThreadLock));
+	}	
+
+	PsTerminateSystemThread(STATUS_SUCCESS);// terminate the thread.
+}
+
+RT_STATUS
+PlatformInitializeThread(
+	IN	PADAPTER			Adapter,
+	IN	PRT_THREAD			pRtThread,
+	IN	RT_THREAD_CALL_BACK	CallBackFunc, 
+	IN	const char*			szID,
+	IN	BOOLEAN				EventTriger,
+	IN	u4Byte				Period,
+	IN	PVOID				pContext
+	)
+{
+	PRT_NDIS_COMMON	pNdisCommon  = Adapter->pNdisCommon;
+	PRT_THREAD_PLATFORM_EXT	pPlatformExt =NULL;
+	RT_STATUS			status = RT_STATUS_SUCCESS;
+
+
+	pRtThread->pPlatformExt = NULL;
+	status = PlatformAllocateMemory(Adapter, (PVOID*)(&pPlatformExt), sizeof(RT_THREAD_PLATFORM_EXT) );
+	if (status != RT_STATUS_SUCCESS)
+	{
+		RT_TRACE(COMP_DBG, DBG_SERIOUS, ("PlatformInitializeThread(): failed to allocate memory: %s\n", szID));
+		return RT_STATUS_RESOURCE;
+	}
+	PlatformZeroMemory( pPlatformExt, sizeof(RT_THREAD_PLATFORM_EXT) );
+	pRtThread->pPlatformExt = pPlatformExt;
+
+
+	NdisAllocateSpinLock(&(pPlatformExt->Lock));
+	NdisInitializeEvent(&(pPlatformExt->CompleteEvent));
+	NdisSetEvent(&(pPlatformExt->CompleteEvent));
+	NdisInitializeEvent(&(pPlatformExt->TrigerEvent));
+	
+	NdisSetEvent(&(pPlatformExt->TrigerEvent));
+
+	pPlatformExt->Period = Period;
+	
+	pRtThread->bEventTriger  = EventTriger;
+	pRtThread->Adapter= Adapter;
+	pRtThread->Status = RT_THREAD_STATUS_INITIALIZED;
+	pRtThread->RefCnt = 1;
+	pRtThread->ScheduleCnt = 0;
+	pRtThread->CallbackFunc = CallBackFunc;
+	pRtThread->PreTheradExitCb = NULL;
+	
+	if(szID != NULL)
+	{
+		ASCII_STR_COPY(pRtThread->szID, szID, 36);
+	}
+
+	pRtThread->Argc = 0;
+	pRtThread->pContext = pContext;
+	
+	return RT_STATUS_SUCCESS;
+}
+
+RT_STATUS
+PlatformInitializeThreadEx(
+	IN	PADAPTER			Adapter,
+	IN	PRT_THREAD			pRtThread,
+	IN	RT_THREAD_CALL_BACK	CallBackFunc, 
+	IN  RT_THREAD_CALL_BACK PreThreadExitCb,
+	IN	const char*			szID,
+	IN	BOOLEAN				EventTriger,
+	IN	u4Byte				Period,
+	IN	PVOID				pContext
+	)
+{
+	RT_STATUS				status = RT_STATUS_SUCCESS;
+	
+	status = PlatformInitializeThread(Adapter, pRtThread, CallBackFunc, szID, EventTriger, Period, pContext);
+
+	if(RT_STATUS_SUCCESS == status)
+	{
+		pRtThread->PreTheradExitCb = PreThreadExitCb;
+	}
+	
+	return status;
+}
+
+VOID
+PlatformSetEventToTrigerThread(
+	IN	PADAPTER		Adapter,
+	IN	PRT_THREAD	pRtThread
+)
+{
+	PRT_NDIS_COMMON	pNdisCommon = Adapter->pNdisCommon;
+        PRT_THREAD_PLATFORM_EXT	pPlatformExt = (PRT_THREAD_PLATFORM_EXT)pRtThread->pPlatformExt;
+
+	if( pPlatformExt == NULL )
+		return;
+
+	NdisAcquireSpinLock(&(pPlatformExt->Lock));
+	
+	if(pRtThread->Status & RT_THREAD_STATUS_CANCEL)
+	{
+		NdisReleaseSpinLock(&(pPlatformExt->Lock));
+		return;
+	}
+	NdisSetEvent(&(pPlatformExt->TrigerEvent));
+
+	NdisReleaseSpinLock(&(pPlatformExt->Lock));
+	return;
+	
+}
+
+RT_STATUS
+PlatformSetEventTrigerThread(
+	IN	PADAPTER		Adapter,
+	IN	PRT_THREAD	pRtThread,
+	IN 	RT_THREAD_LEVEL 	Priority,
+	IN	PVOID		pContext
+    )
+{
+	HANDLE              ThreadHandle;
+	NDIS_STATUS         Status;
+	OBJECT_ATTRIBUTES   ObjectAttribs;
+
+	PRT_NDIS_COMMON	pNdisCommon = Adapter->pNdisCommon;
+        PRT_THREAD_PLATFORM_EXT	pPlatformExt = (PRT_THREAD_PLATFORM_EXT)pRtThread->pPlatformExt;
+
+	if( pPlatformExt == NULL )
+		return RT_STATUS_FAILURE;
+
+	if(RT_DRIVER_HALT(Adapter))
+	{
+		RT_TRACE(COMP_SYSTEM, DBG_LOUD, 
+			("driver is halted pRtThread(%s) cannot schedule !!!\n", pRtThread->szID));
+		return RT_STATUS_FAILURE;
+	}
+	
+	NdisAcquireSpinLock(&(pPlatformExt->Lock));
+	if(pRtThread->Status & RT_THREAD_STATUS_RELEASED)
+	{
+		RT_TRACE(COMP_SYSTEM, DBG_WARNING, 
+			("pRtThread(%s) is alreadyreleased!!!\n", pRtThread->szID));
+		NdisReleaseSpinLock(&(pPlatformExt->Lock));
+		return RT_STATUS_FAILURE;
+	}
+
+	if(!(pRtThread->Status & RT_THREAD_STATUS_INITIALIZED))
+	{
+		RT_TRACE(COMP_SYSTEM, DBG_WARNING,
+			("pRtThread(%s) is not yet initialized!!! Status 0x%x\n", pRtThread->szID, pRtThread->Status));
+		NdisReleaseSpinLock(&(pPlatformExt->Lock));
+		return RT_STATUS_FAILURE;
+	}
+
+	NdisReleaseSpinLock(&(pPlatformExt->Lock));
+
+	if(!NdisWaitEvent(&(pPlatformExt->CompleteEvent),2000))
+	{
+		RT_TRACE(COMP_SYSTEM, DBG_LOUD, 
+			("pRtThread(%s) is not Complete, cannot set again!!!\n", pRtThread->szID));
+		return RT_STATUS_FAILURE;
+	}
+
+	NdisAcquireSpinLock(&(pPlatformExt->Lock));			
+
+	NdisResetEvent(&(pPlatformExt->CompleteEvent));
+
+	NdisReleaseSpinLock(&(pPlatformExt->Lock));
+	
+  	do
+	{
+
+		InitializeObjectAttributes(&ObjectAttribs, 
+		                           NULL,              // ObjectName
+		                           OBJ_KERNEL_HANDLE, 
+		                           NULL,              // RootDir 
+		                           NULL);             // Security Desc
+
+		NdisAcquireSpinLock(&(pPlatformExt->Lock));
+		pRtThread->RefCnt++;
+		pRtThread->Status |= RT_THREAD_STATUS_SET;
+		pRtThread->pContext = pContext;
+		NdisReleaseSpinLock(&(pPlatformExt->Lock));
+
+		NdisAcquireSpinLock(&(pNdisCommon->ThreadLock));
+		pNdisCommon->OutStandingThreadCnt++;
+		NdisReleaseSpinLock(&(pNdisCommon->ThreadLock));
+
+		Status = PsCreateSystemThread(&ThreadHandle,
+		                              THREAD_ALL_ACCESS,
+		                              &ObjectAttribs,
+		                              NULL,           // ProcessHandle
+		                              NULL,           // ClientId
+		                              Ndis6EventTrigerThreadCallback,
+		                              pRtThread);
+		
+		if (!NT_SUCCESS(Status))
+		{
+			RT_TRACE(COMP_INIT, DBG_SERIOUS, ("Worker Thread creation failed with 0x%lx\n", Status));
+			NdisAcquireSpinLock(&(pPlatformExt->Lock));
+			pRtThread->RefCnt--;
+			pRtThread->Status &= ~RT_THREAD_STATUS_SET;
+			NdisReleaseSpinLock(&(pPlatformExt->Lock));
+
+                   if(Adapter->bSWInitReady)
+                   {
+        			NdisAcquireSpinLock(&(pNdisCommon->ThreadLock));
+        			pNdisCommon->OutStandingThreadCnt--;
+
+        			if(pNdisCommon->OutStandingThreadCnt == 0)
+        				NdisSetEvent(&(pNdisCommon->AllThreadCompletedEvent));
+        			
+        			NdisReleaseSpinLock(&(pNdisCommon->ThreadLock));
+                   }
+
+			NdisAcquireSpinLock(&(pPlatformExt->Lock));
+			NdisSetEvent(&(pPlatformExt->CompleteEvent));
+			NdisReleaseSpinLock(&(pPlatformExt->Lock));
+
+	
+			break;
+		}
+
+		Status = ObReferenceObjectByHandle(ThreadHandle,
+		                                   THREAD_ALL_ACCESS,
+						   NULL,
+		                                   KernelMode,
+		                                   &pPlatformExt->Thread,
+		                                   NULL);
+		//Need to check status return;	                                
+
+		if (Priority != 0)
+		{
+			KeSetPriorityThread(pPlatformExt->Thread, (KPRIORITY)Priority);
+		}
+
+		ZwClose(ThreadHandle);
+
+	}while(FALSE);
+
+
+	return RT_STATUS_SUCCESS;
+}
+
+RT_STATUS
+PlatformRunThread(
+	IN	PADAPTER		Adapter,
+	IN	PRT_THREAD	pRtThread,
+	IN 	RT_THREAD_LEVEL 	Priority,
+	IN	PVOID		pContext
+    )
+{
+	HANDLE              ThreadHandle;
+	NDIS_STATUS         Status;
+	OBJECT_ATTRIBUTES   ObjectAttribs;
+
+	PRT_NDIS_COMMON	pNdisCommon = Adapter->pNdisCommon;
+        PRT_THREAD_PLATFORM_EXT	pPlatformExt = (PRT_THREAD_PLATFORM_EXT)pRtThread->pPlatformExt;
+
+	if( pPlatformExt == NULL )
+		return RT_STATUS_FAILURE;
+
+	if(RT_DRIVER_HALT(Adapter))
+	{
+		RT_TRACE(COMP_SYSTEM, DBG_LOUD, 
+			("driver is halted pRtThread(%s) cannot schedule !!!\n", pRtThread->szID));
+		return RT_STATUS_FAILURE;
+	}
+	
+	NdisAcquireSpinLock(&(pPlatformExt->Lock));
+
+	if(pRtThread->Status & RT_THREAD_STATUS_RELEASED)
+	{
+		RT_TRACE(COMP_SYSTEM, DBG_WARNING, ("pRtThread(%s) is alreadyreleased!!!\n", pRtThread->szID));
+		NdisReleaseSpinLock(&(pPlatformExt->Lock));
+		return RT_STATUS_FAILURE;
+	}
+
+	if(!(pRtThread->Status & RT_THREAD_STATUS_INITIALIZED))
+	{
+		RT_ASSERT(FALSE, ("pRtThread(%s) is not yet initialized!!! Status 0x%x\n", pRtThread->szID, pRtThread->Status));
+		NdisReleaseSpinLock(&(pPlatformExt->Lock));
+		return RT_STATUS_FAILURE;
+	}
+
+	NdisReleaseSpinLock(&(pPlatformExt->Lock));
+
+	if(!NdisWaitEvent(&(pPlatformExt->CompleteEvent),2000))
+	{
+		RT_TRACE(COMP_SYSTEM, DBG_WARNING, 
+			("pRtThread(%s) is not Complete, cannot set again!!!\n", pRtThread->szID));
+		return RT_STATUS_FAILURE;
+	}
+
+	NdisAcquireSpinLock(&(pPlatformExt->Lock));
+
+	NdisResetEvent(&(pPlatformExt->CompleteEvent));
+
+	NdisReleaseSpinLock(&(pPlatformExt->Lock));
+	
+  	do
+	{
+		InitializeObjectAttributes(&ObjectAttribs, 
+		                           NULL,              // ObjectName
+		                           OBJ_KERNEL_HANDLE, 
+		                           NULL,              // RootDir 
+		                           NULL);             // Security Desc
+	
+		NdisAcquireSpinLock(&(pPlatformExt->Lock));
+		pRtThread->RefCnt++;
+		pRtThread->Status |= RT_THREAD_STATUS_SET;
+		pRtThread->pContext = pContext;
+		NdisReleaseSpinLock(&(pPlatformExt->Lock));
+		NdisAcquireSpinLock(&(pNdisCommon->ThreadLock));
+		pNdisCommon->OutStandingThreadCnt++;
+		NdisReleaseSpinLock(&(pNdisCommon->ThreadLock));
+
+		Status = PsCreateSystemThread(&ThreadHandle,
+		                              THREAD_ALL_ACCESS,
+		                              &ObjectAttribs,
+		                              NULL,           // ProcessHandle
+		                              NULL,           // ClientId
+		                              Ndis6ThreadCallback,
+		                              pRtThread);
+
+		if (!NT_SUCCESS(Status))
+		{
+			RT_TRACE(COMP_SYSTEM, DBG_SERIOUS, ("Worker Thread creation failed with 0x%lx\n", Status));
+			NdisAcquireSpinLock(&(pPlatformExt->Lock));
+			pRtThread->RefCnt--;
+			pRtThread->Status &= ~RT_THREAD_STATUS_SET;
+			NdisReleaseSpinLock(&(pPlatformExt->Lock));
+
+			NdisAcquireSpinLock(&(pNdisCommon->ThreadLock));
+			pNdisCommon->OutStandingThreadCnt--;
+
+			if(pNdisCommon->OutStandingThreadCnt == 0)
+				NdisSetEvent(&(pNdisCommon->AllThreadCompletedEvent));
+				
+			NdisReleaseSpinLock(&(pNdisCommon->ThreadLock));
+			NdisAcquireSpinLock(&(pPlatformExt->Lock));
+			NdisSetEvent(&(pPlatformExt->CompleteEvent));
+			NdisReleaseSpinLock(&(pPlatformExt->Lock));
+
+	
+			break;
+		}
+
+		Status = ObReferenceObjectByHandle(ThreadHandle,
+		                                   THREAD_ALL_ACCESS,
+		                                   NULL,
+		                                   KernelMode,
+		                                   &pPlatformExt->Thread,
+		                                   NULL);
+		//Need to check status return;	                                
+
+		if (Priority != 0)
+		{
+			KeSetPriorityThread(pPlatformExt->Thread, (KPRIORITY)Priority);
+		}
+
+		ZwClose(ThreadHandle);
+
+	}while(FALSE);
+
+
+	return RT_STATUS_SUCCESS;
+}
+
+
+
+VOID
+PlatformCancelThread(
+	IN	PADAPTER	pAdapter,
+	IN	PRT_THREAD pRtThread)
+{
+	PRT_NDIS_COMMON	pNdisCommon = pAdapter->pNdisCommon;
+	PRT_THREAD_PLATFORM_EXT	pPlatformExt = (PRT_THREAD_PLATFORM_EXT)pRtThread->pPlatformExt;
+
+	if( pPlatformExt == NULL )
+		return ;
+
+	NdisAcquireSpinLock(&(pPlatformExt->Lock));
+
+	if(pRtThread->Status & RT_THREAD_STATUS_RELEASED || 
+		(!(pRtThread->Status & RT_THREAD_STATUS_INITIALIZED)))
+	{
+		NdisReleaseSpinLock(&(pPlatformExt->Lock));
+		return;
+	}
+	
+	if(pRtThread->Status & RT_THREAD_STATUS_FIRED) // already fired and not finish. waiting for the thread complete.
+	{
+		pRtThread->Status |= RT_THREAD_STATUS_CANCEL;
+		NdisReleaseSpinLock(&(pPlatformExt->Lock));
+		NdisSetEvent(&(pPlatformExt->TrigerEvent));
+		NdisWaitEvent(&(pPlatformExt->CompleteEvent),0);
+	}
+	else if(pRtThread->Status & RT_THREAD_STATUS_SET) // set but not fired. This thread would not be fired
+	{
+		pRtThread->Status |= RT_THREAD_STATUS_CANCEL;
+		NdisReleaseSpinLock(&(pPlatformExt->Lock));
+		NdisSetEvent(&(pPlatformExt->TrigerEvent));
+		NdisWaitEvent(&(pPlatformExt->CompleteEvent),0);
+	}
+	else
+	{	
+		NdisReleaseSpinLock(&(pPlatformExt->Lock));
+
+		// thread been canceled
+		NdisAcquireSpinLock(&(pNdisCommon->ThreadLock));
+		
+		if(pNdisCommon->OutStandingThreadCnt == 0)
+			NdisSetEvent(&(pNdisCommon->AllThreadCompletedEvent));
+		
+		NdisReleaseSpinLock(&(pNdisCommon->ThreadLock));
+	}
+}
+
+VOID
+PlatformWaitThreadEnd(
+	IN	PADAPTER	pAdapter,
+	IN	PRT_THREAD pRtThread)
+{
+	PRT_THREAD_PLATFORM_EXT	pPlatformExt = (PRT_THREAD_PLATFORM_EXT)pRtThread->pPlatformExt;
+
+	u4Byte i = 0;
+
+	if( pPlatformExt == NULL )
+		return ;
+
+	NdisAcquireSpinLock(&(pPlatformExt->Lock));
+
+	if(pRtThread->Status & RT_THREAD_STATUS_RELEASED || 
+		(!(pRtThread->Status & RT_THREAD_STATUS_INITIALIZED)))
+	{
+		NdisReleaseSpinLock(&(pPlatformExt->Lock));
+		return;
+	} 
+
+	if( !(pRtThread->Status & RT_THREAD_STATUS_SET) )
+	{
+		NdisReleaseSpinLock(&(pPlatformExt->Lock));
+		return;
+	}
+
+	NdisReleaseSpinLock(&(pPlatformExt->Lock));
+
+	KeWaitForSingleObject(pPlatformExt->Thread,Executive, KernelMode, FALSE, NULL);
+	ObDereferenceObject(pPlatformExt->Thread);
+
+}
+
+VOID
+PlatformReleaseThread(
+	IN	PADAPTER	pAdapter,
+	IN	PRT_THREAD pRtThread)
+{
+	PRT_THREAD_PLATFORM_EXT	pPlatformExt = (PRT_THREAD_PLATFORM_EXT)pRtThread->pPlatformExt;	
+
+	if( pPlatformExt == NULL )
+		return ;
+
+	NdisAcquireSpinLock(&(pPlatformExt->Lock));
+
+	if(pRtThread->Status & RT_THREAD_STATUS_RELEASED || 
+		(!(pRtThread->Status & RT_THREAD_STATUS_INITIALIZED)))
+	{
+		NdisReleaseSpinLock(&(pPlatformExt->Lock));
+		return;
+	}
+
+	pRtThread->Status |= RT_THREAD_STATUS_RELEASED;
+
+	//Fix S3 BSOD, by YJ,120719
+	pRtThread->pPlatformExt = NULL;	
+	
+	NdisReleaseSpinLock(&(pPlatformExt->Lock));
+	NdisFreeSpinLock(&(pPlatformExt->Lock));  // may have some issue?
+
+	PlatformFreeMemory( pPlatformExt, sizeof(RT_THREAD_PLATFORM_EXT) );
+	
+}
+
+//
+//	Description:
+//		This routine  initializes a semaphore object with a specified count and 
+//	specifies an upper limit that the count can attain.
+//
+//	Created by Roger, 2011.01.17.
+//
+VOID
+PlatformInitializeSemaphore(
+	IN 	PPlatformSemaphore	Sema,
+	IN	u4Byte	InitCnt
+	)
+{
+
+	//
+	// We create this  semaphore with an initial count of zero to block access to the protected resource 
+	// while the application is being initialized. After initialization, we can use ReleaseSemaphore to increment 
+	// the count to the maximum value.
+	//
+	KeInitializeSemaphore(
+					Sema, 
+					InitCnt, // Count
+					SEMA_UPBND); // Limit						
+}
+
+
+//
+//	Description:
+//		This routine waits for the semaphore object state to become signaled.
+//
+//	Created by Roger, 2011.01.17.
+//
+RT_STATUS
+PlatformAcquireSemaphore(
+	IN 	PPlatformSemaphore	Sema
+	)
+{	
+	RT_STATUS	status = RT_STATUS_FAILURE;
+	
+	if( STATUS_SUCCESS == KeWaitForSingleObject(Sema, Executive, KernelMode, TRUE, NULL) )
+		status = RT_STATUS_SUCCESS;	
+
+	return status;	
+}
+
+
+//
+//	Description:
+//		This routine increases a semaphore's count by a specified amount.
+//
+//	Created by Roger, 2011.01.17.
+//
+VOID
+PlatformReleaseSemaphore(
+	IN 	PPlatformSemaphore	Sema
+	)
+{
+	if (Sema->Header.Type == 0)
+		return;
+    
+	KeReleaseSemaphore(
+					Sema, 
+					IO_NETWORK_INCREMENT, // Priority increment
+					1,  // Adjustment, a value to be added
+					FALSE ); // Will  not be followed immediately by a call to one of the KeWaitXxx routines
+}
+
+//
+//	Description:
+//		This routine frees a semaphore object 
+//
+//	Created by Roger, 2011.01.17.
+//
+VOID
+PlatformFreeSemaphore(
+	IN 	PPlatformSemaphore	Sema
+	)
+{
+	if (Sema->Header.Type == 0)
+		return;
+}
+
+//
+//	Description:
+//		This routine  initializes a event object 
+//
+//	Created by Cosa, 2012.01.09.
+//
+VOID
+PlatformInitializeEvent(
+	IN 	PPlatformEvent	pEvent
+	)
+{
+	NdisInitializeEvent(pEvent);
+}
+
+VOID
+PlatformResetEvent(
+	IN 	PPlatformEvent	pEvent
+	)
+{
+	NdisResetEvent(pEvent);
+}
+
+VOID
+PlatformSetEvent(
+	IN 	PPlatformEvent	pEvent
+	)
+{
+	NdisSetEvent(pEvent);
+}
+
+VOID
+PlatformFreeEvent(
+	IN 	PPlatformEvent	pEvent
+	)
+{
+
+}
+
+BOOLEAN
+PlatformWaitEvent(
+	IN 	PPlatformEvent	pEvent,
+	IN	u4Byte			msToWait
+	)
+{
+	return NdisWaitEvent(pEvent, msToWait);
+}
+
+
+//
+// 2011/04/08 MH Merge for return pending packet for WINDOWS.
+//
+VOID
+PlatformReturnAllPendingTxPackets(
+	IN 	PADAPTER 		pAdapter
+	)
+{
+	N6SdioReturnAllPendingTxPackets(pAdapter);
+}
+
+
+VOID
+PlatformRestoreLastInitSetting(
+	IN 	PADAPTER 		pAdapter
+	)
+{
+	N6RestoreLastInitSettingAterWakeUP(pAdapter);
+}
+
+BOOLEAN
+PlatformIsOverrideAddress(
+	IN	PADAPTER	Adapter
+	)
+{
+	PRT_NDIS_COMMON	pNdisCommon = Adapter->pNdisCommon;
+
+	if(pNdisCommon->bOverrideAddress)
+	{
+		u1Byte	nulladdr[6] = {0, 0, 0, 0, 0, 0};
+		if(PlatformCompareMemory(nulladdr, pNdisCommon->CurrentAddress, 6) == 0)
+			return FALSE;
+	}
+
+	return pNdisCommon->bOverrideAddress;
+}
+
+pu1Byte
+PlatformGetOverrideAddress(
+	IN	PADAPTER	Adapter
+	)
+{
+	PRT_NDIS_COMMON	pNdisCommon = Adapter->pNdisCommon;
+	
+	return pNdisCommon->CurrentAddress;
+}	
+
+//===================================
+// If we are goting to stop vwifi support, then it will drop 
+// all connections connected with the vwifi and indicate 
+// to OS that can't support anymore. Otherwise, when we
+// need to support vwifi again, we need to 
+// indicate to OS that we can sustain vwifi.
+//===================================
+VOID
+PlatformExtApSupport(
+	IN	PADAPTER	Adapter,
+	IN	BOOLEAN		bSupport
+	)
+{
+	PADAPTER		pExtAdapter;
+	pExtAdapter = GetFirstExtAdapter(Adapter);
+
+	if( NULL != pExtAdapter)
+	{
+		if(!bSupport)
+		{
+			N62CStopApMode(pExtAdapter);
+		}
+		else
+		{
+			N62CApIndicateCanSustainAp(pExtAdapter);
+		}
+	}
+}
+
+BOOLEAN
+PlatformInitReady(
+	IN	PADAPTER	Adapter
+	)
+{
+	if(!N6_INIT_READY(Adapter))
+	{
+		return FALSE;
+	}
+	else
+		return TRUE;
+}
+
+VOID
+Dot11_UpdateDefaultSetting(
+	IN	PADAPTER		pAdapter
+)
+{
+	PMGNT_INFO			pMgntInfo = &(pAdapter->MgntInfo);	
+	PRT_CHANNEL_INFO	pChnlInfo = pMgntInfo->pChannelInfo;
+	PRT_NDIS_COMMON		pNdisCommon = pAdapter->pNdisCommon;
+	EXTCHNL_OFFSET		extchnl = EXTCHNL_OFFSET_NO_EXT;
+
+	// SSID.
+	CopySsid(pMgntInfo->Ssid.Octet, pMgntInfo->Ssid.Length, pNdisCommon->RegSSID.Octet, pNdisCommon->RegSSID.Length);
+
+	// Default wireless mode.
+	pAdapter->RegOrigWirelessMode	= (WIRELESS_MODE)(pNdisCommon->RegWirelessMode); 
+	pAdapter->RegHTMode		  		= (HT_MODE)(pNdisCommon->RegHTMode);
+	
+	if(pAdapter->RegHTMode == HT_MODE_UNDEFINED)
+	{
+		pAdapter->RegWirelessMode		= pAdapter->RegOrigWirelessMode;
+		pAdapter->RegOrigWirelessMode	= 0xFFFF;
+		pAdapter->RegHTMode				= HT_MODE_VHT;
+	}
+	else
+	{
+		if(IS_WIRELESS_MODE_A_ONLY(pAdapter->RegOrigWirelessMode))	// A only
+		{
+			if(IS_VHT_SUPPORTED(pAdapter))
+				pAdapter->RegWirelessMode = WIRELESS_MODE_AC_5G;
+			else if(IS_HT_SUPPORTED(pAdapter))
+				pAdapter->RegWirelessMode = WIRELESS_MODE_N_5G;
+			else
+				pAdapter->RegWirelessMode = WIRELESS_MODE_A;
+		}
+		else if(IS_WIRELESS_MODE_B_ONLY(pAdapter->RegOrigWirelessMode))	// B only
+		{
+			pAdapter->RegWirelessMode	= WIRELESS_MODE_B;
+			pAdapter->RegHTMode			= HT_MODE_DISABLE;
+		}
+		else if(IS_WIRELESS_MODE_G_AND_BG(pAdapter->RegOrigWirelessMode))	// G only, B/G
+		{
+			if(IS_HT_SUPPORTED(pAdapter))
+				pAdapter->RegWirelessMode = WIRELESS_MODE_N_24G;
+			else
+				pAdapter->RegWirelessMode = WIRELESS_MODE_G;
+		}
+		else
+		{
+			pAdapter->RegWirelessMode = WIRELESS_MODE_AUTO;	// A/G, A/B/G
+		}
+
+	}
+
+	{
+		pMgntInfo->Regdot11ChannelNumber = (u1Byte)(pNdisCommon->RegChannel);
+
+		if(pMgntInfo->Regdot11ChannelNumber <= 14)
+		{
+			if(IS_5G_WIRELESS_MODE(pAdapter->RegWirelessMode))
+				pMgntInfo->Regdot11ChannelNumber = 36;
+		}
+		else
+		{
+			if(IS_24G_WIRELESS_MODE(pAdapter->RegWirelessMode))
+				pMgntInfo->Regdot11ChannelNumber = 10;
+		}
+	}
+
+	if(GetDefaultAdapter(pAdapter)->bInHctTest)
+		pMgntInfo->Regdot11ChannelNumber = 10;
+
+	pMgntInfo->dot11CurrentChannelNumber = pMgntInfo->Regdot11ChannelNumber;
+	pChnlInfo->PrimaryChannelNumber = pMgntInfo->dot11CurrentChannelNumber;
+	pChnlInfo->CurrentChannelCenterFrequency = pMgntInfo->dot11CurrentChannelNumber;
+
+
+	if(pAdapter->bInHctTest)
+		pChnlInfo->RegBWSetting = CHANNEL_WIDTH_20;
+	else
+		pChnlInfo->RegBWSetting = pNdisCommon->RegBWSetting;
+
+	// Auto select channel.
+	pMgntInfo->bAutoSelChnl = (BOOLEAN)pNdisCommon->RegAutoSelChnl;
+	pMgntInfo->ChnlWeightMode = (u1Byte)pNdisCommon->RegChnlWeight;
+	
+	// Force Tx rate.
+	pMgntInfo->ForcedDataRate = pNdisCommon->RegForcedDataRate;
+
+	// Set the BeaconType By Bruce, 2011-01-18.
+	pAdapter->HalFunc.SetHalDefVarHandler(pAdapter, HAL_DEF_HW_BEACON_SUPPORT, (pu1Byte)&(pNdisCommon->RegEnableSwBeacon));
+	
+	// AP mode related. 2005.05.30, by rcnjko.
+	pMgntInfo->Regdot11BeaconPeriod = (u2Byte)(pNdisCommon->RegBeaconPeriod);
+	pMgntInfo->dot11BeaconPeriod = pMgntInfo->Regdot11BeaconPeriod;
+	pMgntInfo->Regdot11DtimPeriod = (u1Byte)(pNdisCommon->RegDtimPeriod); 
+	pMgntInfo->dot11DtimPeriod = pMgntInfo->Regdot11DtimPeriod; 
+	pMgntInfo->RegPreambleMode = (u1Byte)(pNdisCommon->RegPreambleMode); 
+	pMgntInfo->dot11CurrentPreambleMode = pMgntInfo->RegPreambleMode;
+
+#if 0
+	// Channel / BW setting
+	if(pChnlInfo->RegBWSetting == CHANNEL_WIDTH_20)
+		extchnl = EXTCHNL_OFFSET_NO_EXT;
+	else
+	{
+		if(CHNL_IsLegal5GChannel(pAdapter, pMgntInfo ->Regdot11ChannelNumber))
+			extchnl = CHNL_GetExt20OffsetOf5G(pMgntInfo->dot11CurrentChannelNumber);
+		else if(pChnlInfo->RegBWSetting == CHANNEL_WIDTH_80)
+		{
+			if(pMgntInfo->dot11CurrentChannelNumber == 1 || pMgntInfo->dot11CurrentChannelNumber == 9)
+				extchnl = EXTCHNL_OFFSET_UPPER;
+			else 
+				extchnl = EXTCHNL_OFFSET_LOWER;
+		}
+		else 
+			extchnl =(pMgntInfo->dot11CurrentChannelNumber<=7)? EXTCHNL_OFFSET_UPPER:EXTCHNL_OFFSET_LOWER;
+	}	
+	pMgntInfo->SettingBeforeScan.ChannelNumber = pMgntInfo->Regdot11ChannelNumber;
+	pMgntInfo->SettingBeforeScan.ChannelBandwidth = pChnlInfo->RegBWSetting;
+	pMgntInfo->SettingBeforeScan.Ext20MHzChnlOffsetOf40MHz = extchnl;
+	pMgntInfo->SettingBeforeScan.Ext40MHzChnlOffsetOf80MHz = extchnl;
+	pMgntInfo->SettingBeforeScan.CenterFrequencyIndex1 = CHNL_GetCenterFrequency(pMgntInfo->SettingBeforeScan.ChannelNumber, pChnlInfo->RegBWSetting, extchnl);
+#endif
+
+}	
+
+
+VOID
+HT_UpdateDefaultSetting(
+	IN	PADAPTER		pAdapter
+)
+{
+	PMGNT_INFO					pMgntInfo = &(pAdapter->MgntInfo);	
+	PRT_HIGH_THROUGHPUT		pHTInfo = GET_HT_INFO(pMgntInfo);
+	PRT_NDIS_COMMON			pNdisCommon = pAdapter->pNdisCommon;
+
+	BOOLEAN						bHwLDPCSupport = FALSE, bHwSTBCSupport = FALSE;
+	BOOLEAN						bHwSupportBeamformer = FALSE, bHwSupportBeamformee = FALSE;
+
+	if(pMgntInfo->bWiFiConfg)
+		pHTInfo->bBssCoexist = TRUE;
+	else
+		pHTInfo->bBssCoexist = FALSE;
+
+	pHTInfo->bRegBW40MHzFor2G = pNdisCommon->bRegBW40MHzFor2G;
+	pHTInfo->bRegBW40MHzFor5G = pNdisCommon->bRegBW40MHzFor5G;
+
+	// 11n adhoc support
+	pMgntInfo->bReg11nAdhoc = pNdisCommon->bReg11nAdhoc;
+
+	// 11ac Bcm 256QAM support
+	pMgntInfo->bRegIOTBcm256QAM = pNdisCommon->bRegIOTBcm256QAM;
+	
+	// CCK rate support in 40MHz channel
+	if(pNdisCommon->RegBWSetting)
+		pHTInfo->bRegSuppCCK = pNdisCommon->bRegHT_EnableCck;
+	else
+		pHTInfo->bRegSuppCCK = TRUE;
+
+	// AMSDU related
+	pHTInfo->nAMSDU_MaxSize = (u2Byte)pNdisCommon->RegAMSDU_MaxSize;
+	pHTInfo->bAMSDU_Support = (BOOLEAN)pNdisCommon->RegAMSDU;
+	
+	pHTInfo->bHWAMSDU_Support = (BOOLEAN)pNdisCommon->RegHWAMSDU;
+
+	// AMPDU related
+	if(pAdapter->bInHctTest)
+		pHTInfo->bAMPDUEnable = FALSE;
+	else	
+		pHTInfo->bAMPDUEnable = (BOOLEAN)pNdisCommon->bRegAMPDUEnable;
+
+	pHTInfo->AMPDU_Factor = (u1Byte)pNdisCommon->RegAMPDU_Factor;
+	pHTInfo->MPDU_Density = (u1Byte)pNdisCommon->RegMPDU_Density;
+
+	// Accept ADDBA Request
+	pHTInfo->bAcceptAddbaReq = (BOOLEAN)(pNdisCommon->bRegAcceptAddbaReq);
+
+	// MIMO Power Save
+	pHTInfo->SelfMimoPs = (u1Byte)pNdisCommon->RegMimoPs;
+	if(pHTInfo->SelfMimoPs == 2)
+		pHTInfo->SelfMimoPs = 3;
+	
+	// For Rx Reorder Control
+	// bRegRxReorderEnable default is FALSE if Rxreorder is swithed by TP since TP should be low as media just connect. 
+	pHTInfo->bRegRxReorderEnable = ((pMgntInfo->RegRxReorder = pNdisCommon->RegRxReorder) ==2) ? FALSE : pNdisCommon->RegRxReorder;
+	pHTInfo->RxReorderWinSize = pMgntInfo->RegRxReorder_WinSize = pNdisCommon->RegRxReorder_WinSize;
+	pHTInfo->RxReorderPendingTime = pMgntInfo->RegRxReorder_PendTime = pNdisCommon->RegRxReorder_PendTime;
+	pHTInfo->bRegShortGI40MHz = TEST_FLAG(pNdisCommon->RegShortGISupport, BIT1) ? TRUE : FALSE;
+	pHTInfo->bRegShortGI20MHz = TEST_FLAG(pNdisCommon->RegShortGISupport, BIT0) ? TRUE : FALSE;
+
+	pHTInfo->b40Intolerant = pNdisCommon->bReg40Intolerant;
+	pHTInfo->bAMPDUManual = pNdisCommon->bRegAMPDUManual;
+	pHTInfo->nTxSPStream = pNdisCommon->RegTxSPStream;
+
+	//IOT issue with Atheros AP. If set incorrect, the Rx rate will always be MCS4. 
+	if(pHTInfo->nRxSPStream == 0)
+	{
+		u1Byte 	Rf_Type = RT_GetRFType(pAdapter);
+			
+		if(Rf_Type == RF_1T2R || Rf_Type == RF_2T2R)
+			pHTInfo->nRxSPStream = 2;
+		else if(Rf_Type == RF_3T3R || Rf_Type == RF_2T4R || Rf_Type == RF_4T4R || Rf_Type == RF_2T3R)
+			pHTInfo->nRxSPStream = 3;
+		else
+			pHTInfo->nRxSPStream = 1;
+	}
+
+	if(pHTInfo->nTxSPStream == 0)
+	{
+		u1Byte 	Rf_Type = RT_GetRFType(pAdapter);
+
+		if(Rf_Type == RF_1T2R || Rf_Type == RF_1T1R)
+			pHTInfo->nTxSPStream = 1;
+		else if(Rf_Type == RF_3T3R || Rf_Type == RF_4T4R)
+			pHTInfo->nTxSPStream = 3;
+		else
+			pHTInfo->nTxSPStream = 2;
+	
+	}
+
+	// LDPC support
+	CLEAR_FLAGS(pHTInfo->HtLdpcCap);
+	
+	// LDPC - Tx
+	pAdapter->HalFunc.GetHalDefVarHandler(pAdapter, HAL_DEF_TX_LDPC, (PBOOLEAN)&bHwLDPCSupport);
+	if(bHwLDPCSupport)
+	{
+		if(TEST_FLAG(pNdisCommon->RegLdpc, BIT5))
+			SET_FLAG(pHTInfo->HtLdpcCap, LDPC_HT_ENABLE_TX);
+	}
+	// LDPC - Rx
+	pAdapter->HalFunc.GetHalDefVarHandler(pAdapter, HAL_DEF_RX_LDPC, (PBOOLEAN)&bHwLDPCSupport);
+	if(bHwLDPCSupport)
+	{
+		if(TEST_FLAG(pNdisCommon->RegLdpc, BIT4))
+			SET_FLAG(pHTInfo->HtLdpcCap, LDPC_HT_ENABLE_RX);
+
+	}
+	RT_TRACE_F(COMP_HT, DBG_LOUD, ("[HT] Support LDOC = 0x%02X\n", pHTInfo->HtLdpcCap));
+
+	// STBC
+	if(pMgntInfo->bWiFiConfg)
+		bHwSTBCSupport = FALSE;
+	else
+		pAdapter->HalFunc.GetHalDefVarHandler(pAdapter, HAL_DEF_TX_STBC, (PBOOLEAN)&bHwSTBCSupport);
+	CLEAR_FLAGS(pHTInfo->HtStbcCap);
+	if(bHwSTBCSupport)
+	{
+		if(TEST_FLAG(pNdisCommon->RegStbc, BIT5))
+			SET_FLAG(pHTInfo->HtStbcCap, STBC_HT_ENABLE_TX);
+
+	}
+	
+	if(pMgntInfo->bWiFiConfg)
+		bHwSTBCSupport = FALSE;
+	else
+		pAdapter->HalFunc.GetHalDefVarHandler(pAdapter, HAL_DEF_RX_STBC, (PBOOLEAN)&bHwSTBCSupport);
+	if(bHwSTBCSupport)
+	{
+		if(TEST_FLAG(pNdisCommon->RegStbc, BIT4))
+			SET_FLAG(pHTInfo->HtStbcCap, STBC_HT_ENABLE_RX);
+	}
+
+	RT_TRACE_F(COMP_HT, DBG_LOUD, ("[HT] Support STBC = 0x%02X\n", pHTInfo->HtStbcCap));
+
+
+
+}
+
+
+VOID
+VHT_UpdateDefaultSetting(
+	IN	PADAPTER		pAdapter
+)
+{
+	PMGNT_INFO					pMgntInfo = &(pAdapter->MgntInfo);
+	PRT_VERY_HIGH_THROUGHPUT	pVHTInfo = GET_VHT_INFO(pMgntInfo);
+	PRT_NDIS_COMMON			pNdisCommon = pAdapter->pNdisCommon;
+
+	BOOLEAN						bHwLDPCSupport = FALSE, bHwSTBCSupport = FALSE;
+	BOOLEAN						bHwSupportBeamformer = FALSE, bHwSupportBeamformee = FALSE;
+	BOOLEAN						bHwSupportMuMimoAp = FALSE, bHwSupportMuMimoSta = FALSE;
+
+	if(pNdisCommon->RegBWSetting == 2)
+	{
+		pVHTInfo->bRegBW80MHz = TRUE;
+		pVHTInfo->bRegShortGI80MHz = TEST_FLAG(pNdisCommon->RegShortGISupport, BIT2) ? TRUE : FALSE;
+	}
+	else
+	{
+		pVHTInfo->bRegBW80MHz = FALSE;
+		pVHTInfo->bRegShortGI80MHz = FALSE;
+	}
+
+	//pVHTInfo->bRegShortGI80MHz = TEST_FLAG(pNdisCommon->RegShortGISupport, BIT2) ? TRUE : FALSE;
+	RT_TRACE(COMP_INIT, DBG_LOUD, ("bRegShortGI80MHz = %d\n", pVHTInfo->bRegShortGI80MHz));
+
+	pVHTInfo->nTxSPStream = pNdisCommon->RegTxSPStream;
+	pVHTInfo->nRxSPStream = pNdisCommon->RegRxSPStream;
+
+	//IOT issue with Atheros AP. If set incorrect, the Rx rate will always be MCS4. 
+	if(pVHTInfo->nRxSPStream == 0)
+	{
+		u1Byte 	Rf_Type = RT_GetRFType(pAdapter);
+			
+		if(Rf_Type == RF_1T2R || Rf_Type == RF_2T2R)
+			pVHTInfo->nRxSPStream = 2;
+		else if(Rf_Type == RF_3T3R || Rf_Type == RF_2T4R || Rf_Type == RF_4T4R || Rf_Type == RF_2T3R)
+			pVHTInfo->nRxSPStream = 3;
+		else
+			pVHTInfo->nRxSPStream = 1;
+	}
+
+	if(pVHTInfo->nTxSPStream == 0)
+	{
+		u1Byte 	Rf_Type = RT_GetRFType(pAdapter);
+
+		if(Rf_Type == RF_1T2R || Rf_Type == RF_1T1R)
+			pVHTInfo->nTxSPStream = 1;
+		else if(Rf_Type == RF_3T3R || Rf_Type == RF_4T4R)
+			pVHTInfo->nTxSPStream = 3;
+		else
+			pVHTInfo->nTxSPStream = 2;
+	
+	}
+
+	// LDPC support
+	CLEAR_FLAGS(pVHTInfo->VhtLdpcCap);
+
+	// LDPC - Tx
+	pAdapter->HalFunc.GetHalDefVarHandler(pAdapter, HAL_DEF_TX_LDPC, (PBOOLEAN)&bHwLDPCSupport);
+	if(bHwLDPCSupport)
+	{
+		if(TEST_FLAG(pNdisCommon->RegLdpc, BIT1))
+			SET_FLAG(pVHTInfo->VhtLdpcCap, LDPC_VHT_ENABLE_TX);
+	}
+	// LDPC - Rx
+	pAdapter->HalFunc.GetHalDefVarHandler(pAdapter, HAL_DEF_RX_LDPC, (PBOOLEAN)&bHwLDPCSupport);
+	if(bHwLDPCSupport)
+	{
+		if(TEST_FLAG(pNdisCommon->RegLdpc, BIT0))
+			SET_FLAG(pVHTInfo->VhtLdpcCap, LDPC_VHT_ENABLE_RX);
+	}
+	RT_TRACE_F(COMP_INIT, DBG_LOUD, ("[VHT] Support LDPC = 0x%02X\n", pVHTInfo->VhtLdpcCap));
+
+	// STBC
+	pAdapter->HalFunc.GetHalDefVarHandler(pAdapter, HAL_DEF_TX_STBC, (PBOOLEAN)&bHwSTBCSupport);
+	CLEAR_FLAGS(pVHTInfo->VhtStbcCap);
+	if(bHwSTBCSupport)
+	{
+		if(TEST_FLAG(pNdisCommon->RegStbc, BIT1))
+			SET_FLAG(pVHTInfo->VhtStbcCap, STBC_VHT_ENABLE_TX);
+
+	}
+	pAdapter->HalFunc.GetHalDefVarHandler(pAdapter, HAL_DEF_RX_STBC, (PBOOLEAN)&bHwSTBCSupport);
+	if(bHwSTBCSupport)
+	{
+		if(TEST_FLAG(pNdisCommon->RegStbc, BIT0))
+			SET_FLAG(pVHTInfo->VhtStbcCap, STBC_VHT_ENABLE_RX);
+	}
+	RT_TRACE_F(COMP_INIT, DBG_LOUD, ("[VHT] Support STBC = 0x%02X\n", pVHTInfo->VhtStbcCap));
+
+
+}
+
+VOID 
+PSC_UpdateDefaultSetting(
+	IN	PADAPTER		pAdapter
+)
+{
+	PMGNT_INFO					pMgntInfo = &(pAdapter->MgntInfo);	
+	PRT_NDIS_COMMON			pNdisCommon = pAdapter->pNdisCommon;
+	PRT_POWER_SAVE_CONTROL	pPSC = GET_POWER_SAVE_CONTROL(pMgntInfo);
+
+	// For SDIO DPC ISR WHQL test setting.
+	// We should enable power saving mode to pass DPC USR test.
+	pMgntInfo->bSdioDpcIsr = (BOOLEAN)pNdisCommon->RegSdioDpcIsr;
+
+	//3 All Power Save Mechanism.
+	if((pAdapter->bInHctTest  || pMgntInfo->bWiFiConfg) && !pMgntInfo->bSdioDpcIsr)
+	{
+#if 0	
+		if(pAdapter->bDPCISRTest)
+		{
+			pPSC->bInactivePs = TRUE;
+			pPSC->bLeisurePs = TRUE;
+			pMgntInfo->keepAliveLevel =pNdisCommon->RegKeepAliveLevel;
+			pPSC->bFwCtrlLPS = TRUE;
+			pPSC->FWCtrlPSMode = FW_PS_MIN_MODE;
+			DbgPrint("test set leisurePS and inactivePS to TRUE\n");
+		}
+		else
+#endif			
+		{
+			pPSC->bInactivePs = FALSE;
+			pNdisCommon->RegInactivePsMode = eIpsOff;
+			
+			pPSC->bLeisurePs = FALSE;
+			pNdisCommon->RegLeisurePsMode = eLpsOff;			
+				
+			pMgntInfo->keepAliveLevel =0;
+
+			pPSC->bFwCtrlLPS = FALSE;
+			pNdisCommon->bRegFwCtrlLPS =0;
+			pPSC->bLeisurePsModeBackup = FALSE;
+			
+			pPSC->FWCtrlPSMode = FW_PS_ACTIVE_MODE;
+		}
+	}	
+	else
+	{
+		RT_TRACE(COMP_INIT, DBG_LOUD, ("pNdisCommon->RegInactivePsMode = %d\n", pNdisCommon->RegInactivePsMode));	
+		if(pNdisCommon->RegInactivePsMode == eIpsAuto)
+			pPSC->bInactivePs = FALSE;
+		else
+			pPSC->bInactivePs = pNdisCommon->RegInactivePsMode;
+
+		pPSC->bLeisurePsModeBackup = FALSE;
+
+		//2008.08.25 
+		if( (pNdisCommon->RegLeisurePsMode==eLpsOn) && (pMgntInfo->dot11PowerSaveMode == eActive) ) 
+		{
+			RT_TRACE(COMP_INIT, DBG_LOUD, ("LeisurePs On!!\n"));
+			pPSC->bLeisurePs = TRUE;
+		}
+		else	 if( (pNdisCommon->RegLeisurePsMode==eLpsAuto) && (pMgntInfo->dot11PowerSaveMode == eActive) )
+		{
+			RT_TRACE(COMP_INIT, DBG_LOUD, ("LeisurePs Off!!\n"));
+			pPSC->bLeisurePs = FALSE;
+		}
+		else
+		{
+			RT_TRACE(COMP_INIT, DBG_LOUD, ("LeisurePs Off!!\n"));
+			pPSC->bLeisurePs = FALSE;
+		}
+		pMgntInfo->keepAliveLevel =pNdisCommon->RegKeepAliveLevel;
+	
+		//Fw Control LPS mode
+		if(pNdisCommon->bRegFwCtrlLPS == 0)
+			pPSC->bFwCtrlLPS = FALSE;
+		else
+			pPSC->bFwCtrlLPS = TRUE;
+		
+		// We need to assign the FW PS mode value even if we do not enable LPS mode. 2012.03.05. by tynli.
+		if(pNdisCommon->bRegFwCtrlLPS == 0)
+			pPSC->FWCtrlPSMode = FW_PS_ACTIVE_MODE;
+		else if(pNdisCommon->bRegFwCtrlLPS == 1)
+			pPSC->FWCtrlPSMode = FW_PS_MIN_MODE;
+		else if(pNdisCommon->bRegFwCtrlLPS == 2)
+			pPSC->FWCtrlPSMode = FW_PS_MAX_MODE;
+		else if(pNdisCommon->bRegFwCtrlLPS == 3)
+			pPSC->FWCtrlPSMode = FW_PS_SELF_DEFINED_MODE;
+
+		
+//LPS 32K Support and Enable Deep Sleep
+//by sherry 20150910
+		if((pNdisCommon->RegLeisurePsMode != eLpsOff) && (pNdisCommon->bRegLowPowerEnable) && (pNdisCommon->bRegLPSDeepSleepEnable))
+		{
+			RT_TRACE(COMP_INIT,DBG_LOUD,("PSC_UpdateDefaultSetting: Enable LPS Deep Sleep \n"));
+			FwLPSDeepSleepInit(pAdapter);
+		}	
+	}
+
+	pPSC->bIPSModeBackup = pPSC->bInactivePs;
+	pPSC->bLeisurePsModeBackup = pPSC->bLeisurePs;
+	pPSC->RegMaxLPSAwakeIntvl = pNdisCommon->RegLPSMaxIntvl;
+	pPSC->RegAdvancedLPs = pNdisCommon->RegAdvancedLPs;
+
+	pPSC->bGpioRfSw = pNdisCommon->bRegGpioRfSw;
+	
+	pPSC->RegLeisurePsMode = pNdisCommon->RegLeisurePsMode;
+	pPSC->RegPowerSaveMode = pNdisCommon->RegPowerSaveMode;
+
+	#if((USB_TX_THREAD_ENABLE && RTL8723_USB_IO_THREAD_ENABLE) || RTL8723_SDIO_IO_THREAD_ENABLE)
+		pPSC->bLowPowerEnable = (BOOLEAN)pNdisCommon->bRegLowPowerEnable;
+	#else
+		pPSC->bLowPowerEnable = 0;
+	#endif
+
+	//Set WoWLAN mode. 2009.09.01. by tynli
+	if(pNdisCommon->bRegWakeOnMagicPacket)
+	{
+		if(pNdisCommon->bRegWakeOnPattern)
+			pPSC->WoWLANMode = eWakeOnBothTypePacket;
+		else
+			pPSC->WoWLANMode = eWakeOnMagicPacketOnly;
+	}
+	else if(pNdisCommon->bRegWakeOnPattern)
+	{
+		pPSC->WoWLANMode = eWakeOnPatternMatchOnly;
+	}
+	else
+	{
+		pPSC->WoWLANMode = eWoWLANDisable;	
+	}
+
+	pPSC->bWakeOnDisconnect = pNdisCommon->bRegWakeOnDisconnect;
+
+	if(pNdisCommon->bRegPacketCoalescing)
+		pMgntInfo->bSupportPacketCoalescing = TRUE;
+	else
+		pMgntInfo->bSupportPacketCoalescing = FALSE;
+	
+	pPSC->APOffloadEnable = pNdisCommon->RegAPOffloadEnable;
+	pPSC->WoWLANLPSLevel = pNdisCommon->RegWoWLANLPSLevel ;
+	pPSC->WoWLANS5Support = pNdisCommon->RegWoWLANS5Support;
+	pPSC->D2ListenIntvl = pNdisCommon->RegD2ListenIntvl;
+	pPSC->bFakeWoWLAN =  pNdisCommon->bRegFakeWoWLAN;
+	
+	pPSC->RegARPOffloadEnable = pNdisCommon->bRegARPOffloadEnable;
+	pPSC->RegGTKOffloadEnable = pNdisCommon->bRegGTKOffloadEnable ;	// support GTK offload after NDIS620.
+	pPSC->ProtocolOffloadDecision = pNdisCommon->RegProtocolOffloadDecision;
+	pPSC->RegNSOffloadEnable = pNdisCommon->bRegNSOffloadEnable;
+
+	pPSC->FSSDetection = pNdisCommon->RegFSSDetection;
+	pMgntInfo->bIntelPatchPNP =  pNdisCommon->RegIntelPatchPNP;
+	pPSC->DxNLOEnable = pNdisCommon->RegNLOEnable;
+	pMgntInfo->bRegPnpKeepLink = (BOOLEAN)pNdisCommon->RegPnpKeepLink;
+
+	pPSC->bFwCtrlPwrOff = (BOOLEAN)pNdisCommon->RegFwCtrlPwrOff;
+	pPSC->CardDisableInLowClk = (BOOLEAN)pNdisCommon->RegCardDisableInLowClk;
+	pPSC->FwIPSLevel = pNdisCommon->RegFwIPSLevel;
+
+	// WoWLAN setting for DTM test.
+	if(pAdapter->bInHctTest)
+	{
+		// Do not enable WoWLAN LPS in DTM test.
+		pPSC->WoWLANLPSLevel = 0;
+	}
+
+	pAdapter->bRxPsWorkAround = (BOOLEAN)pNdisCommon->RegRxPsWorkAround;
+
+	RT_TRACE(COMP_POWER, DBG_LOUD, ("bRegFwCtrlLPS %d bRegLeisurePs %d", pNdisCommon->bRegFwCtrlLPS, pNdisCommon->RegLeisurePsMode));
+	RT_TRACE(COMP_POWER, DBG_LOUD, ("bFwCtrlLPS %d bLeisurePs %d", pPSC->bFwCtrlLPS, pPSC->bLeisurePs));
+}
+
+
+//
+//	Description:
+//		Read common registry value under LOCAL_MACHINE\SYSTEM\CurrentControlSet\Service\RtlWlanx
+//	2014.12.15, by Sean.
+//
+//    PASSIVE_LEVEL ONLY!!!!!!!!!!!!!!!!!!!!!!!!!
+NTSTATUS
+PlatformReadCommonDwordRegistry(
+	IN	PWCHAR			registryName,
+	OUT	pu4Byte			resultValue)
+{
+
+	OBJECT_ATTRIBUTES	objectAttributes = {0};
+	HANDLE				driverKey = NULL;
+	NTSTATUS			ntStatus = STATUS_SUCCESS;
+	UNICODE_STRING		ValueName;
+	UNICODE_STRING		RegistryPath;
+	KEY_VALUE_PARTIAL_INFORMATION	result;
+	ULONG				resultLength;
+	
+
+	do
+	{
+		RtlInitUnicodeString(&RegistryPath,GlobalRtDriverContext.NdisContext.RegistryPath);
+		//DbgPrint("PATH: %wZ length:%d MAX :%d \n",&RegistryPath,RegistryPath.Length,RegistryPath.MaximumLength);
+
+		InitializeObjectAttributes(&objectAttributes,
+		                           &RegistryPath,
+		                           OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
+		                           NULL,
+		                           NULL);
+	    
+		if(STATUS_SUCCESS != (ntStatus = ZwOpenKey(&driverKey, KEY_READ, &objectAttributes)))
+		{
+			DbgPrint("ZwOpenKey Failed = 0x%x\n", ntStatus);
+			break;
+		}
+		RtlInitUnicodeString(&ValueName, registryName);
+
+		ntStatus = ZwQueryValueKey(driverKey,&ValueName,KeyValuePartialInformation,&result,sizeof(KEY_VALUE_PARTIAL_INFORMATION),&resultLength);
+
+		if(STATUS_SUCCESS != ntStatus)
+		{
+			DbgPrint("ZwQueryValueKey Failed = 0x%x\n", ntStatus);
+			break;
+		}
+		memcpy(resultValue,result.Data,sizeof(u4Byte));
+		//DbgPrint("Test result:%d Length:%d type:%d\n",*resultValue, result.DataLength, result.Type);    
+	}while(FALSE);
+
+	if(driverKey)
+	{
+		ZwClose(driverKey);
+		driverKey = NULL;
+	}
+
+	return ntStatus;
+
+}
+
+
+//
+//	Description:
+//		Write common registry value under LOCAL_MACHINE\SYSTEM\CurrentControlSet\Service\RtlWlanx
+//	2014.12.16, by Sean.
+//
+//    PASSIVE_LEVEL ONLY!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+NTSTATUS
+PlatformWriteCommonDwordRegistry(
+	IN	PWCHAR			registryName,
+	IN	pu4Byte			Value)
+{
+
+	OBJECT_ATTRIBUTES	objectAttributes = {0};
+	HANDLE				driverKey = NULL;
+	NTSTATUS			ntStatus = STATUS_SUCCESS;
+	UNICODE_STRING		ValueName;
+	UNICODE_STRING		RegistryPath;
+	
+
+	do
+	{
+		RtlInitUnicodeString(&RegistryPath,GlobalRtDriverContext.NdisContext.RegistryPath);
+		InitializeObjectAttributes(&objectAttributes,
+		                           &RegistryPath,
+		                           OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
+		                           NULL,
+		                           NULL);
+	    
+		if(STATUS_SUCCESS != (ntStatus = ZwOpenKey(&driverKey, KEY_WRITE, &objectAttributes)))
+		{
+			DbgPrint("ZwOpenKey Failed = 0x%x\n", ntStatus);
+			break;
+		}
+		RtlInitUnicodeString(&ValueName, registryName);
+
+		ntStatus = ZwSetValueKey(driverKey,&ValueName,0,REG_DWORD,Value,sizeof(u4Byte));
+
+		if(STATUS_SUCCESS != ntStatus)
+		{
+			DbgPrint("ZwSetValueKey Failed = 0x%x\n", ntStatus);
+			break;
+		}
+	
+	}while(FALSE);
+
+	if(driverKey)
+	{
+		ZwClose(driverKey);
+		driverKey = NULL;
+	}
+
+	return ntStatus;
+
+}
+
+NTSTATUS
+PlatformWriteBTAntPosDwordRegistry(
+	IN	PWCHAR			registryName,
+	IN	pu4Byte			Value)
+{
+
+	OBJECT_ATTRIBUTES	objectAttributes = {0};
+	HANDLE				driverKey = NULL;
+	NTSTATUS			ntStatus = STATUS_SUCCESS;
+	UNICODE_STRING		ValueName;
+	UNICODE_STRING		RegistryPath;
+	ANSI_STRING 		AnsiString;  
+	
+	RT_TRACE(COMP_INIT, DBG_LOUD, ("### test\n"));
+
+	do
+	{
+		//RtlInitUnicodeString(&RegistryPath,registryPath);
+		RtlInitString(&AnsiString,"\\REGISTRY\\MACHINE\\SYSTEM\\ControlSet001\\Services\\RtlWlans\\Parameters");
+		RtlAnsiStringToUnicodeString(&RegistryPath,&AnsiString,TRUE);
+		RT_TRACE(COMP_INIT, DBG_LOUD, ("### PlatformWriteBTAntPosDwordRegistry(): RegistryPath = %wZ\n", &RegistryPath));
+		
+		InitializeObjectAttributes(&objectAttributes,
+		                           &RegistryPath,
+		                           OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
+		                           NULL,
+		                           NULL);
+	    
+		if(STATUS_SUCCESS != (ntStatus = ZwOpenKey(&driverKey, KEY_WRITE, &objectAttributes)))
+		{
+			DbgPrint("ZwOpenKey Failed = 0x%x\n", ntStatus);
+			break;
+		}
+		RtlInitUnicodeString(&ValueName, registryName);
+
+		ntStatus = ZwSetValueKey(driverKey,&ValueName,0,REG_DWORD,Value,sizeof(u4Byte));
+
+		if(STATUS_SUCCESS != ntStatus)
+		{
+			DbgPrint("ZwSetValueKey Failed = 0x%x\n", ntStatus);
+			break;
+		}
+	
+	}while(FALSE);
+
+	if(driverKey)
+	{
+		ZwClose(driverKey);
+		driverKey = NULL;
+	}
+
+	RtlFreeUnicodeString(&RegistryPath); 
+	return ntStatus;
+
+}
+
+#if READ_BT_REGISTRY
+NTSTATUS
+PlatformReadBTFWLoaderDwordRegistry(
+	IN	PWCHAR			registryName,
+	OUT	pu1Byte			resultValue)
+{
+
+	OBJECT_ATTRIBUTES	objectAttributes = {0};
+	HANDLE				driverKey = NULL;
+	NTSTATUS			ntStatus = STATUS_SUCCESS;
+	UNICODE_STRING		ValueName;
+	UNICODE_STRING		RegistryPath;
+	ANSI_STRING 		AnsiString;
+	KEY_VALUE_PARTIAL_INFORMATION	result;
+	ULONG				resultLength;
+	
+
+	do
+	{
+		RtlInitString(&AnsiString,"\\REGISTRY\\MACHINE\\Software\\Realtek\\Bluetooth\\service");
+		RtlAnsiStringToUnicodeString(&RegistryPath,&AnsiString,TRUE);
+		RT_TRACE(COMP_INIT, DBG_LOUD, ("### PlatformReadBTFWLoaderDwordRegistry(): RegistryPath = %wZ\n", &RegistryPath));
+
+		InitializeObjectAttributes(&objectAttributes,
+		                           &RegistryPath,
+		                           OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
+		                           NULL,
+		                           NULL);
+	    
+		if(STATUS_SUCCESS != (ntStatus = ZwOpenKey(&driverKey, KEY_READ, &objectAttributes)))
+		{
+			DbgPrint("ZwOpenKey Failed = 0x%x\n", ntStatus);
+			break;
+		}
+		RtlInitUnicodeString(&ValueName, registryName);
+
+		ntStatus = ZwQueryValueKey(driverKey,&ValueName,KeyValuePartialInformation,&result,sizeof(KEY_VALUE_PARTIAL_INFORMATION),&resultLength);
+
+		if(STATUS_SUCCESS != ntStatus)
+		{
+			DbgPrint("ZwQueryValueKey Failed = 0x%x\n", ntStatus);
+			break;
+		}
+		memcpy(resultValue,result.Data,sizeof(u4Byte));
+		//DbgPrint("Test result:%d Length:%d type:%d\n",*resultValue, result.DataLength, result.Type);    
+	}while(FALSE);
+
+	if(driverKey)
+	{
+		ZwClose(driverKey);
+		driverKey = NULL;
+	}
+
+	return ntStatus;
+
+}
+#endif
+
+
diff --git a/network/wlan/WDI/PLATFORM/NdisComm/NdisComm.h b/network/wlan/WDI/PLATFORM/NdisComm/NdisComm.h
new file mode 100644
index 00000000..75561d1a
--- /dev/null
+++ b/network/wlan/WDI/PLATFORM/NdisComm/NdisComm.h
@@ -0,0 +1,284 @@
+#ifndef __INC_NDIS_COMMON_H
+#define __INC_NDIS_COMMON_H
+
+
+#define N6_LLC_SIZE			8
+#define MAX_STALL_TIME		50		//us. If the delay time is larger than 50us, it's better to call NdisMSleep 
+
+
+#define NDIS_ADAPTER_TYPE RT_SDIO_DEVICE
+#define PNDIS_ADAPTER_TYPE PRT_SDIO_DEVICE
+#define GET_NDIS_ADAPTER(_Adapter)	&_Adapter->NdisSdioDev
+
+#ifndef	MAX_PATH
+#define	MAX_PATH	260		// From DDK.
+#endif // #ifndef	MAX_PATH
+
+
+#define REGISTRY(_Adapter, _VAR)		(_Adapter->pNdisCommon->##_VAR)
+
+#define SetRegLdpc(_Adapter, _RegLdpc)	(_Adapter->pNdisCommon->RegLdpc= _RegLdpc)
+#define SetRegStbc(_Adapter, _RegStbc)	(_Adapter->pNdisCommon->RegStbc= _RegStbc)
+
+
+//
+// <Roger_DBG> Using following state flag to trace vWiFi and power transaction event for some vWiFi bus BSOD issue.
+// 2013.1213
+//
+#define DrvStateNull				0
+#define DrvStateNdisInitialized	BIT0
+#define DrvStateHwInitialized		BIT1
+#define DrvStateHwHalting		BIT2
+#define DrvStateHwHalted			BIT3
+#define DrvStateMacCreating		BIT4
+#define DrvStateMacCreated		BIT5
+#define DrvStateMacDeleting		BIT6
+#define DrvStateMacDeleted		BIT7
+
+//
+// Following flags are abnormal cases
+//
+#define DrvStateMacCreate_NO_DO			BIT8
+#define	DrvStateMacCreate_TMR_FAIL		BIT9
+#define	DrvStateMacCreate_Fail			BIT10
+#define DrvStateMacDelete_NO_DO			BIT11
+#define	DrvStateMacDelete_TMR_FAIL		BIT12
+#define	DrvStateMacDelete_Fail			BIT13
+#define	DrvStateMacCreDel_WI_FAIL		BIT14
+
+#define	DrvStateMacCreatDispatch		BIT15
+#define	DrvStateMacCreatWait			BIT16
+
+#define DrvStateNdisReqPended			BIT22
+#define DrvStateNdisReqPended_Error0	BIT23
+#define DrvStateMacPendReq_Error0		BIT24
+#define DrvStateMacPendReq_Error1		BIT25
+#define DrvStateMacPendReq_Error2		BIT26
+#define DrvStateResetting					BIT27
+
+#define DrvStateWI_Error0				BIT28
+#define DrvStateWI_Error1				BIT29
+#define DrvStateWI_Error2				BIT30
+#define DrvStateWI_Error3				BIT31
+
+#if DRV_LOG_REGISTRY
+#define RT_GET_DRV_STATE(__pAdapter)				(GetDefaultAdapter(__pAdapter)->DrvState)
+#define RT_GET_DRV_STATE_ERROR(__pAdapter)		(GetDefaultAdapter(__pAdapter)->bDrvStateError)
+#define RT_CLEAR_DRV_STATE_ERROR(__pAdapter)		(GetDefaultAdapter(__pAdapter)->bDrvStateError = FALSE)
+
+// Reset all driver state for initialization
+#define RT_INIT_DRV_STATE(__pAdapter)\
+{\
+	u4Byte	DrvState;\
+	RT_TRACE(COMP_INIT, DBG_TRACE, ("RT_INIT_DRV_STATE: \n"));\
+	PlatformAcquireSpinLock(__pAdapter, RT_DRV_STATE_SPINLOCK);\
+	GetDefaultAdapter(__pAdapter)->DrvState= DrvStateNull;\
+	DrvState = RT_GET_DRV_STATE(__pAdapter);\
+	PlatformReleaseSpinLock(__pAdapter, RT_DRV_STATE_SPINLOCK);\
+	if(N6WriteRegDriverState(__pAdapter, DrvState) == NDIS_STATUS_FAILURE)\
+	{\
+		GetDefaultAdapter(__pAdapter)->bDrvStateError = TRUE;\
+	}\
+}
+
+// Set specific driver state
+#define RT_SET_DRV_STATE(__pAdapter, __StaBits)	\
+{	\
+	u4Byte	DrvState;\
+	RT_TRACE(COMP_INIT, DBG_TRACE, ("RT_SET_DRV_STATE: %#x\n", __StaBits));\
+	PlatformAcquireSpinLock(__pAdapter, RT_DRV_STATE_SPINLOCK);\
+	(GetDefaultAdapter(__pAdapter))->DrvState |= ((RT_DF_TYPE)(__StaBits));\
+	DrvState = RT_GET_DRV_STATE(__pAdapter);\
+	PlatformReleaseSpinLock(__pAdapter, RT_DRV_STATE_SPINLOCK);\
+	if(N6WriteRegDriverState(__pAdapter, DrvState) == NDIS_STATUS_FAILURE)\
+	{\
+		GetDefaultAdapter(__pAdapter)->bDrvStateError = TRUE;\
+	}\
+}
+
+// Clear corresponding driver state
+#define RT_CLEAR_DRV_STATE(__pAdapter, __StaBits)\
+{\
+	u4Byte	DrvState;\
+	RT_TRACE(COMP_INIT, DBG_TRACE, ("RT_CLEAR_DRV_STATE: %#x\n", __StaBits));\
+	PlatformAcquireSpinLock(__pAdapter, RT_DRV_STATE_SPINLOCK);\
+	(GetDefaultAdapter(__pAdapter))->DrvState &= (~((RT_DF_TYPE)(__StaBits)));\
+	DrvState = RT_GET_DRV_STATE(__pAdapter);\
+	PlatformReleaseSpinLock(__pAdapter, RT_DRV_STATE_SPINLOCK);\
+	if(N6WriteRegDriverState(__pAdapter, DrvState) == NDIS_STATUS_FAILURE)\
+	{\
+		GetDefaultAdapter(__pAdapter)->bDrvStateError = TRUE;\
+	}\
+}
+#else
+#define RT_GET_DRV_STATE(__pAdapter)	0
+#define RT_GET_DRV_STATE_ERROR(__pAdapter)	0
+#define RT_CLEAR_DRV_STATE_ERROR(__pAdapter)
+#define RT_INIT_DRV_STATE(__pAdapter)
+#define RT_SET_DRV_STATE(__pAdapter, __StaBits)
+#define RT_CLEAR_DRV_STATE(__pAdapter, __StaBits)
+#endif
+
+
+typedef struct  __RT_THREAD_PLATFORM_EXT{
+	NDIS_EVENT	CompleteEvent;
+	NDIS_EVENT		TrigerEvent;
+	u4Byte			Period;
+	NDIS_SPIN_LOCK	Lock;
+
+
+	PKTHREAD		Thread;
+
+}RT_THREAD_PLATFORM_EXT, *PRT_THREAD_PLATFORM_EXT;
+
+
+// Add for windwos common binary.
+typedef struct _NIC_MUTEX
+{
+    ULONG                   Counter;
+    ULONG                   ModuleAndLine;  // useful for debugging
+
+} NIC_MUTEX, *PNIC_MUTEX;
+
+//
+// 2011/02/25 MH Moev the global spin lock and and mutex for global variable between two adapter
+// we need to define all the MAC and structure for dedicated OS.
+//
+// Add for 92D Dual MAC communication protection.
+typedef struct GLOBAL_SPINLOCK
+{
+    ULONG                   SpinlockCounter;
+
+    KIRQL                    SpinlockIrql;
+
+} GLOBAL_SPINLOCK, *PGLOBAL_SPINLOCK;
+
+
+
+//
+// Global Mutex: can only be used at PASSIVE level.
+//
+#define ACQUIRE_GLOBAL_MUTEX(_MutexCounter)                              \
+{                                                               \
+    while (NdisInterlockedIncrement((PULONG)&(_MutexCounter)) != 1)\
+    {                                                           \
+        NdisInterlockedDecrement((PULONG)&(_MutexCounter));        \
+        NdisMSleep(10000);                          \
+    }                                                           \
+}
+
+#define RELEASE_GLOBAL_MUTEX(_MutexCounter)                              \
+{                                                               \
+    NdisInterlockedDecrement((PULONG)&(_MutexCounter));              \
+}
+
+//
+// Global Spinlock: can be used at PASSIVE and DISPATCH level.
+//
+
+#define ACQUIRE_GLOBAL_SPINLOCK(_pSpinlock)                         \
+{                                                                                               \
+    KIRQL                    TempIrql;                                                    \
+    TempIrql = KeGetCurrentIrql();                                                 \
+    if (TempIrql == PASSIVE_LEVEL)                                                  \
+    {                                                                                           \
+    	  KeRaiseIrql(DISPATCH_LEVEL, &TempIrql);	                          \
+    }                                                                                           \
+    while (NdisInterlockedIncrement((PULONG)&((_pSpinlock)->SpinlockCounter)) != 1)\
+    {                                                                                                             \
+        NdisInterlockedDecrement((PULONG)&((_pSpinlock)->SpinlockCounter));        \
+        NdisStallExecution(40);                                                                            \
+    }                                                                                                             \
+    (_pSpinlock)->SpinlockIrql = TempIrql;                                                          \
+}
+
+#define RELEASE_GLOBAL_SPINLOCK(_pSpinlock)                                           \
+{                                                                                                                \
+    KIRQL                    TempIrql;                                                                      \
+    TempIrql = (_pSpinlock)->SpinlockIrql;                                                         \
+    NdisInterlockedDecrement((PULONG)&((_pSpinlock)->SpinlockCounter));          \
+    if (TempIrql == PASSIVE_LEVEL)                                                                  \
+        KeLowerIrql(TempIrql);                                                                           \
+}
+
+
+//===============================================
+// The following is for Windows pIRP definition
+//===============================================
+typedef struct _IRP_ENTRY
+{
+	RT_LIST_ENTRY List;
+	PIRP  	          pIrp;
+}IRP_ENTRY, *PIRP_ENTRY;
+
+
+//
+// Data structure used in DbgWorkItem related OID.
+//
+typedef struct _RT8187DBGWIPARAM
+{
+	ULONG		bDbgActCompleted;
+	ULONG		eDbgActType;
+	ULONG		IoOffset;
+	ULONG		IoValue;	
+	ULONG		outLen;
+	UCHAR		outBuf[200];
+}RT8187DBGWIPARAM, *PRT8187DBGWIPARAM;
+
+//===============================================
+
+NDIS_STATUS
+NdisStatusFromRtStatus(
+	IN	u4Byte	rtStatus
+	);
+
+
+VOID
+Dot11_UpdateDefaultSetting(
+	IN	PADAPTER		pAdapter
+);
+
+
+VOID
+HT_UpdateDefaultSetting(
+	IN	PADAPTER		pAdapter
+);
+
+
+VOID
+VHT_UpdateDefaultSetting(
+	IN	PADAPTER		pAdapter
+);
+
+VOID 
+PSC_UpdateDefaultSetting(
+	IN	PADAPTER		pAdapter
+);
+
+VOID 
+HAL_UpdateDefaultSetting(
+	IN	PADAPTER		pAdapter
+);
+
+NTSTATUS
+PlatformReadCommonDwordRegistry(
+	IN	PWCHAR			registryName,
+	OUT	pu4Byte			Data);
+
+NTSTATUS
+PlatformWriteCommonDwordRegistry(
+	IN	PWCHAR			registryName,
+	IN	pu4Byte			Data);
+
+NTSTATUS
+PlatformWriteBTAntPosDwordRegistry(
+	IN	PWCHAR			registryName,
+	IN	pu4Byte			Data);
+
+NTSTATUS
+PlatformReadBTFWLoaderDwordRegistry(
+	IN	PWCHAR			registryName,
+	OUT	pu1Byte			resultValue);
+
+
+#endif
diff --git a/network/wlan/WDI/PLATFORM/NdisComm/NdisComm.vcxproj b/network/wlan/WDI/PLATFORM/NdisComm/NdisComm.vcxproj
new file mode 100644
index 00000000..70ae9f7b
--- /dev/null
+++ b/network/wlan/WDI/PLATFORM/NdisComm/NdisComm.vcxproj
@@ -0,0 +1,612 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Win10 Debug|Arm">
+      <Configuration>Win10 Debug</Configuration>
+      <Platform>Arm</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Win10 Debug|Win32">
+      <Configuration>Win10 Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Win10 Debug|x64">
+      <Configuration>Win10 Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Win10 Release|Arm">
+      <Configuration>Win10 Release</Configuration>
+      <Platform>Arm</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Win10 Release|Win32">
+      <Configuration>Win10 Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Win10 Release|x64">
+      <Configuration>Win10 Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="WinBlue Debug|Arm">
+      <Configuration>WinBlue Debug</Configuration>
+      <Platform>Arm</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Win8 Debug|Arm">
+      <Configuration>Win8 Debug</Configuration>
+      <Platform>Arm</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="WinBlue Release|Arm">
+      <Configuration>WinBlue Release</Configuration>
+      <Platform>Arm</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Win8 Release|Arm">
+      <Configuration>Win8 Release</Configuration>
+      <Platform>Arm</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="WinBlue Debug|Win32">
+      <Configuration>WinBlue Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Win8 Debug|Win32">
+      <Configuration>Win8 Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Win7 Debug|Win32">
+      <Configuration>Win7 Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Vista Debug|Win32">
+      <Configuration>Vista Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="WinBlue Release|Win32">
+      <Configuration>WinBlue Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Win8 Release|Win32">
+      <Configuration>Win8 Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Win7 Release|Win32">
+      <Configuration>Win7 Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Vista Release|Win32">
+      <Configuration>Vista Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="WinBlue Debug|x64">
+      <Configuration>WinBlue Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Win8 Debug|x64">
+      <Configuration>Win8 Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Win7 Debug|x64">
+      <Configuration>Win7 Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Vista Debug|x64">
+      <Configuration>Vista Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="WinBlue Release|x64">
+      <Configuration>WinBlue Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Win8 Release|x64">
+      <Configuration>Win8 Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Win7 Release|x64">
+      <Configuration>Win7 Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Vista Release|x64">
+      <Configuration>Vista Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="PropertySheets">
+    <PlatformToolset>WindowsKernelModeDriver10.0</PlatformToolset>
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <DriverType>KMDF</DriverType>
+    <TARGETNAME>
+    </TARGETNAME>
+    <Configuration>Win8 Debug</Configuration>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="PropertySheets">
+    <ConversionToolVersion>1.0</ConversionToolVersion>
+    <BUILD_ALT_DIR>$(Configuration.Replace(' ',''))</BUILD_ALT_DIR>
+    <IntDir Condition="'$(Platform)'!='Win32'">$(BUILD_ALT_DIR)\$(Platform)\</IntDir>
+    <IntDir Condition="'$(Platform)'=='Win32'">$(BUILD_ALT_DIR)\</IntDir>
+    <OutDir>$(SolutionDir)PLATFORM\NdisComm\$(Configuration)\$(Platform)\</OutDir>
+  </PropertyGroup>
+  <ImportGroup Label="PreConfiguration">
+    <Import Project="$(VCTargetsPath)\WDKConversion\PreConfiguration.props" />
+  </ImportGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{C0A51792-1338-4294-ADAA-EDC4EE30CF05}</ProjectGuid>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='WinBlue Debug|Arm'">
+    <TargetVersion>WindowsV6.3</TargetVersion>
+    <UseDebugLibraries>True</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Debug|Arm'" Label="Configuration">
+    <TargetVersion>Windows10</TargetVersion>
+    <UseDebugLibraries>True</UseDebugLibraries>
+    <DriverTargetPlatform>Universal</DriverTargetPlatform>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|Arm'">
+    <TargetVersion>Win8</TargetVersion>
+    <UseDebugLibraries>True</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='WinBlue Release|Arm'">
+    <TargetVersion>WindowsV6.3</TargetVersion>
+    <UseDebugLibraries>False</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Release|Arm'" Label="Configuration">
+    <TargetVersion>Windows10</TargetVersion>
+    <UseDebugLibraries>False</UseDebugLibraries>
+    <DriverTargetPlatform>Universal</DriverTargetPlatform>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win8 Release|Arm'">
+    <TargetVersion>Win8</TargetVersion>
+    <UseDebugLibraries>False</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='WinBlue Debug|Win32'">
+    <TargetVersion>WindowsV6.3</TargetVersion>
+    <UseDebugLibraries>True</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Debug|Win32'" Label="Configuration">
+    <TargetVersion>Windows10</TargetVersion>
+    <UseDebugLibraries>True</UseDebugLibraries>
+    <DriverTargetPlatform>Universal</DriverTargetPlatform>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|Win32'">
+    <TargetVersion>Win8</TargetVersion>
+    <UseDebugLibraries>True</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|Win32'">
+    <TargetVersion>Win7</TargetVersion>
+    <UseDebugLibraries>True</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Vista Debug|Win32'">
+    <TargetVersion>Vista</TargetVersion>
+    <UseDebugLibraries>True</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='WinBlue Release|Win32'">
+    <TargetVersion>WindowsV6.3</TargetVersion>
+    <UseDebugLibraries>False</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Release|Win32'" Label="Configuration">
+    <TargetVersion>Windows10</TargetVersion>
+    <UseDebugLibraries>False</UseDebugLibraries>
+    <DriverTargetPlatform>Universal</DriverTargetPlatform>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win8 Release|Win32'">
+    <TargetVersion>Win8</TargetVersion>
+    <UseDebugLibraries>False</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win7 Release|Win32'">
+    <TargetVersion>Win7</TargetVersion>
+    <UseDebugLibraries>False</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Vista Release|Win32'">
+    <TargetVersion>Vista</TargetVersion>
+    <UseDebugLibraries>False</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='WinBlue Debug|x64'">
+    <TargetVersion>WindowsV6.3</TargetVersion>
+    <UseDebugLibraries>True</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Debug|x64'" Label="Configuration">
+    <TargetVersion>Windows10</TargetVersion>
+    <UseDebugLibraries>True</UseDebugLibraries>
+    <DriverTargetPlatform>Universal</DriverTargetPlatform>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|x64'">
+    <TargetVersion>Win8</TargetVersion>
+    <UseDebugLibraries>True</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|x64'">
+    <TargetVersion>Win7</TargetVersion>
+    <UseDebugLibraries>True</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Vista Debug|x64'">
+    <TargetVersion>Vista</TargetVersion>
+    <UseDebugLibraries>True</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='WinBlue Release|x64'">
+    <TargetVersion>WindowsV6.3</TargetVersion>
+    <UseDebugLibraries>False</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Release|x64'" Label="Configuration">
+    <TargetVersion>Windows10</TargetVersion>
+    <UseDebugLibraries>False</UseDebugLibraries>
+    <DriverTargetPlatform>Universal</DriverTargetPlatform>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win8 Release|x64'">
+    <TargetVersion>Win8</TargetVersion>
+    <UseDebugLibraries>False</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Win7 Release|x64'">
+    <TargetVersion>Win7</TargetVersion>
+    <UseDebugLibraries>False</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Vista Release|x64'">
+    <TargetVersion>Vista</TargetVersion>
+    <UseDebugLibraries>False</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup>
+    <DebuggerFlavor Condition="'$(IsKernelModeToolset)'=='true'">DbgengKernelDebugger</DebuggerFlavor>
+    <DebuggerFlavor Condition="'$(IsUserModeToolset)'=='true'">DbgengRemoteDebugger</DebuggerFlavor>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Debug|Win32'">
+    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
+    <ReferencePath>$(VC_ReferencesPath_x86);</ReferencePath>
+    <LibraryPath>$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86);$(NETFXKitsDir)Lib\um\x86</LibraryPath>
+    <LibraryWPath>$(WindowsSDK_MetadataPath);</LibraryWPath>
+    <SourcePath>$(VC_SourcePath);</SourcePath>
+    <ExcludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);$(MSBuild_ExecutablePath);$(VC_LibraryPath_x86);</ExcludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Release|Win32'">
+    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
+    <ReferencePath>$(VC_ReferencePath_x86);</ReferencePath>
+    <LibraryWPath>$(WindowsSDK_MetadataPath);</LibraryWPath>
+    <SourcePath>$(VC_SourcePath);</SourcePath>
+    <LibraryPath>$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86);$(NETFXKitsDir)Lib\um\x86</LibraryPath>
+    <ExcludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);$(MSBuild_ExecutablePath);$(VC_LibraryPath_x86);</ExcludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Release|Arm'">
+    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
+    <ReferencePath>$(VC_ReferencePath_arm);</ReferencePath>
+    <LibraryPath>$(VC_LibraryPath_arm);$(WindowsSDK_LibraryPath_arm);$(NETFXKitsDir)Lib\um\arm</LibraryPath>
+    <LibraryWPath>$(WindowsSDK_MetadataPath);</LibraryWPath>
+    <SourcePath>$(VC_SourcePath);</SourcePath>
+    <ExcludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);$(MSBuild_ExecutablePath);$(VC_LibraryPath_arm);</ExcludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Debug|Arm'">
+    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
+    <ReferencePath>$(VC_ReferencePath_arm);</ReferencePath>
+    <LibraryPath>$(VC_LibraryPath_arm);$(WindowsSDK_LibraryPath_arm);$(NETFXKitsDir)Lib\um\arm</LibraryPath>
+    <LibraryWPath>$(WindowsSDK_MetadataPath);</LibraryWPath>
+    <SourcePath>$(VC_SourcePath);</SourcePath>
+    <ExcludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);$(MSBuild_ExecutablePath);$(VC_LibraryPath_arm);</ExcludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Debug|x64'">
+    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
+    <ReferencePath>$(VC_ReferencesPath_x64);</ReferencePath>
+    <LibraryPath>$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);$(NETFXKitsDir)Lib\um\x64</LibraryPath>
+    <LibraryWPath>$(WindowsSDK_MetadataPath);</LibraryWPath>
+    <SourcePath>$(VC_SourcePath);</SourcePath>
+    <ExcludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);$(MSBuild_ExecutablePath);$(VC_LibraryPath_x64);</ExcludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Release|x64'">
+    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
+    <ReferencePath>$(VC_ReferencesPath_x64);</ReferencePath>
+    <LibraryPath>$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);$(NETFXKitsDir)Lib\um\x64</LibraryPath>
+    <LibraryWPath>$(WindowsSDK_MetadataPath);</LibraryWPath>
+    <SourcePath>$(VC_SourcePath);</SourcePath>
+    <ExcludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);$(MSBuild_ExecutablePath);$(VC_LibraryPath_x64);</ExcludePath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Debug|Win32'">
+    <ClCompile>
+      <PreprocessorDefinitions>_X86_;DBG;USE_KLOCKS=1;BINARY_COMPATIBLE=0;NDIS650_MINIPORT=1;NDIS640_MINIPORT=1;NDIS630_MINIPORT=1;NDIS620_MINIPORT=1;NDIS61_MINIPORT=1;NDIS_MINIPORT_DRIVER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CallingConvention>Cdecl</CallingConvention>
+      <CompileAs>Default</CompileAs>
+      <AdditionalIncludeDirectories>$(WindowsSdkDir)\Include\km\;$(WindowsSdkDir)\Include\shared\;$(WindowsSdkDir)\Include\wdf\kmdf\1.15\;$(WindowsSdkDir)\Include\km\crt\;$(SolutionDir)HEADER;$(SolutionDir)PLATFORM\NDIS6\;$(SolutionDir)PLATFORM\NdisComm\;$(SolutionDir)PLATFORM\NDIS6\SDIO\;$(SolutionDir)HAL\;$(SolutionDir)HAL\phydm\;$(SolutionDir)HAL\rtl8723B\;$(SolutionDir)HAL\rtl8723B\rtl8723bs\;$(SolutionDir)HAL\phydm\rtl8723b\;$(SolutionDir)COMMON\;</AdditionalIncludeDirectories>
+      <Optimization>Disabled</Optimization>
+      <InlineFunctionExpansion>Default</InlineFunctionExpansion>
+      <IntrinsicFunctions>false</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
+      <OmitFramePointers>false</OmitFramePointers>
+      <EnableFiberSafeOptimizations>false</EnableFiberSafeOptimizations>
+      <WholeProgramOptimization>false</WholeProgramOptimization>
+      <MinimalRebuild>true</MinimalRebuild>
+      <ExceptionHandling>
+      </ExceptionHandling>
+      <SmallerTypeCheck>false</SmallerTypeCheck>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <StructMemberAlignment>Default</StructMemberAlignment>
+      <DisableLanguageExtensions>false</DisableLanguageExtensions>
+      <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
+      <ForceConformanceInForLoopScope>true</ForceConformanceInForLoopScope>
+      <RemoveUnreferencedCodeData>true</RemoveUnreferencedCodeData>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <ExpandAttributedSource>false</ExpandAttributedSource>
+      <DebugInformationFormat>None</DebugInformationFormat>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <UndefineAllPreprocessorDefinitions>false</UndefineAllPreprocessorDefinitions>
+      <IgnoreStandardIncludePath>false</IgnoreStandardIncludePath>
+      <PreprocessToFile>false</PreprocessToFile>
+      <PreprocessSuppressLineNumbers>false</PreprocessSuppressLineNumbers>
+      <PreprocessKeepComments>false</PreprocessKeepComments>
+      <ShowIncludes>false</ShowIncludes>
+      <UseFullPaths>false</UseFullPaths>
+      <OmitDefaultLibName>false</OmitDefaultLibName>
+      <ErrorReporting>Prompt</ErrorReporting>
+      <WppEnabled>true</WppEnabled>
+    </ClCompile>
+    <Lib>
+      <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+    </Lib>
+    <ProjectReference>
+      <LinkLibraryDependencies>false</LinkLibraryDependencies>
+    </ProjectReference>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Release|Win32'">
+    <Lib>
+      <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>
+    </Lib>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Release|Win32'">
+    <Lib>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+    </Lib>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Release|Win32'">
+    <ProjectReference>
+      <LinkLibraryDependencies>false</LinkLibraryDependencies>
+    </ProjectReference>
+    <ClCompile>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <Optimization>Disabled</Optimization>
+      <InlineFunctionExpansion>Default</InlineFunctionExpansion>
+      <IntrinsicFunctions>false</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
+      <OmitFramePointers>false</OmitFramePointers>
+      <EnableFiberSafeOptimizations>false</EnableFiberSafeOptimizations>
+      <WholeProgramOptimization>false</WholeProgramOptimization>
+      <UndefineAllPreprocessorDefinitions>false</UndefineAllPreprocessorDefinitions>
+      <IgnoreStandardIncludePath>false</IgnoreStandardIncludePath>
+      <PreprocessToFile>false</PreprocessToFile>
+      <PreprocessSuppressLineNumbers>false</PreprocessSuppressLineNumbers>
+      <PreprocessKeepComments>false</PreprocessKeepComments>
+      <MinimalRebuild>true</MinimalRebuild>
+      <SmallerTypeCheck>false</SmallerTypeCheck>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <StructMemberAlignment>Default</StructMemberAlignment>
+      <DisableLanguageExtensions>false</DisableLanguageExtensions>
+      <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
+      <ForceConformanceInForLoopScope>true</ForceConformanceInForLoopScope>
+      <RemoveUnreferencedCodeData>true</RemoveUnreferencedCodeData>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <CallingConvention>Cdecl</CallingConvention>
+      <CompileAs>Default</CompileAs>
+      <ShowIncludes>false</ShowIncludes>
+      <UseFullPaths>false</UseFullPaths>
+      <OmitDefaultLibName>false</OmitDefaultLibName>
+      <ErrorReporting>Prompt</ErrorReporting>
+      <AdditionalIncludeDirectories>$(WindowsSdkDir)\Include\km\;$(WindowsSdkDir)\Include\shared\;$(WindowsSdkDir)\Include\wdf\kmdf\1.15\;$(WindowsSdkDir)\Include\km\crt\;$(SolutionDir)HEADER;$(SolutionDir)PLATFORM\NDIS6\;$(SolutionDir)PLATFORM\NdisComm\;$(SolutionDir)PLATFORM\NDIS6\SDIO\;$(SolutionDir)HAL\;$(SolutionDir)HAL\phydm\;$(SolutionDir)HAL\rtl8723B\;$(SolutionDir)HAL\rtl8723B\rtl8723bs\;$(SolutionDir)HAL\phydm\rtl8723b\;$(SolutionDir)COMMON\;</AdditionalIncludeDirectories>
+      <DebugInformationFormat>None</DebugInformationFormat>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <PreprocessorDefinitions>_X86_;USE_KLOCKS=1;BINARY_COMPATIBLE=0;NDIS650_MINIPORT=1;NDIS640_MINIPORT=1;NDIS630_MINIPORT=1;NDIS620_MINIPORT=1;NDIS61_MINIPORT=1;NDIS_MINIPORT_DRIVER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <WppEnabled>true</WppEnabled>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Release|Arm'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(WindowsSdkDir)\Include\km\;$(WindowsSdkDir)\Include\shared\;$(WindowsSdkDir)\Include\wdf\kmdf\1.15\;$(WindowsSdkDir)\Include\km\crt\;$(SolutionDir)HEADER;$(SolutionDir)PLATFORM\NDIS6\;$(SolutionDir)PLATFORM\NdisComm\;$(SolutionDir)PLATFORM\NDIS6\SDIO\;$(SolutionDir)HAL\;$(SolutionDir)HAL\phydm\;$(SolutionDir)HAL\rtl8723B\;$(SolutionDir)HAL\rtl8723B\rtl8723bs\;$(SolutionDir)HAL\phydm\rtl8723b\;$(SolutionDir)COMMON\;</AdditionalIncludeDirectories>
+      <DebugInformationFormat>None</DebugInformationFormat>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <Optimization>Disabled</Optimization>
+      <InlineFunctionExpansion>Default</InlineFunctionExpansion>
+      <IntrinsicFunctions>false</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
+      <OmitFramePointers>false</OmitFramePointers>
+      <EnableFiberSafeOptimizations>false</EnableFiberSafeOptimizations>
+      <WholeProgramOptimization>false</WholeProgramOptimization>
+      <PreprocessorDefinitions>_ARM_;USE_KLOCKS=1;BINARY_COMPATIBLE=0;NDIS650_MINIPORT=1;NDIS640_MINIPORT=1;NDIS630_MINIPORT=1;NDIS620_MINIPORT=1;NDIS61_MINIPORT=1;NDIS_MINIPORT_DRIVER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <UndefineAllPreprocessorDefinitions>false</UndefineAllPreprocessorDefinitions>
+      <IgnoreStandardIncludePath>false</IgnoreStandardIncludePath>
+      <PreprocessToFile>false</PreprocessToFile>
+      <PreprocessSuppressLineNumbers>false</PreprocessSuppressLineNumbers>
+      <PreprocessKeepComments>false</PreprocessKeepComments>
+      <MinimalRebuild>true</MinimalRebuild>
+      <SmallerTypeCheck>false</SmallerTypeCheck>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <StructMemberAlignment>Default</StructMemberAlignment>
+      <DisableLanguageExtensions>false</DisableLanguageExtensions>
+      <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
+      <ForceConformanceInForLoopScope>true</ForceConformanceInForLoopScope>
+      <RemoveUnreferencedCodeData>true</RemoveUnreferencedCodeData>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <CallingConvention>Cdecl</CallingConvention>
+      <CompileAs>Default</CompileAs>
+      <ShowIncludes>false</ShowIncludes>
+      <UseFullPaths>false</UseFullPaths>
+      <OmitDefaultLibName>false</OmitDefaultLibName>
+      <ErrorReporting>Prompt</ErrorReporting>
+      <WppEnabled>true</WppEnabled>
+    </ClCompile>
+    <Lib>
+      <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+    </Lib>
+    <ProjectReference>
+      <LinkLibraryDependencies>false</LinkLibraryDependencies>
+    </ProjectReference>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Debug|Arm'">
+    <ClCompile>
+      <WppEnabled>true</WppEnabled>
+      <AdditionalIncludeDirectories>$(WindowsSdkDir)\Include\km\;$(WindowsSdkDir)\Include\shared\;$(WindowsSdkDir)\Include\wdf\kmdf\1.15\;$(WindowsSdkDir)\Include\km\crt\;$(SolutionDir)HEADER;$(SolutionDir)PLATFORM\NDIS6\;$(SolutionDir)PLATFORM\NdisComm\;$(SolutionDir)PLATFORM\NDIS6\SDIO\;$(SolutionDir)HAL\;$(SolutionDir)HAL\phydm\;$(SolutionDir)HAL\rtl8723B\;$(SolutionDir)HAL\rtl8723B\rtl8723bs\;$(SolutionDir)HAL\phydm\rtl8723b\;$(SolutionDir)COMMON\;</AdditionalIncludeDirectories>
+      <DebugInformationFormat>None</DebugInformationFormat>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <Optimization>Disabled</Optimization>
+      <InlineFunctionExpansion>Default</InlineFunctionExpansion>
+      <IntrinsicFunctions>false</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
+      <OmitFramePointers>false</OmitFramePointers>
+      <EnableFiberSafeOptimizations>false</EnableFiberSafeOptimizations>
+      <WholeProgramOptimization>false</WholeProgramOptimization>
+      <PreprocessorDefinitions>_ARM_;DBG;USE_KLOCKS=1;BINARY_COMPATIBLE=0;NDIS650_MINIPORT=1;NDIS640_MINIPORT=1;NDIS630_MINIPORT=1;NDIS620_MINIPORT=1;NDIS61_MINIPORT=1;NDIS_MINIPORT_DRIVER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <UndefineAllPreprocessorDefinitions>false</UndefineAllPreprocessorDefinitions>
+      <IgnoreStandardIncludePath>false</IgnoreStandardIncludePath>
+      <PreprocessToFile>false</PreprocessToFile>
+      <PreprocessSuppressLineNumbers>false</PreprocessSuppressLineNumbers>
+      <PreprocessKeepComments>false</PreprocessKeepComments>
+      <MinimalRebuild>true</MinimalRebuild>
+      <SmallerTypeCheck>false</SmallerTypeCheck>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <StructMemberAlignment>Default</StructMemberAlignment>
+      <DisableLanguageExtensions>false</DisableLanguageExtensions>
+      <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
+      <ForceConformanceInForLoopScope>true</ForceConformanceInForLoopScope>
+      <RemoveUnreferencedCodeData>true</RemoveUnreferencedCodeData>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <CallingConvention>Cdecl</CallingConvention>
+      <CompileAs>Default</CompileAs>
+      <ShowIncludes>false</ShowIncludes>
+      <UseFullPaths>false</UseFullPaths>
+      <OmitDefaultLibName>false</OmitDefaultLibName>
+      <ErrorReporting>Prompt</ErrorReporting>
+    </ClCompile>
+    <Lib>
+      <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+    </Lib>
+    <ProjectReference>
+      <LinkLibraryDependencies>false</LinkLibraryDependencies>
+    </ProjectReference>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Debug|x64'">
+    <ClCompile>
+      <WppEnabled>true</WppEnabled>
+      <AdditionalIncludeDirectories>$(WindowsSdkDir)\Include\km\;$(WindowsSdkDir)\Include\shared\;$(WindowsSdkDir)\Include\wdf\kmdf\1.15\;$(WindowsSdkDir)\Include\km\crt\;$(SolutionDir)HEADER;$(SolutionDir)PLATFORM\NDIS6\;$(SolutionDir)PLATFORM\NdisComm\;$(SolutionDir)PLATFORM\NDIS6\SDIO\;$(SolutionDir)HAL\;$(SolutionDir)HAL\phydm\;$(SolutionDir)HAL\rtl8723B\;$(SolutionDir)HAL\rtl8723B\rtl8723bs\;$(SolutionDir)HAL\phydm\rtl8723b\;$(SolutionDir)COMMON\;</AdditionalIncludeDirectories>
+      <DebugInformationFormat>None</DebugInformationFormat>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <Optimization>Disabled</Optimization>
+      <InlineFunctionExpansion>Default</InlineFunctionExpansion>
+      <IntrinsicFunctions>false</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
+      <OmitFramePointers>false</OmitFramePointers>
+      <EnableFiberSafeOptimizations>false</EnableFiberSafeOptimizations>
+      <WholeProgramOptimization>false</WholeProgramOptimization>
+      <PreprocessorDefinitions>_X64_;DBG;USE_KLOCKS=1;BINARY_COMPATIBLE=0;NDIS650_MINIPORT=1;NDIS640_MINIPORT=1;NDIS630_MINIPORT=1;NDIS620_MINIPORT=1;NDIS61_MINIPORT=1;NDIS_MINIPORT_DRIVER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <UndefineAllPreprocessorDefinitions>false</UndefineAllPreprocessorDefinitions>
+      <IgnoreStandardIncludePath>false</IgnoreStandardIncludePath>
+      <PreprocessToFile>false</PreprocessToFile>
+      <PreprocessSuppressLineNumbers>false</PreprocessSuppressLineNumbers>
+      <PreprocessKeepComments>false</PreprocessKeepComments>
+      <MinimalRebuild>true</MinimalRebuild>
+      <SmallerTypeCheck>false</SmallerTypeCheck>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <StructMemberAlignment>Default</StructMemberAlignment>
+      <DisableLanguageExtensions>false</DisableLanguageExtensions>
+      <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
+      <ForceConformanceInForLoopScope>true</ForceConformanceInForLoopScope>
+      <RemoveUnreferencedCodeData>true</RemoveUnreferencedCodeData>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <CallingConvention>Cdecl</CallingConvention>
+      <CompileAs>Default</CompileAs>
+      <ShowIncludes>false</ShowIncludes>
+      <UseFullPaths>false</UseFullPaths>
+      <OmitDefaultLibName>false</OmitDefaultLibName>
+      <ErrorReporting>Prompt</ErrorReporting>
+    </ClCompile>
+    <Lib>
+      <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>
+    </Lib>
+    <Lib>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+    </Lib>
+    <ProjectReference>
+      <LinkLibraryDependencies>false</LinkLibraryDependencies>
+    </ProjectReference>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win10 Release|x64'">
+    <ClCompile>
+      <WppEnabled>true</WppEnabled>
+      <AdditionalIncludeDirectories>$(WindowsSdkDir)\Include\km\;$(WindowsSdkDir)\Include\shared\;$(WindowsSdkDir)\Include\wdf\kmdf\1.15\;$(WindowsSdkDir)\Include\km\crt\;$(SolutionDir)HEADER;$(SolutionDir)PLATFORM\NDIS6\;$(SolutionDir)PLATFORM\NdisComm\;$(SolutionDir)PLATFORM\NDIS6\SDIO\;$(SolutionDir)HAL\;$(SolutionDir)HAL\phydm\;$(SolutionDir)HAL\rtl8723B\;$(SolutionDir)HAL\rtl8723B\rtl8723bs\;$(SolutionDir)HAL\phydm\rtl8723b\;$(SolutionDir)COMMON\;</AdditionalIncludeDirectories>
+      <DebugInformationFormat>None</DebugInformationFormat>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <Optimization>Disabled</Optimization>
+      <InlineFunctionExpansion>Default</InlineFunctionExpansion>
+      <IntrinsicFunctions>false</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
+      <OmitFramePointers>false</OmitFramePointers>
+      <EnableFiberSafeOptimizations>false</EnableFiberSafeOptimizations>
+      <WholeProgramOptimization>false</WholeProgramOptimization>
+      <PreprocessorDefinitions>_X64_;USE_KLOCKS=1;BINARY_COMPATIBLE=0;NDIS650_MINIPORT=1;NDIS640_MINIPORT=1;NDIS630_MINIPORT=1;NDIS620_MINIPORT=1;NDIS61_MINIPORT=1;NDIS_MINIPORT_DRIVER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <UndefineAllPreprocessorDefinitions>false</UndefineAllPreprocessorDefinitions>
+      <IgnoreStandardIncludePath>false</IgnoreStandardIncludePath>
+      <PreprocessToFile>false</PreprocessToFile>
+      <PreprocessSuppressLineNumbers>false</PreprocessSuppressLineNumbers>
+      <PreprocessKeepComments>false</PreprocessKeepComments>
+      <MinimalRebuild>true</MinimalRebuild>
+      <SmallerTypeCheck>false</SmallerTypeCheck>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <StructMemberAlignment>Default</StructMemberAlignment>
+      <DisableLanguageExtensions>false</DisableLanguageExtensions>
+      <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
+      <ForceConformanceInForLoopScope>true</ForceConformanceInForLoopScope>
+      <RemoveUnreferencedCodeData>true</RemoveUnreferencedCodeData>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <CallingConvention>Cdecl</CallingConvention>
+      <CompileAs>Default</CompileAs>
+      <ShowIncludes>false</ShowIncludes>
+      <UseFullPaths>false</UseFullPaths>
+      <ErrorReporting>Prompt</ErrorReporting>
+      <OmitDefaultLibName>false</OmitDefaultLibName>
+    </ClCompile>
+    <Lib>
+      <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>
+    </Lib>
+    <Lib>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+    </Lib>
+    <ProjectReference>
+      <LinkLibraryDependencies>false</LinkLibraryDependencies>
+    </ProjectReference>
+  </ItemDefinitionGroup>
+  <!-- Needed by any VcxProj -->
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup Label="UserMacros" />
+  <!-- The WrappedTaskItems label is used by the conversion tool to identify the location where items 
+        associated with wrapped tasks will reside.-->
+  <ItemGroup Label="WrappedTaskItems" />
+  <ItemGroup>
+    <!-- We only add items (e.g. form ClSourceFiles) that do not already exist (e.g in the ClCompile list), this avoids duplication -->
+    <ClCompile Include="@(ClSourceFiles)" Exclude="@(ClCompile)" />
+    <ClCompile Include="NdisComm.c" />
+    <ClCompile Include="NdisDbg.c" />
+    <ClCompile Include="NdisOid.c" />
+    <ResourceCompile Include="@(RcSourceFiles)" Exclude="@(ResourceCompile)" />
+    <Midl Include="@(IdlSourceFiles)" Exclude="@(Midl)" />
+    <MessageCompile Include="@(McSourceFiles)" Exclude="@(MessageCompile)" />
+    <MASM Include="@(AsmSourceFiles)" Exclude="@(MASM)" />
+    <GenerateBmf Include="@(MofSourceFiles)" Exclude="@(GenerateBmf)" />
+  </ItemGroup>
+  <!-- Set default environment variables, e.g. for stampinf -->
+  <ItemGroup>
+    <BuildMacro Include="SDK_INC_PATH">
+      <Value>$(KIT_SHARED_INC_PATH)</Value>
+      <EnvironmentVariable>true</EnvironmentVariable>
+    </BuildMacro>
+  </ItemGroup>
+  <!-- Necessary to pick up propper files from local directory when in the IDE-->
+  <ItemGroup>
+    <None Exclude="@(None)" Include="*.txt;*.htm;*.html" />
+    <None Exclude="@(None)" Include="*.ico;*.cur;*.bmp;*.dlg;*.rct;*.gif;*.jpg;*.jpeg;*.wav;*.jpe;*.tiff;*.tif;*.png;*.rc2" />
+    <None Exclude="@(None)" Include="*.def;*.bat;*.hpj;*.asmx" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Exclude="@(ClInclude)" Include="*.h;*.hpp;*.hxx;*.hm;*.inl;*.xsd" />
+  </ItemGroup>
+  <!-- /Necessary to pick up propper files from local directory when in the IDE-->
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>
\ No newline at end of file
diff --git a/network/wlan/WDI/PLATFORM/NdisComm/NdisDbg.c b/network/wlan/WDI/PLATFORM/NdisComm/NdisDbg.c
new file mode 100644
index 00000000..6b459774
--- /dev/null
+++ b/network/wlan/WDI/PLATFORM/NdisComm/NdisDbg.c
@@ -0,0 +1,1691 @@
+#include "Mp_Precomp.h"
+
+//-----------------------------------------------------------------------------
+//	Description:
+//		Callback function of DbgWorkItem.
+//
+//-----------------------------------------------------------------------------
+
+// global buf for BT c2h rsp.
+u1Byte	GLCurBtC2hRsp[20];
+u1Byte	GLCurBtStackRsp[100];
+
+BT_CTRL_STATUS
+ndbg_CheckBtRspStatus(
+	IN	PADAPTER			Adapter
+	)
+{
+	BT_CTRL_STATUS	retStatus=BT_OP_STATUS_SUCCESS;
+	PBT_EXT_C2H 		pExtC2h=(PBT_EXT_C2H)&GLCurBtC2hRsp[0];
+
+	switch(pExtC2h->statusCode)
+	{
+		case BT_OP_STATUS_SUCCESS:
+			retStatus = BT_STATUS_BT_OP_SUCCESS;
+			RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], BT status : MP_BT_STATUS_SUCCESS\n"));
+			break;
+		case BT_OP_STATUS_VERSION_MISMATCH:
+			retStatus = BT_STATUS_OPCODE_L_VERSION_MISMATCH;
+			RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], BT status : MP_BT_STATUS_OPCODE_L_VERSION_MISMATCH\n"));
+			break;
+		case BT_OP_STATUS_UNKNOWN_OPCODE:
+			retStatus = BT_STATUS_UNKNOWN_OPCODE_L;
+			RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], BT status : MP_BT_STATUS_UNKNOWN_OPCODE_L\n"));
+			break;
+		case BT_OP_STATUS_ERROR_PARAMETER:
+			retStatus = BT_STATUS_PARAMETER_FORMAT_ERROR_L;
+			RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], BT status : MP_BT_STATUS_PARAMETER_FORMAT_ERROR_L\n"));
+			break;
+		default:
+			retStatus = BT_STATUS_UNKNOWN_STATUS_L;
+			RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], BT status : MP_BT_STATUS_UNKNOWN_STATUS_L\n"));
+			break;
+	}
+	
+	return retStatus;
+}	
+
+BT_CTRL_STATUS
+ndbg_CheckC2hFrame(
+	IN	PADAPTER		Adapter,
+	IN	PBT_H2C			pH2c
+	)
+{
+	BT_CTRL_STATUS	c2hStatus=BT_STATUS_C2H_SUCCESS;
+	PBT_EXT_C2H 		pExtC2h=(PBT_EXT_C2H)&GLCurBtC2hRsp[0];
+		
+	RT_DISP_DATA(FBT, BT_DBG_CONTENT, ("[BTDBG], C2H rsp hex: \n"), pExtC2h, 6);
+
+	RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], statusCode = 0x%x\n", pExtC2h->statusCode));
+	RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], retLen = %d\n", pExtC2h->retLen));
+	RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], opCodeVer : req/rsp=%d/%d\n", pH2c->opCodeVer, pExtC2h->opCodeVer));
+	RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], reqNum : req/rsp=%d/%d\n", pH2c->reqNum, pExtC2h->reqNum));
+	if(pExtC2h->reqNum != pH2c->reqNum)
+	{
+		c2hStatus = BT_STATUS_C2H_REQNUM_MISMATCH;
+		RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], Error!! C2H reqNum Mismatch!!\n"));
+	}
+	else if(pExtC2h->opCodeVer != pH2c->opCodeVer)
+	{
+		c2hStatus = BT_STATUS_OPCODE_L_VERSION_MISMATCH;
+		RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], Error!! OPCode version L mismatch!!\n"));
+	}
+
+	return c2hStatus;
+}
+
+BT_CTRL_STATUS
+ndbg_SendH2c(
+	IN	PADAPTER	Adapter,
+	IN	PBT_H2C		pH2c,
+	IN	u2Byte		h2cCmdLen
+	)
+{
+	KIRQL				OldIrql = KeGetCurrentIrql();
+	BT_CTRL_STATUS		h2cStatus=BT_STATUS_H2C_SUCCESS;
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx=&(Adapter->ndisDbgCtx);
+	u1Byte				i;
+
+	RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], ndbg_SendH2c()=========>\n"));
+
+	PlatformResetEvent(&pDbgCtx->dbgH2cRspEvent);
+	PlatformResetEvent(&pDbgCtx->dbgBtC2hEvent);
+
+	if(OldIrql == PASSIVE_LEVEL)
+	{
+		RT_DISP_DATA(FBT, BT_DBG_CONTENT, ("[BTDBG], H2C hex: \n"), pH2c, h2cCmdLen);
+
+		for(i=0; i<BT_H2C_MAX_RETRY; i++)
+		{
+			RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], Send H2C command to wifi!!!\n"));
+			
+			pDbgCtx->h2cReqNum++;
+			pDbgCtx->h2cReqNum %= 16;
+			if(PlatformWaitEvent(&pDbgCtx->dbgH2cRspEvent, 100))
+			{
+				RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], Received H2C Rsp Event!!!\n"));
+				if(PlatformWaitEvent(&pDbgCtx->dbgBtC2hEvent, 500))
+				{
+					RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], Received BT C2H Event!!!\n"));
+					break;
+				}
+				else
+				{
+					RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], Error!! BT C2H Event timeout!!\n"));
+					h2cStatus = BT_STATUS_H2C_BT_NO_RSP;
+				}
+			}
+			else
+			{
+				RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], Error!! H2C Rsp Event timeout!!\n"));
+				h2cStatus = BT_STATUS_H2C_TIMTOUT;
+			}
+		}
+	}
+	else
+	{
+		RT_ASSERT(FALSE, ("[BTDBG],  ndbg_SendH2c() can only run under PASSIVE_LEVEL!!\n"));
+		h2cStatus = BT_STATUS_WRONG_LEVEL;
+	}
+
+	RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], ndbg_SendH2c()<=========\n"));
+	return h2cStatus;
+}
+
+
+BT_CTRL_STATUS
+ndbg_BtFwOpCodeProcess(
+	IN	PADAPTER		Adapter,
+	IN	u1Byte			btFwOpCode,
+	IN	u1Byte			opCodeVer,
+	IN	pu1Byte			pH2cPar,
+	IN	u1Byte			h2cParaLen
+	)
+{
+	u1Byte				H2C_Parameter[20] ={0};
+	PBT_H2C				pH2c=(PBT_H2C)&H2C_Parameter[0];
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx=&(Adapter->ndisDbgCtx);
+	u2Byte				paraLen=0;
+	BT_CTRL_STATUS		h2cStatus=BT_STATUS_H2C_SUCCESS, c2hStatus=BT_STATUS_C2H_SUCCESS;
+	BT_CTRL_STATUS		retStatus=BT_STATUS_H2C_BT_NO_RSP;
+
+	pH2c->opCode = btFwOpCode;
+	pH2c->opCodeVer = opCodeVer;
+	pH2c->reqNum = pDbgCtx->h2cReqNum;
+	PlatformMoveMemory(&pH2c->buf[0], pH2cPar, h2cParaLen);
+
+	RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], pH2c->opCode=%d\n", pH2c->opCode));
+	RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], pH2c->opCodeVer=%d\n", pH2c->opCodeVer));
+	RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], pH2c->reqNum=%d\n", pH2c->reqNum));
+	RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], h2c parameter length=%d\n", h2cParaLen));
+	if(h2cParaLen)
+	{
+		RT_DISP_DATA(FBT, BT_DBG_STATE, ("[BTDBG], parameters(hex): \n"), &pH2c->buf[0], h2cParaLen);
+	}
+
+	h2cStatus = ndbg_SendH2c(Adapter, pH2c, h2cParaLen+2);
+	if(BT_STATUS_H2C_SUCCESS == h2cStatus)
+	{
+		// if reach here, it means H2C get the correct c2h response, 
+		c2hStatus = ndbg_CheckC2hFrame(Adapter, pH2c);
+		if(BT_STATUS_C2H_SUCCESS == c2hStatus)
+		{
+			retStatus = ndbg_CheckBtRspStatus(Adapter);
+		}
+		else
+		{
+			RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], Error!! C2H failed for pH2c->opCode=%d\n", pH2c->opCode));
+			// check c2h status error, return error status code to upper layer.
+			retStatus = c2hStatus;
+		}
+	}
+	else
+	{
+		RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], Error!! H2C failed for pH2c->opCode=%d\n", pH2c->opCode));
+		// check h2c status error, return error status code to upper layer.
+		retStatus = h2cStatus;
+	}
+
+	return retStatus;
+}
+
+BT_CTRL_STATUS
+ndbg_BtStackOpCodeProcess(
+	IN	PADAPTER		Adapter,
+	IN	u1Byte			dataLen,
+	IN	PVOID			pData
+	)
+{
+	KIRQL				OldIrql = KeGetCurrentIrql();
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx=&(Adapter->ndisDbgCtx);
+	BT_CTRL_STATUS		retStatus=BT_STATUS_BT_STACK_NO_RSP;
+	PBT_STACK_COEX_INFO	pStackRsp=(PBT_STACK_COEX_INFO)&GLCurBtStackRsp[0];
+
+	PlatformResetEvent(&pDbgCtx->dbgBtCoexEvent);
+
+
+	if(OldIrql == PASSIVE_LEVEL)
+	{
+		if(PlatformWaitEvent(&pDbgCtx->dbgBtCoexEvent, 100))
+		{
+			RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], Received BT Coex Event from stack!!!\n"));
+			retStatus = (BT_CTRL_STATUS)pStackRsp->opStatus;
+		}
+		else
+		{
+			RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], Error!! BT Coex Rsp Event timeout!!\n"));
+			retStatus = BT_STATUS_BT_STACK_NO_RSP;
+		}
+	}
+	else
+		retStatus = BT_STATUS_WRONG_LEVEL;
+		
+	return retStatus;
+}
+
+VOID
+DbgWorkItemCallback(
+	IN PVOID			pContext
+	)
+{
+	PADAPTER				pAdapter = (PADAPTER)pContext;
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+		
+	// Execute specified action.
+	if(pDbgCtx->CurrDbgAct != NULL)
+	{
+#if DBG
+		u8Byte StartTime, EndTime;
+		StartTime = PlatformGetCurrentTime();
+#endif
+
+		pDbgCtx->CurrDbgAct(pAdapter);
+
+#if DBG
+		EndTime = PlatformGetCurrentTime();
+		RT_TRACE(COMP_DBG, DBG_LOUD, 
+			("DbgActType: %d, time spent: %I64d us\n",
+			pDbgCtx->DbgActType, (EndTime-StartTime) )); 
+#endif
+	}
+
+	PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	pDbgCtx->bDbgWorkItemInProgress = FALSE;
+	PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	
+	if(pDbgCtx->bDbgDrvUnload)
+	{
+		PlatformSetEvent( &(pDbgCtx->DbgWorkItemEvent) );
+	}
+}
+
+//-----------------------------------------------------------------------------
+//	Description:
+//		Callback function of a workitem for IO.	
+//
+//-----------------------------------------------------------------------------
+VOID
+DbgIoCallback(
+	IN	PVOID	Context
+	)
+{
+	PADAPTER		pAdapter = (PADAPTER)Context;
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	PRT_SDIO_DEVICE pDevice = GET_RT_SDIO_DEVICE(pAdapter);
+
+	RT_ASSERT((KeGetCurrentIrql() == PASSIVE_LEVEL), 
+		("DbgIoCallback(): not in PASSIVE_LEVEL!\n"));
+
+	switch(pDbgCtx->DbgActType)
+	{
+	//
+	// <Roger_Notes> The following IO items are for RTL8192SU purpose.
+	// These are just instead of CMD I/O case to compatible Command Line Utility.
+	// 2008.09.02.
+	//
+	case DBG_WRITE_MAC_1BYTE:
+		if( IS_BB_REG_OFFSET_92S(pDbgCtx->DbgIoOffset) )
+		{
+			ULONG mod_val=0;
+			mod_val = pDbgCtx->DbgIoOffset%4;
+			if(mod_val)
+				pDbgCtx->DbgIoOffset -= mod_val;
+			PHY_SetBBReg(pAdapter, pDbgCtx->DbgIoOffset, (u4Byte)(bMaskByte0<<(8*mod_val)), pDbgCtx->DbgIoValue);
+		}
+		else
+		{
+			if(pDevice->SdioRegDbgCtrl & SDIO_REG_CTRL_LOCAL)
+			{// Local REG
+				if(pDevice->SdioRegDbgCtrl & SDIO_REG_CTRL_CMD52)
+					PlatformEFSdioLocalCmd52Write1Byte(pAdapter, pDbgCtx->DbgIoOffset, (u1Byte)(pDbgCtx->DbgIoValue));
+				else
+					PlatformEFSdioLocalCmd53Write1Byte(pAdapter, pDbgCtx->DbgIoOffset, (u1Byte)(pDbgCtx->DbgIoValue));
+			}
+			else
+			{ // IO REG
+				if(pDevice->SdioRegDbgCtrl & SDIO_REG_CTRL_CMD52)
+					PlatformEFSdioCmd52Write1Byte(pAdapter, WLAN_IOREG_DEVICE_ID, 1, pDbgCtx->DbgIoOffset, (u1Byte)(pDbgCtx->DbgIoValue));
+				else
+					PlatformEFIOWrite1Byte(pAdapter, pDbgCtx->DbgIoOffset, (u1Byte)(pDbgCtx->DbgIoValue));
+			}
+		}
+		break;
+
+	case DBG_WRITE_MAC_2BYTE:
+		if( IS_BB_REG_OFFSET_92S(pDbgCtx->DbgIoOffset) )
+		{
+			ULONG mod_val=0;
+			mod_val = pDbgCtx->DbgIoOffset%4;
+			if(mod_val)
+				pDbgCtx->DbgIoOffset -= mod_val;
+			PHY_SetBBReg(pAdapter, pDbgCtx->DbgIoOffset, (bMaskLWord<<(8*mod_val)), pDbgCtx->DbgIoValue);
+		}
+		else
+		{
+			if(pDevice->SdioRegDbgCtrl & SDIO_REG_CTRL_LOCAL)
+			{// Local REG
+				if(pDevice->SdioRegDbgCtrl & SDIO_REG_CTRL_CMD52)
+					PlatformEFSdioLocalCmd52Write2Byte(pAdapter, pDbgCtx->DbgIoOffset, (u2Byte)(pDbgCtx->DbgIoValue));
+				else
+					PlatformEFSdioLocalCmd53Write2Byte(pAdapter, pDbgCtx->DbgIoOffset, (u2Byte)(pDbgCtx->DbgIoValue));
+			}
+			else
+			{ // IO REG
+				if(pDevice->SdioRegDbgCtrl & SDIO_REG_CTRL_CMD52)
+					PlatformEFSdioCmd52Write2Byte(pAdapter, WLAN_IOREG_DEVICE_ID, 1, pDbgCtx->DbgIoOffset, (u2Byte)(pDbgCtx->DbgIoValue));
+				else
+					PlatformEFIOWrite2Byte(pAdapter, pDbgCtx->DbgIoOffset, (u2Byte)(pDbgCtx->DbgIoValue));
+			}
+		}
+		break;
+
+	case DBG_WRITE_MAC_4BYTE:
+		if( IS_BB_REG_OFFSET_92S(pDbgCtx->DbgIoOffset) )
+			PHY_SetBBReg(pAdapter, pDbgCtx->DbgIoOffset, bMaskDWord, pDbgCtx->DbgIoValue);
+		else
+		{
+			if(pDevice->SdioRegDbgCtrl & SDIO_REG_CTRL_LOCAL)
+			{// Local REG
+				if(pDevice->SdioRegDbgCtrl & SDIO_REG_CTRL_CMD52)
+					PlatformEFSdioLocalCmd52Write4Byte(pAdapter, pDbgCtx->DbgIoOffset, (u4Byte)(pDbgCtx->DbgIoValue));
+				else
+					PlatformEFSdioLocalCmd53Write4Byte(pAdapter, pDbgCtx->DbgIoOffset, (u4Byte)(pDbgCtx->DbgIoValue));
+			}
+			else
+			{ // IO REG
+				if(pDevice->SdioRegDbgCtrl & SDIO_REG_CTRL_CMD52)
+					PlatformEFSdioCmd52Write4Byte(pAdapter, WLAN_IOREG_DEVICE_ID, 1, pDbgCtx->DbgIoOffset, (u4Byte)(pDbgCtx->DbgIoValue));		
+				else
+					PlatformEFIOWrite4Byte(pAdapter, pDbgCtx->DbgIoOffset, (u4Byte)(pDbgCtx->DbgIoValue));
+			}
+		}
+		break;
+	
+	case DBG_READ_MAC_1BYTE:
+		if( IS_BB_REG_OFFSET_92S(pDbgCtx->DbgIoOffset) )
+		{
+			ULONG mod_val=0;
+			mod_val = pDbgCtx->DbgIoOffset%4;
+			if(mod_val)
+				pDbgCtx->DbgIoOffset -= mod_val;
+			pDbgCtx->DbgIoValue = PHY_QueryBBReg(pAdapter, pDbgCtx->DbgIoOffset, bMaskDWord);
+			pDbgCtx->DbgIoValue &= (bMaskByte0<<(8*mod_val));
+			pDbgCtx->DbgIoValue = (pDbgCtx->DbgIoValue>>(8*mod_val));
+		}
+		else
+		{
+			if(pDevice->SdioRegDbgCtrl & SDIO_REG_CTRL_LOCAL)
+			{// Local REG
+				if(pDevice->SdioRegDbgCtrl & SDIO_REG_CTRL_CMD52)
+					pDbgCtx->DbgIoValue = PlatformEFSdioLocalCmd52Read1Byte(pAdapter, pDbgCtx->DbgIoOffset);
+				else
+					pDbgCtx->DbgIoValue = PlatformEFSdioLocalCmd53Read1Byte(pAdapter, pDbgCtx->DbgIoOffset);
+			}
+			else
+			{ // IO REG
+				if(pDevice->SdioRegDbgCtrl & SDIO_REG_CTRL_CMD52)
+					pDbgCtx->DbgIoValue = PlatformEFSdioCmd52Read1Byte(pAdapter,  WLAN_IOREG_DEVICE_ID, 1,pDbgCtx->DbgIoOffset);		
+				else
+					pDbgCtx->DbgIoValue = PlatformEFIORead1Byte(pAdapter, pDbgCtx->DbgIoOffset);
+			}
+		}
+		break;
+
+	case DBG_READ_MAC_2BYTE:
+		if( IS_BB_REG_OFFSET_92S(pDbgCtx->DbgIoOffset) )
+		{
+			ULONG mod_val=0;
+			mod_val = pDbgCtx->DbgIoOffset%4;
+			if(mod_val)
+				pDbgCtx->DbgIoOffset -= mod_val;
+			pDbgCtx->DbgIoValue = PHY_QueryBBReg(pAdapter, pDbgCtx->DbgIoOffset, bMaskDWord);
+			pDbgCtx->DbgIoValue &= (bMaskLWord<<(8*mod_val));
+			pDbgCtx->DbgIoValue = (pDbgCtx->DbgIoValue>>(8*mod_val));
+		}
+		else
+		{
+			if(pDevice->SdioRegDbgCtrl & SDIO_REG_CTRL_LOCAL)
+			{// Local REG
+				if(pDevice->SdioRegDbgCtrl & SDIO_REG_CTRL_CMD52)
+					pDbgCtx->DbgIoValue = PlatformEFSdioLocalCmd52Read2Byte(pAdapter, pDbgCtx->DbgIoOffset);
+				else
+					pDbgCtx->DbgIoValue = PlatformEFSdioLocalCmd53Read2Byte(pAdapter, pDbgCtx->DbgIoOffset);
+			}
+			else
+			{ // IO REG
+				if(pDevice->SdioRegDbgCtrl & SDIO_REG_CTRL_CMD52)
+					pDbgCtx->DbgIoValue = PlatformEFSdioCmd52Read2Byte(pAdapter,  WLAN_IOREG_DEVICE_ID, 1,pDbgCtx->DbgIoOffset);		
+				else
+					pDbgCtx->DbgIoValue = PlatformEFIORead2Byte(pAdapter, pDbgCtx->DbgIoOffset);
+			}
+		}
+		break;
+
+	case DBG_READ_MAC_4BYTE:
+		if( IS_BB_REG_OFFSET_92S(pDbgCtx->DbgIoOffset) )
+			pDbgCtx->DbgIoValue = PHY_QueryBBReg(pAdapter, pDbgCtx->DbgIoOffset, bMaskDWord);
+		else
+		{
+			if(pDevice->SdioRegDbgCtrl & SDIO_REG_CTRL_LOCAL)
+			{// Local REG
+				if(pDevice->SdioRegDbgCtrl & SDIO_REG_CTRL_CMD52)
+					pDbgCtx->DbgIoValue = PlatformEFSdioLocalCmd52Read4Byte(pAdapter, pDbgCtx->DbgIoOffset);
+				else
+					pDbgCtx->DbgIoValue = PlatformEFSdioLocalCmd53Read4Byte(pAdapter, pDbgCtx->DbgIoOffset);
+			}
+			else
+			{ // IO REG
+				if(pDevice->SdioRegDbgCtrl & SDIO_REG_CTRL_CMD52)
+					pDbgCtx->DbgIoValue = PlatformEFSdioCmd52Read4Byte(pAdapter,  WLAN_IOREG_DEVICE_ID, 1,pDbgCtx->DbgIoOffset);		
+				else
+					pDbgCtx->DbgIoValue = PlatformEFIORead4Byte(pAdapter, pDbgCtx->DbgIoOffset);
+			}
+		}
+		break;
+
+	case DBG_READ_BB_OFDM:
+	case DBG_READ_BB_CCK:
+		pDbgCtx->DbgIoValue = PHY_QueryBBReg(pAdapter, pDbgCtx->DbgIoOffset, bMaskDWord);
+		break;
+
+	case DBG_WRITE_BB_OFDM:
+	case DBG_WRITE_BB_CCK:
+		PHY_SetBBReg(pAdapter, pDbgCtx->DbgIoOffset, bMaskDWord, pDbgCtx->DbgIoValue);
+		break;
+
+	case DBG_READ_RF:	
+		pDbgCtx->DbgIoValue = PHY_QueryRFReg(pAdapter, (u1Byte)pDbgCtx->DbgRfPath, pDbgCtx->DbgIoOffset, bRFRegOffsetMask);
+		break;
+
+	case DBG_WRITE_RF:
+		PHY_SetRFReg(pAdapter,  (u1Byte)pDbgCtx->DbgRfPath, pDbgCtx->DbgIoOffset, bRFRegOffsetMask, pDbgCtx->DbgIoValue);
+		break;
+
+	case DBG_READ_EEPROM_1BYTE:
+		pDbgCtx->DbgIoValue = ReadEEprom( pAdapter, (u2Byte)(pDbgCtx->DbgIoOffset>>1) );
+		if(pDbgCtx->DbgIoOffset % 2 == 1)
+		{
+			pDbgCtx->DbgIoValue >>= 8;
+		}
+		pDbgCtx->DbgIoValue &= 0xff;
+		break;
+
+	case DBG_READ_EEPROM_2BYTE:
+		pDbgCtx->DbgIoValue = ReadEEprom( pAdapter, (u2Byte)(pDbgCtx->DbgIoOffset>>1) );
+		pDbgCtx->DbgIoValue &= 0xffff;
+		break;
+
+	case DBG_WRITE_EEPROM_1BYTE:
+		{
+			USHORT usTmp = 0;
+
+			usTmp = ReadEEprom( pAdapter, (u2Byte)(pDbgCtx->DbgIoOffset>>1) );
+			if(pDbgCtx->DbgIoOffset % 2 == 1)
+			{
+				usTmp &= 0x00ff; // Clear high byte of the word.
+				usTmp |= (pDbgCtx->DbgIoValue << 8);
+			}
+			else
+			{
+				usTmp &= 0xff00; // Clear low byte of the word.
+				usTmp |= (pDbgCtx->DbgIoValue);
+			}
+			WriteEEprom(pAdapter, (u1Byte)(pDbgCtx->DbgIoOffset>>1), usTmp);
+		}
+		break;
+
+	case DBG_WRITE_EEPROM_2BYTE:
+		WriteEEprom(pAdapter, (u1Byte)(pDbgCtx->DbgIoOffset>>1), (u2Byte)(pDbgCtx->DbgIoValue&0xffff));
+		break;
+
+#if 0
+	case DBG_OUT_CMD:
+		{
+			u4Byte	BufferLengthRead;
+			u1Byte	i=0;
+			
+			PlatformUsbSyncVendorRequest(
+					pAdapter, 
+					TRUE, 	// bWrite
+					0x05, 	// bReq
+					0, 		// wValue
+					0x8051, // wIndex
+					(pu1Byte)&(pDbgCtx->DbgIoBuf),  // pBuffer
+					pDbgCtx->DbgIoValue,   // BufferLength
+					&BufferLengthRead          // pBufferLengthRead
+					);
+		}
+		break;
+#endif
+
+	case DBG_WRITE_EFUSE_1BYTE:
+		EFUSE_ShadowWrite(pAdapter, 1, (u2Byte)pDbgCtx->DbgIoOffset, (UINT32)pDbgCtx->DbgIoValue);
+		break;
+
+	case DBG_READ_EFUSE_1BYTE:
+		EFUSE_MaskedShadowRead(pAdapter, 1, (u2Byte)(pDbgCtx->DbgIoOffset), (UINT32 *)&pDbgCtx->DbgIoValue);
+		break;
+
+	case DBG_READ_EFUSE_2BYTE:
+		EFUSE_MaskedShadowRead(pAdapter, 2, (u2Byte)(pDbgCtx->DbgIoOffset), (UINT32 *)&pDbgCtx->DbgIoValue);
+		break;
+
+	case DBG_READ_EFUSE_4BYTE:
+		EFUSE_MaskedShadowRead(pAdapter, 4, (u2Byte)(pDbgCtx->DbgIoOffset), (UINT32 *)&pDbgCtx->DbgIoValue);
+		break;
+		
+	case DBG_UPDATE_EFUSE:
+		pDbgCtx->DbgIoValue = EFUSE_ShadowUpdate(pAdapter, FALSE);	
+		break;	
+
+	case DBG_WRITE_BT_EFUSE_1BYTE:
+		EFUSE_ShadowWriteBT(pAdapter, 1, (u2Byte)pDbgCtx->DbgIoOffset, (UINT32)pDbgCtx->DbgIoValue);
+		break;
+
+	case DBG_READ_BT_EFUSE_1BYTE:
+		EFUSE_ShadowReadBT(pAdapter, 1, (u2Byte)(pDbgCtx->DbgIoOffset), (UINT32 *)&pDbgCtx->DbgIoValue);
+		break;
+
+	case DBG_READ_BT_EFUSE_2BYTE:
+		EFUSE_ShadowReadBT(pAdapter, 2, (u2Byte)(pDbgCtx->DbgIoOffset), (UINT32 *)&pDbgCtx->DbgIoValue);
+		break;
+
+	case DBG_READ_BT_EFUSE_4BYTE:
+		EFUSE_ShadowReadBT(pAdapter, 4, (u2Byte)(pDbgCtx->DbgIoOffset), (UINT32 *)&pDbgCtx->DbgIoValue);
+		break;
+		
+	case DBG_UPDATE_BT_EFUSE:
+		pDbgCtx->DbgIoValue = EFUSE_ShadowUpdateBT(pAdapter, FALSE);
+		break;	
+
+	case DBG_SWITCH_ANTENNA:
+		pAdapter->HalFunc.SetTxAntennaHandler(pAdapter, (u1Byte)pDbgCtx->DbgIoValue);
+		break;
+
+	case DBG_SET_TXPWR_FOR_ALL_RATE:
+		HAL_SetTxPowerForAllRate(pAdapter, pDbgCtx->DbgIoValue);
+		break;
+		
+	default:
+		break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+//	Description:
+//		Initialize debugging realted information or resource.
+//		It should be called in context of MiniportInitialize().
+//
+//-----------------------------------------------------------------------------
+VOID
+NDBG_Init(
+	IN	PADAPTER pAdapter
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx=&(pAdapter->ndisDbgCtx);
+
+	RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], NDBG_Init()\n"));
+
+	pDbgCtx->bDbgDrvUnload = FALSE;
+	
+	PlatformInitializeEvent(&(pDbgCtx->DbgWorkItemEvent));
+	PlatformInitializeEvent(&pDbgCtx->dbgH2cRspEvent);
+	PlatformInitializeEvent(&pDbgCtx->dbgBtC2hEvent);
+	PlatformInitializeEvent(&pDbgCtx->dbgBtCoexEvent);
+	PlatformInitializeSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	PlatformInitializeWorkItem(
+		pAdapter,
+		&(pDbgCtx->DbgWorkItem), 
+		(RT_WORKITEM_CALL_BACK)DbgWorkItemCallback,
+		(PVOID)pAdapter,
+		"DbgWorkItem");
+
+	pDbgCtx->bDbgWorkItemInProgress = FALSE;
+	pDbgCtx->CurrDbgAct = NULL;
+}
+
+//-----------------------------------------------------------------------------
+//	Description:
+//		DeInitialize for debugging realted resource.
+//		It should be called in context of MiniportHalt().
+//
+//-----------------------------------------------------------------------------
+VOID
+NDBG_Halt(
+	IN	PADAPTER pAdapter
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], NDBG_Halt()\n"));
+
+	pDbgCtx->bDbgDrvUnload = TRUE;
+
+	PlatformFreeWorkItem( &(pDbgCtx->DbgWorkItem) );
+
+	if(pDbgCtx->bDbgWorkItemInProgress)
+	{
+		PlatformWaitEvent(&(pDbgCtx->DbgWorkItemEvent), 2000);
+	}
+	
+	PlatformFreeSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+}
+
+//-----------------------------------------------------------------------------
+//	Description:
+//		Read MAC register.	
+//		
+//-----------------------------------------------------------------------------
+BOOLEAN
+DbgReadMacReg(
+	IN	PADAPTER			Adapter,
+	IN	ULONG				ulRegOffset,
+	IN	ULONG				ulRegDataWidth
+	)
+{
+	PADAPTER				pAdapter;
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx;
+	BOOLEAN bResult = TRUE;
+	ULONG	ulIoType;
+
+	if(Adapter->bSWInitReady)
+		pAdapter=GetDefaultAdapter(Adapter);
+	else
+		pAdapter=Adapter;
+	
+	pDbgCtx = &(pAdapter->ndisDbgCtx);
+
+	switch(ulRegDataWidth)
+	{
+	case 1:
+		ulIoType = DBG_READ_MAC_1BYTE;
+		break;
+
+	case 2:
+		ulIoType = DBG_READ_MAC_2BYTE;
+		break;
+
+	case 4:
+		ulIoType = DBG_READ_MAC_4BYTE;
+		break;
+
+	default:
+		bResult = FALSE;
+		break;
+	}
+
+	if(bResult == TRUE)
+	{
+		// Perform IO via workitem.
+		PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+		if(pDbgCtx->bDbgWorkItemInProgress)
+		{
+			RT_ASSERT(FALSE, 
+				("DbgWorkItem is in progress!, skip DbgReadMacReg(), IoType: %d.\n", ulIoType));
+			bResult = FALSE;
+		}
+		else
+		{
+			pDbgCtx->DbgIoOffset = ulRegOffset;
+			pDbgCtx->DbgIoValue = 0xffffffff;
+
+			pDbgCtx->bDbgWorkItemInProgress = TRUE;
+			pDbgCtx->DbgActType = ulIoType;
+			pDbgCtx->CurrDbgAct = DbgIoCallback;
+
+			PlatformScheduleWorkItem( &(pDbgCtx->DbgWorkItem) );
+		}
+		PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	}
+
+	return bResult;
+}
+
+//-----------------------------------------------------------------------------
+//	Description:
+//		Write MAC register.	
+//		
+//-----------------------------------------------------------------------------
+BOOLEAN
+DbgWriteMacReg(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulRegDataWidth,
+	IN	ULONG		ulRegValue
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	BOOLEAN bResult = TRUE;
+	ULONG	ulIoType;
+
+	switch(ulRegDataWidth)
+	{
+	case 1:
+		ulIoType = DBG_WRITE_MAC_1BYTE;
+		break;
+
+	case 2:
+		ulIoType = DBG_WRITE_MAC_2BYTE;
+		break;
+
+	case 4:
+		ulIoType = DBG_WRITE_MAC_4BYTE;
+		break;
+
+	default:
+		bResult = FALSE;
+		break;
+	}
+
+	if(bResult == TRUE)
+	{
+		// Perform IO via workitem.
+		PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+		if(pDbgCtx->bDbgWorkItemInProgress)
+		{
+			RT_ASSERT(FALSE, 
+				("DbgWorkItem is in progress!, skip DbgWriteMacReg(), IoType: %d.\n", ulIoType));
+			bResult = FALSE;
+		}
+		else
+		{
+			pDbgCtx->DbgIoOffset = ulRegOffset;
+			pDbgCtx->DbgIoValue = ulRegValue;
+
+			pDbgCtx->bDbgWorkItemInProgress = TRUE;
+			pDbgCtx->DbgActType = ulIoType;
+			pDbgCtx->CurrDbgAct = DbgIoCallback;
+
+			PlatformScheduleWorkItem( &(pDbgCtx->DbgWorkItem) );
+		}
+		PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	}
+
+	return bResult;
+}
+
+//-----------------------------------------------------------------------------
+//	Description:
+//		Read BB register.	
+//		
+//-----------------------------------------------------------------------------
+BOOLEAN
+DbgReadBbReg(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulBeOFDM
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	BOOLEAN bResult = TRUE;
+	ULONG	ulIoType;
+
+	if(ulBeOFDM == 1)
+	{
+		ulIoType = DBG_READ_BB_OFDM;
+	}
+	else
+	{
+		ulIoType = DBG_READ_BB_CCK;
+	}
+
+	if(bResult == TRUE)
+	{
+		// Perform IO via workitem.
+		PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+		if(pDbgCtx->bDbgWorkItemInProgress)
+		{
+			RT_ASSERT(FALSE, 
+				("DbgWorkItem is in progress!, skip DbgReadBbReg(), IoType: %d.\n", ulIoType));
+			bResult = FALSE;
+		}
+		else
+		{
+			pDbgCtx->DbgIoOffset = ulRegOffset;
+			pDbgCtx->DbgIoValue = 0xffffffff;
+
+			pDbgCtx->bDbgWorkItemInProgress = TRUE;
+			pDbgCtx->DbgActType = ulIoType;
+			pDbgCtx->CurrDbgAct = DbgIoCallback;
+
+			PlatformScheduleWorkItem( &(pDbgCtx->DbgWorkItem) );
+		}
+		PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	}
+
+	return bResult;
+}
+
+//-----------------------------------------------------------------------------
+//	Description:
+//		Write BB register.	
+//		
+//-----------------------------------------------------------------------------
+BOOLEAN
+DbgWriteBbReg(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulBeOFDM,
+	IN	ULONG		ulRegValue
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	BOOLEAN bResult = TRUE;
+	ULONG	ulIoType;
+
+	if(ulBeOFDM == 1)
+	{
+		ulIoType = DBG_WRITE_BB_OFDM;
+	}
+	else
+	{
+		ulIoType = DBG_WRITE_BB_CCK;
+	}
+
+	if(bResult == TRUE)
+	{
+		// Perform IO via workitem.
+		PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+		if(pDbgCtx->bDbgWorkItemInProgress)
+		{
+			RT_ASSERT(FALSE, 
+				("DbgWorkItem is in progress!, skip DbgWriteBbReg(), IoType: %d.\n", ulIoType));
+			bResult = FALSE;
+		}
+		else
+		{
+			pDbgCtx->DbgIoOffset = ulRegOffset;
+			pDbgCtx->DbgIoValue = ulRegValue;
+
+			pDbgCtx->bDbgWorkItemInProgress = TRUE;
+			pDbgCtx->DbgActType = ulIoType;
+			pDbgCtx->CurrDbgAct = DbgIoCallback;
+
+			PlatformScheduleWorkItem( &(pDbgCtx->DbgWorkItem) );
+		}
+		PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	}
+
+	return bResult;
+}
+
+//-----------------------------------------------------------------------------
+//	Description:
+//		Read RF register.	
+//		
+//-----------------------------------------------------------------------------
+BOOLEAN
+DbgReadRfReg(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulRegDataWidth
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	BOOLEAN bResult = TRUE;
+	ULONG	ulIoType;
+	ULONG	RF_PATH=0, INulRegOffset=0;
+
+	ulIoType = DBG_READ_RF; 
+	RF_PATH = (ulRegDataWidth >> 4); // Get RF path
+	INulRegOffset = ulRegOffset & 0x0fff;
+
+	if(bResult == TRUE)
+	{
+		// Perform IO via workitem.
+		PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+		if(pDbgCtx->bDbgWorkItemInProgress)
+		{
+			RT_ASSERT(FALSE, 
+				("DbgWorkItem is in progress!, skip DbgReadRfReg(), IoType: %d.\n", ulIoType));
+			bResult = FALSE;
+		}
+		else
+		{
+			pDbgCtx->DbgIoOffset = ulRegOffset;
+			pDbgCtx->DbgIoValue = 0xffffffff;
+			pDbgCtx->DbgRfPath = RF_PATH;
+
+			pDbgCtx->bDbgWorkItemInProgress = TRUE;
+			pDbgCtx->DbgActType = ulIoType;
+			pDbgCtx->CurrDbgAct = DbgIoCallback;
+			
+			PlatformScheduleWorkItem( &(pDbgCtx->DbgWorkItem) );
+		}
+		PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	}
+
+	return bResult;
+}
+
+//-----------------------------------------------------------------------------
+//	Description:
+//		Write RF register.	
+//		
+//-----------------------------------------------------------------------------
+BOOLEAN
+DbgWriteRfReg(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulRegDataWidth,
+	IN	ULONG		ulRegValue
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	BOOLEAN bResult = TRUE;
+	ULONG	ulIoType, RF_PATH, INulRegOffset, INulRegValue;
+
+	ulIoType = DBG_WRITE_RF;
+	RF_PATH  = (ulRegOffset >> 12);
+	INulRegOffset = ulRegOffset & 0xfff;	//[11:0]
+	INulRegValue = ulRegValue & bRFRegOffsetMask;
+
+
+	if(bResult == TRUE)
+	{
+		// Perform IO via workitem.
+		PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+		if(pDbgCtx->bDbgWorkItemInProgress)
+		{
+			RT_ASSERT(FALSE, 
+				("DbgWorkItem is in progress!, skip DbgWriteRfReg(), IoType: %d.\n", ulIoType));
+			bResult = FALSE;
+		}
+		else
+		{
+			pDbgCtx->DbgIoOffset = INulRegOffset;
+			pDbgCtx->DbgIoValue = INulRegValue;
+			pDbgCtx->DbgRfPath = RF_PATH;
+
+
+			pDbgCtx->bDbgWorkItemInProgress = TRUE;
+			pDbgCtx->DbgActType = ulIoType;
+			pDbgCtx->CurrDbgAct = DbgIoCallback;
+
+			PlatformScheduleWorkItem( &(pDbgCtx->DbgWorkItem) );
+		}
+		PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	}
+
+	return bResult;
+}
+
+//-----------------------------------------------------------------------------
+//	Description:
+//		Read EEPROM for OID_RT_PRO_READ_EEPROM.	
+//		
+//-----------------------------------------------------------------------------
+BOOLEAN
+DbgReadEeprom(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulRegDataWidth
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	BOOLEAN 		bResult = TRUE;
+	ULONG			ulIoType;
+
+	switch(ulRegDataWidth)
+	{
+	case 1:
+		ulIoType = DBG_READ_EEPROM_1BYTE;
+		break;
+
+	case 2:
+		ulIoType = DBG_READ_EEPROM_2BYTE;
+		break;
+
+	default:
+		bResult = FALSE;
+		break;
+	}
+
+	if(bResult == TRUE)
+	{
+		// Perform IO via workitem.
+		PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+		if(pDbgCtx->bDbgWorkItemInProgress)
+		{
+			RT_ASSERT(FALSE,
+				("DbgWorkItem is in progress!, skip DbgReadEeprom(), IoType: %d.\n", ulIoType));
+			bResult = FALSE;
+		}
+		else
+		{
+			pDbgCtx->DbgIoOffset = ulRegOffset;
+			pDbgCtx->DbgIoValue = 0xffffffff;
+
+			pDbgCtx->bDbgWorkItemInProgress = TRUE;
+			pDbgCtx->DbgActType = ulIoType;
+			pDbgCtx->CurrDbgAct = DbgIoCallback;
+
+			PlatformScheduleWorkItem( &(pDbgCtx->DbgWorkItem) );
+		}
+		PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	}
+
+	return bResult;
+}
+
+
+//-----------------------------------------------------------------------------
+//	Description:
+//		Write EEPROM for OID_RT_PRO_WRITE_EEPROM.
+//		
+//-----------------------------------------------------------------------------
+BOOLEAN
+DbgWriteEeprom(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulRegDataWidth,
+	IN	ULONG		ulRegValue
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	BOOLEAN 		bResult = TRUE;
+	ULONG			ulIoType;
+
+	switch(ulRegDataWidth)
+	{
+	case 1:
+		ulIoType = DBG_WRITE_EEPROM_1BYTE;
+		break;
+
+	case 2:
+		ulIoType = DBG_WRITE_EEPROM_2BYTE;
+		break;
+
+	default:
+		bResult = FALSE;
+		break;
+	}
+
+	if(bResult == TRUE)
+	{
+		// Perform IO via workitem.
+		PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+		if(pDbgCtx->bDbgWorkItemInProgress)
+		{
+			RT_ASSERT(FALSE, 
+				("DbgWorkItem is in progress!, skip Pro8187IoCallback(), IoType: %d.\n", ulIoType));
+			bResult = FALSE;
+		}
+		else
+		{
+			pDbgCtx->DbgIoOffset = ulRegOffset;
+			pDbgCtx->DbgIoValue = ulRegValue;
+
+			pDbgCtx->bDbgWorkItemInProgress = TRUE;
+			pDbgCtx->DbgActType = ulIoType;
+			pDbgCtx->CurrDbgAct = DbgIoCallback;
+
+			PlatformScheduleWorkItem( &(pDbgCtx->DbgWorkItem) );
+		}
+		PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	}
+
+	return bResult;
+}
+
+
+//-----------------------------------------------------------------------------
+//	Description:
+//		87S-USB Out Command.
+//		
+//-----------------------------------------------------------------------------
+BOOLEAN
+DbgOutCmd(
+	IN	PADAPTER		pAdapter,
+	IN	PUCHAR			ulOutCmd,
+	IN	ULONG			ulOutCmdWidth
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	BOOLEAN 		bResult = TRUE;
+	ULONG			ulIoType;
+	ULONG i=0;
+
+	ulIoType = DBG_OUT_CMD; 
+
+	// Perform IO via workitem.
+	PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	if(pDbgCtx->bDbgWorkItemInProgress)
+	{
+		RT_ASSERT(FALSE, 
+			("DbgWorkItem is in progress!, skip Pro8187IoCallback(), IoType: %d.\n", ulIoType));
+		bResult = FALSE;
+	}
+	else
+	{
+		PlatformZeroMemory(&pDbgCtx->DbgIoBuf, 64);
+		pDbgCtx->DbgIoOffset = 0;
+		
+		pDbgCtx->DbgIoValue = ulOutCmdWidth; //use DbgIoValue to indicate OutCmd length
+		PlatformMoveMemory(&pDbgCtx->DbgIoBuf, ulOutCmd, ulOutCmdWidth);
+
+		pDbgCtx->bDbgWorkItemInProgress = TRUE;
+		pDbgCtx->DbgActType = ulIoType;
+		pDbgCtx->CurrDbgAct = DbgIoCallback;
+		PlatformScheduleWorkItem( &(pDbgCtx->DbgWorkItem) );
+	}
+	PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+
+	return bResult;
+}
+
+//-----------------------------------------------------------------------------
+//	Description:
+//		Read EEPROM for OID_RT_PRO_READ_EFUSE.	
+//	Added by Roger, 2008.11.10.
+//		
+//-----------------------------------------------------------------------------
+BOOLEAN
+DbgReadEFuse(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulRegDataWidth
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	BOOLEAN 		bResult = TRUE;
+	ULONG			ulIoType;
+
+	switch(ulRegDataWidth)
+	{
+	case 1:
+		ulIoType = DBG_READ_EFUSE_1BYTE;
+		break;
+
+	case 2:
+		ulIoType = DBG_READ_EFUSE_2BYTE;
+		break;
+
+	case 4:
+		ulIoType = DBG_READ_EFUSE_4BYTE;
+		break;
+
+	default:
+		bResult = FALSE;
+		break;
+	}
+
+	if(bResult == TRUE)
+	{
+		// Perform IO via workitem.
+		PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+		if(pDbgCtx->bDbgWorkItemInProgress)
+		{
+			RT_ASSERT(FALSE,
+				("DbgWorkItem is in progress!, skip DbgReadEeprom(), IoType: %d.\n", ulIoType));
+			bResult = FALSE;
+		}
+		else
+		{
+			pDbgCtx->DbgIoOffset = ulRegOffset;
+			pDbgCtx->DbgIoValue = 0xffffffff;
+
+			pDbgCtx->bDbgWorkItemInProgress = TRUE;
+			pDbgCtx->DbgActType = ulIoType;
+			pDbgCtx->CurrDbgAct = DbgIoCallback;
+
+			PlatformScheduleWorkItem( &(pDbgCtx->DbgWorkItem) );
+		}
+		PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	}
+
+	return bResult;
+}
+
+
+//-----------------------------------------------------------------------------
+//	Description:
+//		Write EEPROM for OID_RT_PRO_WRITE_EFUSE.
+//	Added by Roger, 2008.11.10.
+//		
+//-----------------------------------------------------------------------------
+BOOLEAN
+DbgWriteEFuse(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulRegDataWidth,
+	IN	ULONG		ulRegValue
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	BOOLEAN 		bResult = TRUE;
+	ULONG			ulIoType;
+
+	switch(ulRegDataWidth)
+	{
+	case 1:
+		ulIoType = DBG_WRITE_EFUSE_1BYTE;
+		break;	
+
+	default:
+		bResult = FALSE;
+		break;
+	}
+
+	if(bResult == TRUE)
+	{
+		// Perform IO via workitem.
+		PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+		if(pDbgCtx->bDbgWorkItemInProgress)
+		{
+			RT_ASSERT(FALSE, 
+				("DbgWorkItem is in progress!, skip Pro8187IoCallback(), IoType: %d.\n", ulIoType));
+			bResult = FALSE;
+		}
+		else
+		{
+			pDbgCtx->DbgIoOffset = ulRegOffset;
+			pDbgCtx->DbgIoValue = ulRegValue;
+
+			pDbgCtx->bDbgWorkItemInProgress = TRUE;
+			pDbgCtx->DbgActType = ulIoType;
+			pDbgCtx->CurrDbgAct = DbgIoCallback;
+
+			PlatformScheduleWorkItem( &(pDbgCtx->DbgWorkItem) );
+		}
+		PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	}
+
+	return bResult;
+}
+//-----------------------------------------------------------------------------
+//	Description:
+//		Write EEPROM for OID_RT_PRO_WRITE_EFUSE.
+//	Added by Roger, 2008.11.10.
+//		
+//-----------------------------------------------------------------------------
+BOOLEAN
+DbgUpdateEFuse(
+	IN	PADAPTER	pAdapter	
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	BOOLEAN 		bResult = TRUE;
+	ULONG			ulIoType;
+	
+	ulIoType = DBG_UPDATE_EFUSE;	
+
+	if(bResult == TRUE)
+	{
+		// Perform IO via workitem.
+		PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+		if(pDbgCtx->bDbgWorkItemInProgress)
+		{
+			RT_ASSERT(FALSE, 
+				("DbgWorkItem is in progress!, skip Pro8187IoCallback(), IoType: %d.\n", ulIoType));
+			bResult = FALSE;
+		}
+		else
+		{
+			pDbgCtx->bDbgWorkItemInProgress = TRUE;
+			pDbgCtx->DbgActType = ulIoType;
+			pDbgCtx->CurrDbgAct = DbgIoCallback;
+			PlatformScheduleWorkItem( &(pDbgCtx->DbgWorkItem) );
+		}
+		PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	}
+
+	return bResult;
+}
+
+BOOLEAN
+DbgReadBTEFuse(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulRegDataWidth
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	BOOLEAN 		bResult = TRUE;
+	ULONG			ulIoType;
+
+	switch(ulRegDataWidth)
+	{
+	case 1:
+		ulIoType = DBG_READ_BT_EFUSE_1BYTE;
+		break;
+
+	case 2:
+		ulIoType = DBG_READ_BT_EFUSE_2BYTE;
+		break;
+
+	case 4:
+		ulIoType = DBG_READ_BT_EFUSE_4BYTE;
+		break;
+
+	default:
+		bResult = FALSE;
+		break;
+	}
+
+	if(bResult == TRUE)
+	{
+		// Perform IO via workitem.
+		PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+		if(pDbgCtx->bDbgWorkItemInProgress)
+		{
+			RT_ASSERT(FALSE,
+				("DbgWorkItem is in progress!, skip DbgReadBTEFuse(), IoType: %d.\n", ulIoType));
+			bResult = FALSE;
+		}
+		else
+		{
+			pDbgCtx->DbgIoOffset = ulRegOffset;
+			pDbgCtx->DbgIoValue = 0xffffffff;
+
+			pDbgCtx->bDbgWorkItemInProgress = TRUE;
+			pDbgCtx->DbgActType = ulIoType;
+			pDbgCtx->CurrDbgAct = DbgIoCallback;
+
+			PlatformScheduleWorkItem( &(pDbgCtx->DbgWorkItem) );
+		}
+		PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	}
+
+	return bResult;
+}
+
+BOOLEAN
+DbgWriteBTEFuse(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulRegDataWidth,
+	IN	ULONG		ulRegValue
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	BOOLEAN 		bResult = TRUE;
+	ULONG			ulIoType;
+
+	switch(ulRegDataWidth)
+	{
+	case 1:
+		ulIoType = DBG_WRITE_BT_EFUSE_1BYTE;
+		break;	
+
+	default:
+		bResult = FALSE;
+		break;
+	}
+
+	if(bResult == TRUE)
+	{
+		// Perform IO via workitem.
+		PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+		if(pDbgCtx->bDbgWorkItemInProgress)
+		{
+			RT_ASSERT(FALSE, 
+				("DbgWorkItem is in progress!, skip DbgWriteBTEFuse(), IoType: %d.\n", ulIoType));
+			bResult = FALSE;
+		}
+		else
+		{
+			pDbgCtx->DbgIoOffset = ulRegOffset;
+			pDbgCtx->DbgIoValue = ulRegValue;
+
+			pDbgCtx->bDbgWorkItemInProgress = TRUE;
+			pDbgCtx->DbgActType = ulIoType;
+			pDbgCtx->CurrDbgAct = DbgIoCallback;
+
+			PlatformScheduleWorkItem( &(pDbgCtx->DbgWorkItem) );
+		}
+		PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	}
+
+	return bResult;
+}
+
+BOOLEAN
+DbgUpdateBTEFuse(
+	IN	PADAPTER	pAdapter	
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	BOOLEAN 		bResult = TRUE;
+	ULONG			ulIoType;
+	
+	ulIoType = DBG_UPDATE_BT_EFUSE;	
+
+	if(bResult == TRUE)
+	{
+		// Perform IO via workitem.
+		PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+		if(pDbgCtx->bDbgWorkItemInProgress)
+		{
+			RT_ASSERT(FALSE, 
+				("DbgWorkItem is in progress!, skip DbgUpdateBTEFuse(), IoType: %d.\n", ulIoType));
+			bResult = FALSE;
+		}
+		else
+		{
+			pDbgCtx->bDbgWorkItemInProgress = TRUE;
+			pDbgCtx->DbgActType = ulIoType;
+			pDbgCtx->CurrDbgAct = DbgIoCallback;
+			PlatformScheduleWorkItem( &(pDbgCtx->DbgWorkItem) );
+		}
+		PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	}
+
+	return bResult;
+}
+
+BOOLEAN
+DbgSetTxAntenna(
+	IN	PADAPTER	pAdapter,
+	IN	u1Byte		selectedAntenna
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	BOOLEAN 		bResult = TRUE;
+	ULONG			ulIoType;
+
+	ulIoType = DBG_SWITCH_ANTENNA;	
+
+	if(bResult == TRUE)
+	{
+		// Perform IO via workitem.
+		PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+		if(pDbgCtx->bDbgWorkItemInProgress)
+		{
+			RT_ASSERT(FALSE, 
+				("DbgWorkItem is in progress!, skip Pro8187IoCallback(), IoType: %d.\n", ulIoType));
+			bResult = FALSE;
+		}
+		else
+		{
+			pDbgCtx->bDbgWorkItemInProgress = TRUE;
+			pDbgCtx->DbgActType = ulIoType;
+			pDbgCtx->DbgIoValue = selectedAntenna;
+			pDbgCtx->CurrDbgAct = DbgIoCallback;
+			PlatformScheduleWorkItem( &(pDbgCtx->DbgWorkItem) );
+		}
+		PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	}
+
+	return bResult;	
+}
+
+BOOLEAN
+DbgSetTxPowerForAllRate(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulTxPowerData
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	BOOLEAN 		bResult = TRUE;
+	ULONG			ulIoType;
+
+
+	ulIoType = DBG_SET_TXPWR_FOR_ALL_RATE;
+
+
+	if(bResult == TRUE)
+	{
+		// Perform IO via workitem.
+		PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+		if(pDbgCtx->bDbgWorkItemInProgress)
+		{
+			RT_ASSERT(FALSE,
+				("DbgWorkItem is in progress!, skip DbgSetTxPowerForAllRate(), IoType: %d.\n", ulIoType));
+			bResult = FALSE;
+		}
+		else
+		{
+			pDbgCtx->DbgIoValue = ulTxPowerData;
+
+			pDbgCtx->bDbgWorkItemInProgress = TRUE;
+			pDbgCtx->DbgActType = ulIoType;
+			pDbgCtx->CurrDbgAct = DbgIoCallback;
+
+			PlatformScheduleWorkItem( &(pDbgCtx->DbgWorkItem) );
+		}
+		PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+	}
+
+	return bResult;
+}
+
+static BOOLEAN
+ndbg_BtControlStart(
+	IN	PADAPTER	pAdapter
+	)
+{
+	BOOLEAN 		bResult = TRUE;
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx = &(pAdapter->ndisDbgCtx);
+	ULONG	ulIoType = DBG_BT_CONTROL;
+	
+	PlatformAcquireSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+
+	if(pDbgCtx->bDbgWorkItemInProgress)
+	{
+		RT_ASSERT(FALSE, 
+		("DbgWorkItem is in progress!, skip Pro8187IoCallback(), IoType: %d.\n", ulIoType));
+		bResult = FALSE;			
+	}
+	else
+	{
+		pDbgCtx->bDbgWorkItemInProgress = TRUE;
+		pDbgCtx->DbgActType = ulIoType;
+		pDbgCtx->CurrDbgAct = DbgIoCallback;
+		PlatformScheduleWorkItem( &(pDbgCtx->DbgWorkItem));
+    }
+
+	PlatformReleaseSpinLock(pAdapter, RT_DBG_SPIN_LOCK);
+
+	return bResult;
+}
+
+NDIS_STATUS
+NDBG_BtControl(
+	IN	PADAPTER		pAdapter,
+	IN	PVOID			InformationBuffer,
+	IN	ULONG			InformationBufferLength,
+	OUT	PULONG			BytesRead,
+	OUT	PULONG			BytesNeeded
+	)
+{
+	PADAPTER			pDefAdapter=GetDefaultAdapter(pAdapter);
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx=&(pDefAdapter->ndisDbgCtx);
+	NDIS_STATUS				Status = NDIS_STATUS_SUCCESS;
+
+	if(InformationBufferLength < sizeof(ULONG))
+	{
+		RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], Error!! insufficient InformationBufferLength!!\n"));
+		Status = NDIS_STATUS_INVALID_LENGTH;
+		*BytesNeeded = sizeof(ULONG);
+	}
+	else
+	{
+		RT_DISP_DATA(FBT, BT_DBG_CONTENT, ("[BTDBG], InformationBuffer: \n"), InformationBuffer, InformationBufferLength);
+		if(InformationBufferLength <= 100)
+		{
+			PlatformMoveMemory(&pDbgCtx->btInBuf[0], InformationBuffer, InformationBufferLength);
+			RT_DISP_DATA(FBT, BT_DBG_CONTENT, ("[BTDBG], pDbgCtx->btInBuf: \n"), &pDbgCtx->btInBuf[0], InformationBufferLength);
+			if(!ndbg_BtControlStart(pDefAdapter))
+			{
+				RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], Error!! DBG workitem is under progress!!\n"));
+				Status = NDIS_STATUS_NOT_ACCEPTED;
+			}
+		}
+		else
+		{
+			RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], Error!! InformationBufferLength should < 100!!\n"));
+			Status = NDIS_STATUS_INVALID_LENGTH;
+		}
+	}
+	
+	return Status;
+}
+
+BOOLEAN
+NDBG_GetBtFwVersion(
+	IN	PADAPTER		pAdapter,
+	IN	pu2Byte			pBtRealFwVer,
+	IN	pu1Byte			pBtFwVer
+	)
+{
+	PBT_EXT_C2H			pExtC2h=(PBT_EXT_C2H)&GLCurBtC2hRsp[0];
+	pu1Byte				pBtRspContent=(pu1Byte)&pExtC2h->buf[0];
+	BT_CTRL_STATUS		retStatus;
+	u1Byte				h2cParaBuf[6] ={0};
+	u1Byte				h2cParaLen=0;
+	u1Byte				btOpcode, btFwVer;
+	u1Byte				btOpcodeVer=0;
+	u2Byte				btRealFwVer=0, realStatus=0;
+	pu2Byte				pu2Tmp;
+
+	// Get BT FW version
+	// fill h2c parameters
+	btOpcode = BT_LO_OP_GET_BT_VERSION;
+	// execute h2c and check respond c2h from bt fw is correct or not
+	retStatus = ndbg_BtFwOpCodeProcess(pAdapter, btOpcode, btOpcodeVer, &h2cParaBuf[0], h2cParaLen);
+	// ckeck bt return status.
+	if(BT_STATUS_BT_OP_SUCCESS != retStatus)
+	{
+		realStatus = ((btOpcode<<8)|retStatus);
+		*pBtRealFwVer = 0xffff;
+		*pBtFwVer = 0xff;
+		RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], Query BT fw version fail, status code=0x%x!!!\n", realStatus));
+		return FALSE;
+	}
+	else
+	{	
+		pu2Tmp = (pu2Byte)&pBtRspContent[0];
+		btRealFwVer = *pu2Tmp;
+		btFwVer = pExtC2h->buf[2];
+		*pBtRealFwVer = btRealFwVer;
+		*pBtFwVer = btFwVer;
+		RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], Query BT fw version successful!! btRealFwVer=0x%x, btFwVer=0x%x\n", btRealFwVer, btFwVer));
+		return TRUE;
+	}
+}
+
+VOID
+NDBG_FwC2hBtControl(
+	IN	PADAPTER	Adapter,
+	IN	pu1Byte		tmpBuf,
+	IN	u1Byte		length
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx=&(Adapter->ndisDbgCtx);
+	PBT_EXT_C2H		pExtC2h=(PBT_EXT_C2H)tmpBuf;
+
+	RT_DISP_DATA(FBT, BT_DBG_CONTENT, ("[BTDBG], NDBG_FwC2hBtControl(), hex: \n"), 
+						tmpBuf, length);
+
+	RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], pExtC2h->extendId=0x%x\n", pExtC2h->extendId));
+	switch(pExtC2h->extendId)
+	{
+		case EXT_C2H_WIFI_FW_ACTIVE_RSP:
+			RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], EXT_C2H_WIFI_FW_ACTIVE_RSP\n"));
+			RT_DISP_DATA(FBT, BT_DBG_CONTENT, ("[BTDBG], pExtC2h->buf hex: \n"), 
+				&pExtC2h->buf[0], (length-3));
+			PlatformSetEvent(&pDbgCtx->dbgH2cRspEvent);
+			break;
+		case EXT_C2H_TRIG_BY_BT_FW:
+			RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], EXT_C2H_TRIG_BY_BT_FW\n"));
+			PlatformMoveMemory(&GLCurBtC2hRsp[0], tmpBuf, length);
+			RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], pExtC2h->statusCode=0x%x\n", pExtC2h->statusCode));
+			RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], pExtC2h->retLen=0x%x\n", pExtC2h->retLen));
+			RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], pExtC2h->opCodeVer=0x%x\n", pExtC2h->opCodeVer));
+			RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], pExtC2h->reqNum=0x%x\n", pExtC2h->reqNum));
+			RT_DISP_DATA(FBT, BT_DBG_CONTENT, ("[BTDBG], pExtC2h->buf hex: \n"), 
+				&pExtC2h->buf[0], (length-3));
+			PlatformSetEvent(&pDbgCtx->dbgBtC2hEvent);
+			break;
+		default:
+			break;
+	}
+}
+
+VOID
+NDBG_StackBtCoexNotify(
+	IN	PADAPTER	Adapter,
+	IN	u1Byte		stackOpCode,
+	IN	u1Byte		stackOpStatus,
+	IN	pu1Byte		tmpBuf,
+	IN	u1Byte		length
+	)
+{
+	PRT_NDIS_DBG_CONTEXT	pDbgCtx=&(Adapter->ndisDbgCtx);
+	PBT_STACK_COEX_INFO	pStackRsp=(PBT_STACK_COEX_INFO)&GLCurBtStackRsp[0];
+
+	pStackRsp->opCode = stackOpCode;
+	pStackRsp->opStatus = stackOpStatus;
+	pStackRsp->bufLen = length;
+	if(length)
+	{
+		PlatformMoveMemory(&pStackRsp->buf[0], tmpBuf, length);
+		RT_DISP_DATA(FBT, BT_DBG_CONTENT, ("[BTDBG], NDBG_StackBtCoexNotify(), hex: \n"), 
+			tmpBuf, length);
+	}
+	RT_DISP(FBT, BT_DBG_STATE, ("[BTDBG], pStackRsp->opCode=0x%x, pStackRsp->opStatus=0x%x\n", 
+		pStackRsp->opCode, pStackRsp->opStatus));
+	PlatformSetEvent(&pDbgCtx->dbgBtCoexEvent);
+}
+
+
diff --git a/network/wlan/WDI/PLATFORM/NdisComm/NdisDbg.h b/network/wlan/WDI/PLATFORM/NdisComm/NdisDbg.h
new file mode 100644
index 00000000..48e77aa6
--- /dev/null
+++ b/network/wlan/WDI/PLATFORM/NdisComm/NdisDbg.h
@@ -0,0 +1,434 @@
+#ifndef __INC_NDIS_DBG_H
+#define __INC_NDIS_DBG_H
+
+
+#define	BT_H2C_MAX_RETRY								1
+#define	BT_MAX_C2H_LEN									20
+
+typedef enum _RTL_EXT_C2H_EVT
+{
+	EXT_C2H_WIFI_FW_ACTIVE_RSP = 0,
+	EXT_C2H_TRIG_BY_BT_FW = 1,
+	MAX_EXT_C2HEVENT
+}RTL_EXT_C2H_EVT;
+
+
+// OP codes definition between the user layer and driver
+typedef enum _BT_CTRL_OPCODE_UPPER{
+	BT_UP_OP_BT_READY										= 0x00, 
+	BT_UP_OP_BT_SET_MODE									= 0x01,
+	BT_UP_OP_BT_SET_TX_RX_PARAMETER							= 0x02,
+	BT_UP_OP_BT_SET_GENERAL									= 0x03,
+	BT_UP_OP_BT_GET_GENERAL									= 0x04,
+	BT_UP_OP_BT_TEST_CTRL									= 0x05,
+	BT_UP_OP_MAX
+}BT_CTRL_OPCODE_UPPER,*PBT_CTRL_OPCODE_UPPER;
+
+typedef enum _BT_SET_GENERAL{
+	BT_GSET_REG												= 0x00, 
+	BT_GSET_RESET											= 0x01, 
+	BT_GSET_TARGET_BD_ADDR									= 0x02, 
+	BT_GSET_TX_PWR_FINETUNE									= 0x03,
+	BT_GSET_TRACKING_INTERVAL								= 0x04,
+	BT_GSET_THERMAL_METER									= 0x05,
+	BT_GSET_CFO_TRACKING									= 0x06,
+	BT_GSET_ANT_DETECTION									= 0x07,
+	BT_GSET_MAX
+}BT_SET_GENERAL,*PBT_SET_GENERAL;
+
+typedef enum _BT_GET_GENERAL{
+	BT_GGET_REG												= 0x00, 
+	BT_GGET_STATUS											= 0x01,
+	BT_GGET_REPORT											= 0x02,
+	BT_GGET_AFH_MAP											= 0x03,
+	BT_GGET_AFH_STATUS										= 0x04,
+	BT_GGET_IQK_FLOW										= 0x05,
+	BT_GGET_IQK_RESULT										= 0x06,
+	BT_GGET_MAX
+}BT_GET_GENERAL,*PBT_GET_GENERAL;
+
+// definition for BT_UP_OP_BT_SET_GENERAL
+typedef enum _BT_REG_TYPE{
+	BT_REG_RF								= 0,
+	BT_REG_MODEM							= 1,
+	BT_REG_BLUEWIZE							= 2,
+	BT_REG_VENDOR							= 3,
+	BT_REG_LE								= 4,
+	BT_REG_MAX
+}BT_REG_TYPE,*PBT_REG_TYPE;
+
+// definition for BT_LO_OP_GET_AFH_MAP
+typedef enum _BT_AFH_MAP_TYPE{
+	BT_AFH_MAP_RESULT						= 0,
+	BT_AFH_MAP_WIFI_PSD_ONLY				= 1,
+	BT_AFH_MAP_WIFI_CH_BW_ONLY				= 2,
+	BT_AFH_MAP_BT_PSD_ONLY					= 3,
+	BT_AFH_MAP_HOST_CLASSIFICATION_ONLY		= 4,
+	BT_AFH_MAP_MAX
+}BT_AFH_MAP_TYPE,*PBT_AFH_MAP_TYPE;
+
+// definition for BT_UP_OP_BT_GET_GENERAL
+typedef enum _BT_REPORT_TYPE{
+	BT_REPORT_RX_PACKET_CNT					= 0,
+	BT_REPORT_RX_ERROR_BITS					= 1,
+	BT_REPORT_RSSI							= 2,
+	BT_REPORT_CFO_HDR_QUALITY				= 3,
+	BT_REPORT_CONNECT_TARGET_BD_ADDR		= 4,
+	BT_REPORT_MAX
+}BT_REPORT_TYPE,*PBT_REPORT_TYPE;
+
+
+//OP codes definition between driver and bt fw
+typedef enum _BT_CTRL_OPCODE_LOWER{
+	BT_LO_OP_GET_BT_VERSION										= 0x00, 
+	BT_LO_OP_RESET												= 0x01,
+	BT_LO_OP_TEST_CTRL											= 0x02,
+	BT_LO_OP_SET_BT_MODE										= 0x03,
+	BT_LO_OP_SET_CHNL_TX_GAIN									= 0x04,
+	BT_LO_OP_SET_PKT_TYPE_LEN									= 0x05,
+	BT_LO_OP_SET_PKT_CNT_L_PL_TYPE								= 0x06,
+	BT_LO_OP_SET_PKT_CNT_H_PKT_INTV								= 0x07,
+	BT_LO_OP_SET_PKT_HEADER										= 0x08,
+	BT_LO_OP_SET_WHITENCOEFF									= 0x09,
+	BT_LO_OP_SET_BD_ADDR_L										= 0x0a,
+	BT_LO_OP_SET_BD_ADDR_H										= 0x0b,
+	BT_LO_OP_WRITE_REG_ADDR										= 0x0c,
+	BT_LO_OP_WRITE_REG_VALUE									= 0x0d,
+	BT_LO_OP_GET_BT_STATUS										= 0x0e,
+	BT_LO_OP_GET_BD_ADDR_L										= 0x0f,
+	BT_LO_OP_GET_BD_ADDR_H										= 0x10,
+	BT_LO_OP_READ_REG											= 0x11,
+	BT_LO_OP_SET_TARGET_BD_ADDR_L								= 0x12,
+	BT_LO_OP_SET_TARGET_BD_ADDR_H								= 0x13,
+	BT_LO_OP_SET_TX_POWER_CALIBRATION							= 0x14,
+	BT_LO_OP_GET_RX_PKT_CNT_L									= 0x15,
+	BT_LO_OP_GET_RX_PKT_CNT_H									= 0x16,
+	BT_LO_OP_GET_RX_ERROR_BITS_L								= 0x17,
+	BT_LO_OP_GET_RX_ERROR_BITS_H								= 0x18,
+	BT_LO_OP_GET_RSSI											= 0x19,
+	BT_LO_OP_GET_CFO_HDR_QUALITY_L								= 0x1a,
+	BT_LO_OP_GET_CFO_HDR_QUALITY_H								= 0x1b,
+	BT_LO_OP_GET_TARGET_BD_ADDR_L								= 0x1c,
+	BT_LO_OP_GET_TARGET_BD_ADDR_H								= 0x1d,
+	BT_LO_OP_GET_AFH_MAP_L										= 0x1e,
+	BT_LO_OP_GET_AFH_MAP_M										= 0x1f,
+	BT_LO_OP_GET_AFH_MAP_H										= 0x20,
+	BT_LO_OP_GET_AFH_STATUS										= 0x21,
+	BT_LO_OP_SET_TRACKING_INTERVAL								= 0x22,
+	BT_LO_OP_SET_THERMAL_METER									= 0x23,
+	BT_LO_OP_SET_CFO_TRACKING									= 0x24,
+	BT_LO_OP_SET_FW_POLICY_REQ									= 0x25,
+	BT_LO_OP_SET_ANT_DETECTION									= 0x26,
+	BT_LO_OP_GET_IQK_FLOW										= 0x27,
+	BT_LO_OP_GET_IQK_RESULT										= 0x28,
+	BT_LO_OP_MAX
+}BT_CTRL_OPCODE_LOWER,*PBT_CTRL_OPCODE_LOWER;
+
+//OP codes definition between driver and bt stack
+typedef enum _BT_CTRL_OPCODE_STACK{
+	BT_STACK_OP_GET_BT_VERSION									= 0x00,
+	BT_STACK_OP_IGNORE_WLAN_ACTIVE_CTRL							= 0x01,
+	BT_STACK_OP_LNA_CONSTRAIN_CTRL								= 0x02,
+	BT_STACK_OP_BT_POWER_DEC_CTRL								= 0x03,
+	BT_STACK_OP_BT_PSD_MODE_CTRL								= 0x04,
+	BT_STACK_OP_BT_WIFI_BW_CHNL_NOTIFY							= 0x05,
+	BT_STACK_OP_QUERY_BT_AFH_MAP								= 0x06,
+	BT_STACK_OP_BT_REGISTER_ACCESS								= 0x07,
+	BT_STACK_OP_MAX
+}BT_CTRL_OPCODE_STACK,*PBT_CTRL_OPCODE_STACK;
+
+
+// return status definition to the user layer
+typedef enum _BT_CTRL_STATUS{
+	BT_STATUS_SUCCESS									= 0x00, // Success
+	BT_STATUS_BT_OP_SUCCESS								= 0x01,	// bt fw op execution success
+	BT_STATUS_H2C_SUCCESS								= 0x02,	// H2c success
+	BT_STATUS_H2C_TIMTOUT								= 0x03, // H2c timeout
+	BT_STATUS_H2C_BT_NO_RSP								= 0x04, // H2c sent, bt no rsp
+	BT_STATUS_C2H_SUCCESS								= 0x05, // C2h success
+	BT_STATUS_C2H_REQNUM_MISMATCH						= 0x06,	// bt fw wrong rsp
+	BT_STATUS_OPCODE_U_VERSION_MISMATCH					= 0x07,	// Upper layer OP code version mismatch.
+	BT_STATUS_OPCODE_L_VERSION_MISMATCH					= 0x08,	// Lower layer OP code version mismatch.
+	BT_STATUS_UNKNOWN_OPCODE_U							= 0x09, // Unknown Upper layer OP code
+	BT_STATUS_UNKNOWN_OPCODE_L							= 0x0a, // Unknown Lower layer OP code
+	BT_STATUS_PARAMETER_FORMAT_ERROR_U					= 0x0b,	// Wrong parameters sent by upper layer.
+	BT_STATUS_PARAMETER_FORMAT_ERROR_L					= 0x0c,	// bt fw parameter format is not consistency
+	BT_STATUS_PARAMETER_OUT_OF_RANGE_U					= 0x0d,	// uppery layer parameter value is out of range
+	BT_STATUS_PARAMETER_OUT_OF_RANGE_L					= 0x0e,	// bt fw parameter value is out of range
+	BT_STATUS_UNKNOWN_STATUS_L							= 0x0f,	// bt returned an defined status code
+	BT_STATUS_UNKNOWN_STATUS_H							= 0x10,	// driver need to do error handle or not handle-well.
+	BT_STATUS_WRONG_LEVEL								= 0x11, // should be under passive level
+	BT_STATUS_NOT_IMPLEMENT 							= 0x12,	// op code not implemented yet
+	BT_STATUS_BT_STACK_OP_SUCCESS						= 0x13,	// bt stack op execution success
+	BT_STATUS_BT_STACK_NOT_SUPPORT						= 0x14, 	// stack version not support this.
+	BT_STATUS_BT_STACK_SEND_HCI_EVENT_FAIL				= 0x15, 	// send hci event fail
+	BT_STATUS_BT_STACK_NOT_BIND							= 0x16,	// stack not bind wifi driver
+	BT_STATUS_BT_STACK_NO_RSP							= 0x17,	// stack doesn't have any rsp.
+	BT_STATUS_MAX
+}BT_CTRL_STATUS,*PBT_CTRL_STATUS;
+
+typedef enum _BT_OPCODE_STATUS{
+	BT_OP_STATUS_SUCCESS									= 0x00, // Success
+	BT_OP_STATUS_VERSION_MISMATCH							= 0x01,	
+	BT_OP_STATUS_UNKNOWN_OPCODE								= 0x02,
+	BT_OP_STATUS_ERROR_PARAMETER							= 0x03,
+	BT_OP_STATUS_MAX
+}BT_OPCODE_STATUS,*PBT_OPCODE_STATUS;
+
+
+typedef struct _BT_REQ_CMD{
+    UCHAR       opCodeVer;
+    UCHAR       OpCode;
+    USHORT      paraLength;
+    UCHAR       pParamStart[1];
+} BT_REQ_CMD, *PBT_REQ_CMD;
+
+typedef struct _BT_RSP_CMD{
+    USHORT      status;
+    USHORT      paraLength;
+    UCHAR       pParamStart[1];
+} BT_RSP_CMD, *PBT_RSP_CMD;
+
+typedef struct _BT_H2C{
+	u1Byte	opCodeVer:4;
+	u1Byte	reqNum:4;
+	u1Byte	opCode;
+	u1Byte	buf[1];
+}BT_H2C, *PBT_H2C;
+
+typedef struct _BT_EXT_C2H{
+	u1Byte	extendId;
+	u1Byte	statusCode:4;
+	u1Byte	retLen:4;
+	u1Byte	opCodeVer:4;
+	u1Byte	reqNum:4;
+	u1Byte	buf[1];
+}BT_EXT_C2H, *PBT_EXT_C2H;
+
+typedef struct _BT_STACK_COEX_INFO{
+	u1Byte	opCode;
+	u1Byte	opStatus;
+	u1Byte	bufLen;
+	u1Byte	buf[1];
+}BT_STACK_COEX_INFO, *PBT_STACK_COEX_INFO;
+
+typedef struct _HAL_REQ_CMD{
+    UCHAR       OpCodeVer;
+    UCHAR       OpCode;
+    USHORT      ParaLength;
+    UCHAR       pParamStart[1];
+} HAL_REQ_CMD, *PHAL_REQ_CMD;
+
+typedef struct _HAL_RSP_CMD{
+    USHORT		Status;
+    USHORT      ParaLength;
+    UCHAR       pParamStart[1];
+} HAL_RSP_CMD, *PHAL_RSP_CMD;
+
+//
+// Type of action going on in DbgWorkItem.
+//
+#define DBG_NOOP					0
+#define DBG_READ_MAC_1BYTE			1
+#define DBG_READ_MAC_2BYTE			2
+#define DBG_READ_MAC_4BYTE			3
+#define DBG_WRITE_MAC_1BYTE			4
+#define DBG_WRITE_MAC_2BYTE			5
+#define DBG_WRITE_MAC_4BYTE			6
+#define DBG_READ_BB_CCK				7
+#define DBG_WRITE_BB_CCK			8
+#define DBG_READ_BB_OFDM			9
+#define DBG_WRITE_BB_OFDM			10
+#define DBG_READ_RF					11
+#define DBG_WRITE_RF				12
+#define DBG_READ_EEPROM_1BYTE		13
+#define DBG_WRITE_EEPROM_1BYTE		14
+#define DBG_READ_EEPROM_2BYTE		15
+#define DBG_WRITE_EEPROM_2BYTE		16
+#define DBG_OUT_CMD				17
+
+#define DBG_SWITCH_ANTENNA			26
+#define DBG_SET_TXPWR_FOR_ALL_RATE	27
+//
+// <Roger_Notes> The following DBG IO components are ONLY for 92S.
+// Please do NOT revise the macro definitions(i.e., compatible with DLL export functions)
+// 2008.11.17.
+//
+#define DBG_WRITE_EFUSE_1BYTE			53
+#define DBG_READ_EFUSE_1BYTE			54
+#define DBG_READ_EFUSE_2BYTE			55
+#define DBG_READ_EFUSE_4BYTE			56
+#define DBG_UPDATE_EFUSE				57
+
+#define DBG_WRITE_BT_EFUSE_1BYTE  		64
+#define DBG_READ_BT_EFUSE_1BYTE		65
+#define DBG_READ_BT_EFUSE_2BYTE		66
+#define DBG_READ_BT_EFUSE_4BYTE		67
+#define DBG_UPDATE_BT_EFUSE			68
+#define DBG_UPDATE_BT_EFUSE_UTILIZE	69
+#define DBG_UPDATE_BT_EFUSE_MAP		70
+#define	DBG_BT_CONTROL				75
+
+// Forward declaration.
+typedef struct _ADAPTER ADAPTER, *PADAPTER;
+
+VOID
+NDBG_Init(
+	IN	PADAPTER pAdapter
+);
+
+VOID
+NDBG_Halt(
+	IN	PADAPTER pAdapter
+);
+
+NDIS_STATUS
+NDBG_BtControl(
+	IN	PADAPTER		pAdapter,
+	IN	PVOID			InformationBuffer,
+	IN	ULONG			InformationBufferLength,
+	OUT	PULONG			BytesRead,
+	OUT	PULONG			BytesNeeded
+	);
+BOOLEAN
+NDBG_GetBtFwVersion(
+	IN	PADAPTER		pAdapter,
+	IN	pu2Byte			pBtRealFwVer,
+	IN	pu1Byte			pBtFwVer
+	);
+VOID
+NDBG_FwC2hBtControl(
+	IN	PADAPTER	Adapter,
+	IN	pu1Byte		tmpBuf,
+	IN	u1Byte		length
+	);
+VOID
+NDBG_StackBtCoexNotify(
+	IN	PADAPTER	Adapter,
+	IN	u1Byte		stackOpCode,
+	IN	u1Byte		stackOpStatus,
+	IN	pu1Byte		tmpBuf,
+	IN	u1Byte		length
+	);
+
+BOOLEAN
+DbgReadMacReg(
+	IN	PADAPTER			pAdapter,
+	IN	ULONG				ulRegOffset,
+	IN	ULONG				ulRegDataWidth
+);
+
+BOOLEAN
+DbgWriteMacReg(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulRegDataWidth,
+	IN	ULONG		ulRegValue
+);
+
+BOOLEAN
+DbgReadBbReg(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulBeOFDM
+);
+
+BOOLEAN
+DbgWriteBbReg(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulBeOFDM,
+	IN	ULONG		ulRegValue
+);
+
+BOOLEAN
+DbgReadRfReg(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulRegDataWidth
+);
+
+BOOLEAN
+DbgWriteRfReg(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulRegDataWidth,
+	IN	ULONG		ulRegValue
+);
+
+BOOLEAN
+DbgReadEeprom(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulRegDataWidth
+);
+
+BOOLEAN
+DbgWriteEeprom(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulRegDataWidth,
+	IN	ULONG		ulRegValue
+);
+
+BOOLEAN
+DbgOutCmd(
+	IN	PADAPTER		pAdapter,
+	IN	PUCHAR			ulOutCmd,
+	IN	ULONG			ulOutCmdWidth
+);
+
+BOOLEAN
+DbgReadEFuse(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulRegDataWidth
+);
+
+BOOLEAN
+DbgWriteEFuse(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulRegDataWidth,
+	IN	ULONG		ulRegValue
+);
+
+BOOLEAN
+DbgUpdateEFuse(
+	IN	PADAPTER	pAdapter	
+);
+
+BOOLEAN
+DbgReadBTEFuse(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulRegDataWidth
+);
+
+BOOLEAN
+DbgWriteBTEFuse(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulRegOffset,
+	IN	ULONG		ulRegDataWidth,
+	IN	ULONG		ulRegValue
+);
+
+BOOLEAN
+DbgUpdateBTEFuse(
+	IN	PADAPTER	pAdapter	
+);
+
+BOOLEAN
+DbgSetTxPowerForAllRate(
+	IN	PADAPTER	pAdapter,
+	IN	ULONG		ulTxPowerData
+	);
+
+
+BOOLEAN
+DbgSetTxAntenna(
+	IN	PADAPTER	pAdapter,
+	IN	u1Byte		selectedAntenna
+);
+
+#endif
diff --git a/network/wlan/WDI/PLATFORM/NdisComm/NdisOid.c b/network/wlan/WDI/PLATFORM/NdisComm/NdisOid.c
new file mode 100644
index 00000000..e1bf69c1
--- /dev/null
+++ b/network/wlan/WDI/PLATFORM/NdisComm/NdisOid.c
@@ -0,0 +1,323 @@
+#include "Mp_Precomp.h"
+
+BOOLEAN
+oids_RTKDbgInvalidLength(
+	IN	ULONG				InformationBufferLength,
+	IN	PRTK_DBG_CTRL_OIDS	pRTKDbg,
+	OUT	PULONG				BytesNeeded
+	)
+{
+	BOOLEAN		bRet=FALSE;
+	ULONG		totalLen=0;
+
+	totalLen = sizeof(RTK_DBG_CTRL_OIDS)-sizeof(ULONG)+pRTKDbg->ctrlDataLen;
+	if(InformationBufferLength != totalLen)
+	{
+		bRet = TRUE;
+		*BytesNeeded = totalLen;
+		return bRet;
+	}
+	return bRet;
+}
+
+
+
+
+
+NDIS_STATUS
+OIDQ_RTKReadReg(
+	IN	PADAPTER	Adapter,
+	IN	PVOID		InformationBuffer,
+	IN	ULONG		InformationBufferLength,
+	OUT	PULONG		BytesWritten,
+	OUT	PULONG		BytesNeeded,
+	IN	PULONG		pulInfo
+	)
+{
+	NDIS_STATUS		Status=NDIS_STATUS_SUCCESS;
+	ULONG			ulRegOffset;
+	ULONG			ulRegDataWidth;
+	ULONG			ulInfo = 0;
+
+	// Verify input paramter.
+	if(InformationBufferLength < sizeof(ULONG)*2)
+	{
+		Status = NDIS_STATUS_INVALID_LENGTH;
+		*BytesNeeded = sizeof(ULONG)*2;
+		return Status;
+	}
+	// Get offset and data width.
+	ulRegOffset = *((ULONG*)InformationBuffer);
+	ulRegDataWidth = *((ULONG*)InformationBuffer+1);
+	switch(ulRegDataWidth)
+	{
+	case 1:
+		if( IS_BB_REG_OFFSET_92S(ulRegOffset) )
+		{
+			ULONG mod_val=0;
+			mod_val = ulRegOffset%4;
+			if(mod_val)
+				ulRegOffset -= mod_val;
+			ulInfo = PHY_QueryBBReg(Adapter, ulRegOffset, bMaskDWord);
+			ulInfo &= (bMaskByte0<<(8*mod_val));
+			ulInfo = (ulInfo>>(8*mod_val));
+		}
+		else
+			ulInfo = PlatformEFIORead1Byte(Adapter, ulRegOffset);
+		break;
+	case 2:
+		if( IS_BB_REG_OFFSET_92S(ulRegOffset) )
+		{
+			ULONG mod_val=0;
+			mod_val = ulRegOffset%4;
+			if(mod_val)
+				ulRegOffset -= mod_val;
+			ulInfo = PHY_QueryBBReg(Adapter, ulRegOffset, bMaskDWord);
+			ulInfo &= (bMaskLWord<<(8*mod_val));
+			ulInfo = (ulInfo>>(8*mod_val));
+		}
+		else
+			ulInfo = PlatformEFIORead2Byte(Adapter, ulRegOffset);
+		break;
+	case 4:
+		if( IS_BB_REG_OFFSET_92S(ulRegOffset) )
+			ulInfo = PHY_QueryBBReg(Adapter, ulRegOffset, bMaskDWord);
+		else
+			ulInfo = PlatformEFIORead4Byte(Adapter, ulRegOffset);
+		break;
+	default:
+		Status = NDIS_STATUS_INVALID_LENGTH;
+		return Status;
+	}
+
+	*pulInfo = ulInfo;
+
+	return Status;
+}
+
+NDIS_STATUS
+OIDQ_RTKReadRegSIC(
+	IN	PADAPTER	Adapter,
+	IN	PVOID		InformationBuffer,
+	IN	ULONG		InformationBufferLength,
+	OUT	PULONG		BytesWritten,
+	OUT	PULONG		BytesNeeded,
+	IN	PULONG		pulInfo
+	)
+{
+	NDIS_STATUS		Status=NDIS_STATUS_SUCCESS;
+	ULONG			ulRegOffset;
+	ULONG			ulRegDataWidth;
+	ULONG			ulInfo = 0;
+
+	// Verify input paramter.
+	if(InformationBufferLength < sizeof(ULONG)*2)
+	{
+		Status = NDIS_STATUS_INVALID_LENGTH;
+		*BytesNeeded = sizeof(ULONG)*2;
+		return Status;
+	}
+	// Get offset and data width.
+	ulRegOffset = *((ULONG*)InformationBuffer);
+	ulRegDataWidth = *((ULONG*)InformationBuffer+1);
+	switch(ulRegDataWidth)
+	{
+	case 1:
+		{
+			ULONG mod_val=0;
+			mod_val = ulRegOffset%4;
+			if(mod_val)
+				ulRegOffset -= mod_val;
+
+			ulInfo = SIC_QueryBBReg(Adapter, ulRegOffset, bMaskDWord);
+			ulInfo &= (bMaskByte0<<(8*mod_val));
+			ulInfo = (ulInfo>>(8*mod_val));
+		}
+		break;
+	case 2:
+		{
+			ULONG mod_val=0;
+			mod_val = ulRegOffset%4;
+			if(mod_val)
+				ulRegOffset -= mod_val;
+			ulInfo = SIC_QueryBBReg(Adapter, ulRegOffset, bMaskDWord);
+			ulInfo &= (bMaskLWord<<(8*mod_val));
+			ulInfo = (ulInfo>>(8*mod_val));
+		}
+		break;
+	case 4:
+		ulInfo = SIC_QueryBBReg(Adapter, ulRegOffset, bMaskDWord);
+		break;
+	default:
+		Status = NDIS_STATUS_INVALID_LENGTH;
+		return Status;
+	}
+
+	*pulInfo = ulInfo;
+
+	return Status;
+}
+
+NDIS_STATUS
+OIDS_RTKWriteReg(
+	IN	PADAPTER	Adapter,
+	IN	PVOID		InformationBuffer,
+	IN	ULONG		InformationBufferLength,
+	OUT	PULONG		BytesRead,
+	OUT	PULONG		BytesNeeded
+	)
+{
+	NDIS_STATUS		Status=NDIS_STATUS_SUCCESS;
+	ULONG			ulRegOffset;
+	ULONG			ulRegDataWidth;
+	ULONG			ulRegValue;
+
+	// Verify input paramter.
+	if(InformationBufferLength < sizeof(ULONG)*3)
+	{
+		Status = NDIS_STATUS_INVALID_LENGTH;
+		*BytesNeeded = sizeof(ULONG)*3;				
+		return Status;
+	}
+	// Get offset, data width, and value to write.
+	ulRegOffset = *((ULONG*)InformationBuffer);
+	ulRegDataWidth = *((ULONG*)InformationBuffer+1);
+	ulRegValue = *((ULONG*)InformationBuffer+2);
+
+	switch(ulRegDataWidth)
+	{
+	case 1:
+		if( IS_BB_REG_OFFSET_92S(ulRegOffset) )
+		{
+			ULONG mod_val=0;
+			mod_val = ulRegOffset%4;
+			if(mod_val)
+				ulRegOffset -= mod_val;
+			PHY_SetBBReg(Adapter, ulRegOffset, (u4Byte)(bMaskByte0<<(8*mod_val)), ulRegValue);
+		}
+		else
+			PlatformEFIOWrite1Byte(Adapter, ulRegOffset, (u1Byte)(ulRegValue));
+		break;
+	case 2:
+		if( IS_BB_REG_OFFSET_92S(ulRegOffset) )
+		{
+			ULONG mod_val=0;
+			mod_val = ulRegOffset%4;
+			if(mod_val)
+				ulRegOffset -= mod_val;
+			PHY_SetBBReg(Adapter, ulRegOffset, (bMaskLWord<<(8*mod_val)), ulRegValue);
+		}
+		else
+			PlatformEFIOWrite2Byte(Adapter, ulRegOffset, (u2Byte)(ulRegValue));
+		break;
+	case 4:
+		if( IS_BB_REG_OFFSET_92S(ulRegOffset) )
+
			PHY_SetBBReg(Adapter, ulRegOffset, bMaskDWord, ulRegValue);
+		else
+			PlatformEFIOWrite4Byte(Adapter, ulRegOffset, (u4Byte)(ulRegValue));
+		break;
+	default:
+		Status = NDIS_STATUS_INVALID_LENGTH;
+		return Status;
+	}
+
+	return Status;
+}
+
+NDIS_STATUS
+OIDS_RTKWriteRegSIC(
+	IN	PADAPTER	Adapter,
+	IN	PVOID		InformationBuffer,
+	IN	ULONG		InformationBufferLength,
+	OUT	PULONG		BytesRead,
+	OUT	PULONG		BytesNeeded
+	)
+{
+	NDIS_STATUS		Status=NDIS_STATUS_SUCCESS;
+	ULONG			ulRegOffset;
+	ULONG			ulRegDataWidth;
+	ULONG			ulRegValue;
+
+	// Verify input paramter.
+	if(InformationBufferLength < sizeof(ULONG)*3)
+	{
+		Status = NDIS_STATUS_INVALID_LENGTH;
+		*BytesNeeded = sizeof(ULONG)*3;				
+		return Status;
+	}
+	// Get offset, data width, and value to write.
+	ulRegOffset = *((ULONG*)InformationBuffer);
+	ulRegDataWidth = *((ULONG*)InformationBuffer+1);
+	ulRegValue = *((ULONG*)InformationBuffer+2);
+
+	switch(ulRegDataWidth)
+	{
+	case 1:
+		{
+			ULONG mod_val=0;
+			mod_val = ulRegOffset%4;
+			if(mod_val)
+				ulRegOffset -= mod_val;
+			SIC_SetBBReg(Adapter, ulRegOffset, (u4Byte)(bMaskByte0<<(8*mod_val)), ulRegValue);
+		}
+		break;
+	case 2:
+		{
+			ULONG mod_val=0;
+			mod_val = ulRegOffset%4;
+			if(mod_val)
+				ulRegOffset -= mod_val;
+			SIC_SetBBReg(Adapter, ulRegOffset, (bMaskLWord<<(8*mod_val)), ulRegValue);
+		}
+		break;
+	case 4:
+
		SIC_SetBBReg(Adapter, ulRegOffset, bMaskDWord, ulRegValue);
+		break;
+	default:
+		Status = NDIS_STATUS_INVALID_LENGTH;
+		return Status;
+	}
+
+	return Status;
+}
+
+
+NDIS_STATUS
+OIDS_RTKDbgControl(
+	IN	PADAPTER	Adapter,
+	IN	PVOID		InformationBuffer,
+	IN	ULONG		InformationBufferLength,
+	OUT	PULONG		BytesRead,
+	OUT	PULONG		BytesNeeded	
+	)
+{
+	NDIS_STATUS			Status=NDIS_STATUS_SUCCESS;
+	PRTK_DBG_CTRL_OIDS	pRTKDbg;
+
+	pRTKDbg = (PRTK_DBG_CTRL_OIDS)InformationBuffer;
+
+	RT_DISP(FDBG_CTRL, DBG_CTRL_TRACE, ("[RTKDBG], Type=0x%x, Len=0x%x(%d)\n", 
+		pRTKDbg->ctrlType, pRTKDbg->ctrlDataLen, pRTKDbg->ctrlDataLen));
+
+	if(oids_RTKDbgInvalidLength(InformationBufferLength, pRTKDbg, BytesNeeded))
+	{
+		RT_DISP(FDBG_CTRL, DBG_CTRL_TRACE, ("[RTKDBG], Invalid Length, return!!\n"));
+		Status = NDIS_STATUS_INVALID_LENGTH;				
+		return Status;
+	}
+	else
+	{
+		RT_DISP_DATA(FDBG_CTRL, DBG_CTRL_TRACE, ("[RTKDBG], Hex Data :"), &pRTKDbg->CtrlData, pRTKDbg->ctrlDataLen)
+	}
+
+	switch(pRTKDbg->ctrlType)
+	{
+		case RTK_DBG_OIDS_BT_PROFILE:
+			RT_DISP(FDBG_CTRL, DBG_CTRL_TRACE, ("[RTKDBG], RTK_DBG_OIDS_BT_PROFILE\n"));
+			break;
+		default:
+			break;
+	}
+
+	return Status;
+}
\ No newline at end of file
diff --git a/network/wlan/WDI/PLATFORM/NdisComm/NdisOid.h b/network/wlan/WDI/PLATFORM/NdisComm/NdisOid.h
new file mode 100644
index 00000000..ef382bc9
--- /dev/null
+++ b/network/wlan/WDI/PLATFORM/NdisComm/NdisOid.h
@@ -0,0 +1,75 @@
+#ifndef __INC_NDIS_COMMONOID_H
+#define __INC_NDIS_COMMONOID_H
+
+#pragma pack(1)
+typedef struct _RTK_DBG_CTRL_OIDS{
+	u2Byte	ctrlType;
+	u2Byte	ctrlDataLen;
+	ULONG	CtrlData;	// head data
+} RTK_DBG_CTRL_OIDS, *PRTK_DBG_CTRL_OIDS;
+
+typedef enum _RTK_DBG_TYPE_OIDS
+{	
+	RTK_DBG_OIDS_BT_PROFILE			=0,
+}RTK_DBG_TYPE_OIDS;
+#pragma pack()
+
+//============================================
+//	Local function
+//============================================
+
+
+//============================================
+//	Extern function
+//============================================
+
+//============================================
+//	For OID Query
+//============================================
+NDIS_STATUS
+OIDQ_RTKReadReg(
+	IN	PADAPTER	Adapter,
+	IN	PVOID		InformationBuffer,
+	IN	ULONG		InformationBufferLength,
+	OUT	PULONG		BytesWritten,
+	OUT	PULONG		BytesNeeded,
+	IN	PULONG		pulInfo
+	);
+NDIS_STATUS
+OIDQ_RTKReadRegSIC(
+	IN	PADAPTER	Adapter,
+	IN	PVOID		InformationBuffer,
+	IN	ULONG		InformationBufferLength,
+	OUT	PULONG		BytesWritten,
+	OUT	PULONG		BytesNeeded,
+	IN	PULONG		pulInfo
+	);
+
+//============================================
+//	For OID Set
+//============================================
+NDIS_STATUS
+OIDS_RTKWriteReg(
+	IN	PADAPTER	Adapter,
+	IN	PVOID		InformationBuffer,
+	IN	ULONG		InformationBufferLength,
+	OUT	PULONG		BytesRead,
+	OUT	PULONG		BytesNeeded
+	);
+NDIS_STATUS
+OIDS_RTKWriteRegSIC(
+	IN	PADAPTER	Adapter,
+	IN	PVOID		InformationBuffer,
+	IN	ULONG		InformationBufferLength,
+	OUT	PULONG		BytesRead,
+	OUT	PULONG		BytesNeeded
+	);
+NDIS_STATUS
+OIDS_RTKDbgControl(
+	IN	PADAPTER	Adapter,
+	IN	PVOID		InformationBuffer,
+	IN	ULONG		InformationBufferLength,
+	OUT	PULONG		BytesRead,
+	OUT	PULONG		BytesNeeded	
+	);
+#endif
diff --git a/network/wlan/WDI/PLATFORM/NdisComm/makefile.Win b/network/wlan/WDI/PLATFORM/NdisComm/makefile.Win
new file mode 100644
index 00000000..6ee4f43f
--- /dev/null
+++ b/network/wlan/WDI/PLATFORM/NdisComm/makefile.Win
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/network/wlan/WDI/PLATFORM/NdisComm/sources.list b/network/wlan/WDI/PLATFORM/NdisComm/sources.list
new file mode 100644
index 00000000..a7fc814e
--- /dev/null
+++ b/network/wlan/WDI/PLATFORM/NdisComm/sources.list
@@ -0,0 +1,13 @@
+//
+// Command:	+(OS, ...) -(OS, ...) [FILE]
+//		//: Comment at the beginning
+//		OS: * Ebd6 Ebd7 WinXP Vista Win7 Win8 WinBlue
+//		+: Add for OS
+//		-: Remove for OS 
+//
+
++(*) [NdisComm.c]
++(*) [NdisOid.c]
+//+(*) [ioctl.c]
++(*) [NdisDbg.c]
+//+(*) [WinCEIrql.c]
\ No newline at end of file
diff --git a/network/wlan/WDI/PLATFORM/NdisComm/sources.props b/network/wlan/WDI/PLATFORM/NdisComm/sources.props
new file mode 100644
index 00000000..42f19b74
--- /dev/null
+++ b/network/wlan/WDI/PLATFORM/NdisComm/sources.props
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <TARGETNAME>NdisComm</TARGETNAME>
+    <TARGETPATH>$(TMP_TARGET_DIR)</TARGETPATH>
+    <TARGETTYPE>DRIVER_LIBRARY</TARGETTYPE>
+    <PRECOMPILED_INCLUDE>Mp_Precomp.h</PRECOMPILED_INCLUDE>
+    <PRECOMPILED_PCH>precomp.pch</PRECOMPILED_PCH>
+    <PRECOMPILED_OBJ>precomp.obj</PRECOMPILED_OBJ>
+    <INCLUDES>
+		.;
+		..;
+		$(SRC_ROOT)\Header;
+		$(SRC_ROOT)\COMMON;
+		$(SRC_ROOT)\Platform\NdisComm;
+		$(HAL_INC_DIRS);
+	</INCLUDES>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SOURCES>
+	</SOURCES>
+  </PropertyGroup>
+</Project>
\ No newline at end of file
diff --git a/network/wlan/WDI/PLATFORM/NdisComm/sources.tpl.props b/network/wlan/WDI/PLATFORM/NdisComm/sources.tpl.props
new file mode 100644
index 00000000..3ad367f7
--- /dev/null
+++ b/network/wlan/WDI/PLATFORM/NdisComm/sources.tpl.props
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <TARGETNAME>NdisComm</TARGETNAME>
+    <TARGETPATH>$(TMP_TARGET_DIR)</TARGETPATH>
+    <TARGETTYPE>DRIVER_LIBRARY</TARGETTYPE>
+    <PRECOMPILED_INCLUDE>Mp_Precomp.h</PRECOMPILED_INCLUDE>
+    <PRECOMPILED_PCH>precomp.pch</PRECOMPILED_PCH>
+    <PRECOMPILED_OBJ>precomp.obj</PRECOMPILED_OBJ>
+    <INCLUDES>
+		.;
+		..;
+		$(SRC_ROOT)\Header;
+		$(SRC_ROOT)\COMMON;
+		$(SRC_ROOT)\Platform\NdisComm;
+		$(HAL_INC_DIRS);
+	</INCLUDES>
+  </PropertyGroup>
+  <Import Project="$(SRC_ROOT)\$(PLATFORM_INC).props" />
+  <PropertyGroup>
+    <SOURCES>
+		<!--TAG_REALTEK_SOURCE_FILES-->
+	</SOURCES>
+  </PropertyGroup>
+</Project>
\ No newline at end of file
diff --git a/network/wlan/WDI/PLATFORM/NdisComm/sources.tpl.win b/network/wlan/WDI/PLATFORM/NdisComm/sources.tpl.win
new file mode 100644
index 00000000..752bda83
--- /dev/null
+++ b/network/wlan/WDI/PLATFORM/NdisComm/sources.tpl.win
@@ -0,0 +1,29 @@
+TARGETNAME=NdisComm
+TARGETPATH=.
+TARGETTYPE=LIBRARY
+
+PRECOMPILED_INCLUDE=Mp_Precomp.h
+PRECOMPILED_PCH=precomp.pch
+PRECOMPILED_OBJ=precomp.obj
+
+#
+# IC dependent directories are defined in 
+# the environment variable HAL_INC_DIRS.
+#
+INCLUDES=	\
+		.;		\
+		..;		\
+		$(SRC_ROOT)\Header;		\
+		$(SRC_ROOT)\COMMON;		\
+		$(SRC_ROOT)\Platform\NdisComm;		\
+		$(HAL_INC_DIRS);					\
+		$(OMNIPEEK_INC_DIRS);	\
+
+#
+# OS and Bus dependent setting.
+#
+!include $(SRC_ROOT)\$(PLATFORM_INC)
+
+SOURCES = <!--TAG_REALTEK_SOURCE_FILES-->
+	
+