diff --git a/include/mgmt/p2p_func.h b/include/mgmt/p2p_func.h
index 7dca620..4262bbd 100644
--- a/include/mgmt/p2p_func.h
+++ b/include/mgmt/p2p_func.h
@@ -58,6 +58,14 @@
 
 #if (CFG_SUPPORT_DFS_MASTER == 1)
 extern P2P_RADAR_INFO_T g_rP2pRadarInfo;
+
+enum _ENUM_DFS_STATE_T {
+	DFS_STATE_INACTIVE = 0,
+	DFS_STATE_CHECKING,
+	DFS_STATE_ACTIVE,
+	DFS_STATE_DETECTED,
+	DFS_STATE_NUM
+};
 #endif
 
 /*******************************************************************************
@@ -151,9 +159,11 @@
 
 BOOLEAN p2pFuncCheckWeatherRadarBand(IN P_P2P_CHNL_REQ_INFO_T prChnlReqInfo);
 
-INT_32 p2pFuncSetManualCacTime(IN UINT_32 u4ManualCacTime);
+INT_32 p2pFuncSetDriverCacTime(IN UINT_32 u4CacTime);
 
-UINT_32 p2pFuncGetManualCacTime(VOID);
+VOID p2pFuncEnableManualCac(VOID);
+
+UINT_32 p2pFuncGetDriverCacTime(VOID);
 
 BOOLEAN p2pFuncIsManualCac(VOID);
 
@@ -161,6 +171,8 @@
 
 VOID p2pFuncShowRadarInfo(IN P_ADAPTER_T prAdapter, IN UINT_8 ucBssIdx);
 
+VOID p2pFuncGetRadarInfo(IN P_P2P_RADAR_INFO_T prP2pRadarInfo);
+
 PUINT_8 p2pFuncJpW53RadarType(VOID);
 
 PUINT_8 p2pFuncJpW56RadarType(VOID);
@@ -168,6 +180,16 @@
 VOID p2pFuncSetRadarDetectMode(IN UINT_8 ucRadarDetectMode);
 
 UINT_8 p2pFuncGetRadarDetectMode(VOID);
+
+VOID p2pFuncSetDfsState(IN UINT_8 ucDfsState);
+
+UINT_8 p2pFuncGetDfsState(VOID);
+
+PUINT_8 p2pFuncShowDfsState(VOID);
+
+VOID p2pFuncRecordCacStartBootTime(VOID);
+
+UINT_32 p2pFuncGetCacRemainingTime(VOID);
 #endif
 
 VOID p2pFuncSetChannel(IN P_ADAPTER_T prAdapter, IN UINT_8 ucRoleIdx, IN P_RF_CHANNEL_INFO_T prRfChannelInfo);
diff --git a/mgmt/cnm.c b/mgmt/cnm.c
index 6ebb334..d2efcb4 100644
--- a/mgmt/cnm.c
+++ b/mgmt/cnm.c
@@ -422,7 +422,7 @@
 	prEventBody = (P_EVENT_RDD_REPORT_T)(prEvent->aucBuffer);
 
 	prP2pRddDetMsg = (P_MSG_P2P_RADAR_DETECT_T) cnmMemAlloc(prAdapter,
-					RAM_TYPE_MSG, sizeof(P_MSG_P2P_RADAR_DETECT_T));
+					RAM_TYPE_MSG, sizeof(*prP2pRddDetMsg));
 
 	prP2pRddDetMsg->rMsgHdr.eMsgId = MID_CNM_P2P_RADAR_DETECT;
 
@@ -435,6 +435,8 @@
 		}
 	}
 
+	p2pFuncSetDfsState(DFS_STATE_DETECTED);
+
 	p2pFuncRadarInfoInit();
 
 	g_rP2pRadarInfo.ucRadarReportMode = prEventBody->ucRadarReportMode;
@@ -467,7 +469,7 @@
 	DBGLOG(CNM, INFO, "cnmCsaDoneEvent.\n");
 
 	prP2pCsaDoneMsg = (P_MSG_P2P_CSA_DONE_T) cnmMemAlloc(prAdapter,
-					RAM_TYPE_MSG, sizeof(P_MSG_P2P_CSA_DONE_T));
+					RAM_TYPE_MSG, sizeof(*prP2pCsaDoneMsg));
 
 	prAdapter->rWifiVar.fgCsaInProgress = FALSE;
 
diff --git a/mgmt/p2p_func.c b/mgmt/p2p_func.c
index e1fdea1..f85d6e6 100644
--- a/mgmt/p2p_func.c
+++ b/mgmt/p2p_func.c
@@ -80,9 +80,18 @@
 
 #if (CFG_SUPPORT_DFS_MASTER == 1)
 BOOLEAN g_fgManualCac = FALSE;
-UINT_32 g_u4ManualCacTime;
-UINT_8 g_ucRadarDetectMode;
+UINT_32 g_u4DriverCacTime;
+UINT_32 g_u4CacStartBootTime;
+UINT_8 g_ucRadarDetectMode = FALSE;
 P2P_RADAR_INFO_T g_rP2pRadarInfo;
+UINT_8 g_ucDfsState = DFS_STATE_INACTIVE;
+static PUINT_8 apucDfsState[DFS_STATE_NUM] = {
+	(PUINT_8) DISP_STRING("DFS_STATE_INACTIVE"),
+	(PUINT_8) DISP_STRING("DFS_STATE_CHECKING"),
+	(PUINT_8) DISP_STRING("DFS_STATE_ACTIVE"),
+	(PUINT_8) DISP_STRING("DFS_STATE_DETECTED")
+};
+
 PUINT_8 apucW53RadarType[3] = {
 	(PUINT_8) DISP_STRING("Unknown Type"),
 	(PUINT_8) DISP_STRING("Type 1 (short pulse)"),
@@ -1207,22 +1216,25 @@
 	return FALSE;
 }
 
-INT_32 p2pFuncSetManualCacTime(IN UINT_32 u4ManualCacTime)
+INT_32 p2pFuncSetDriverCacTime(IN UINT_32 u4CacTime)
 {
 	WLAN_STATUS i4Status = WLAN_STATUS_SUCCESS;
 
-	g_fgManualCac = TRUE;
+	g_u4DriverCacTime = u4CacTime;
 
-	g_u4ManualCacTime = u4ManualCacTime * 1000;
-
-	DBGLOG(P2P, INFO, "p2pFuncSetManualCacTime: g_u4ManualCacTime = %dsec\n", g_u4ManualCacTime/1000);
+	DBGLOG(P2P, INFO, "p2pFuncSetDriverCacTime: g_u4ManualCacTime = %dsec\n", g_u4DriverCacTime);
 
 	return i4Status;
 }
 
-UINT_32 p2pFuncGetManualCacTime(VOID)
+VOID p2pFuncEnableManualCac(VOID)
 {
-	return g_u4ManualCacTime;
+	g_fgManualCac = TRUE;
+}
+
+UINT_32 p2pFuncGetDriverCacTime(VOID)
+{
+	return g_u4DriverCacTime;
 }
 
 BOOLEAN p2pFuncIsManualCac(VOID)
@@ -1232,35 +1244,7 @@
 
 VOID p2pFuncRadarInfoInit(VOID)
 {
-
 	kalMemZero(&g_rP2pRadarInfo, sizeof(g_rP2pRadarInfo));
-
-/*	UINT_8 ucCnt;
-
-	g_rP2pRadarInfo.ucRadarReportMode = 0;
-	g_rP2pRadarInfo.ucRddIdx = 0;
-	g_rP2pRadarInfo.ucLongDetected = 0;
-	g_rP2pRadarInfo.ucPeriodicDetected = 0;
-	g_rP2pRadarInfo.ucLPBNum = 0;
-	g_rP2pRadarInfo.ucPPBNum = 0;
-	g_rP2pRadarInfo.ucLPBPeriodValid = 0;
-	g_rP2pRadarInfo.ucLPBWidthValid = 0;
-	g_rP2pRadarInfo.ucPRICountM1 = 0;
-	g_rP2pRadarInfo.ucPRICountM1TH = 0;
-	g_rP2pRadarInfo.ucPRICountM2 = 0;
-	g_rP2pRadarInfo.ucPRICountM2TH = 0;
-	g_rP2pRadarInfo.u4PRI1stUs = 0;
-
-	for (ucCnt = 0; ucCnt < 32; ucCnt++) {
-		g_rP2pRadarInfo.arPpbContent[ucCnt].u4PeriodicStartTime = 0;
-		g_rP2pRadarInfo.arPpbContent[ucCnt].u2PeriodicPulseWidth = 0;
-	}
-	for (ucCnt = 0; ucCnt < 32; ucCnt++) {
-		g_rP2pRadarInfo.arLpbContent[ucCnt].u4LongStartTime = 0;
-		g_rP2pRadarInfo.arLpbContent[ucCnt].u2LongPulseWidth = 0;
-	}
-*/
-
 }
 
 VOID p2pFuncShowRadarInfo(IN P_ADAPTER_T prAdapter, IN UINT_8 ucBssIdx)
@@ -1300,7 +1284,7 @@
 
 		DBGLOG(P2P, INFO, "Radar Content:\n");
 
-		DBGLOG(P2P, INFO, "start time	pulse width	PRI\n");
+		DBGLOG(P2P, INFO, "start time    pulse width    PRI\n");
 
 		if (g_rP2pRadarInfo.ucPeriodicDetected) {
 			DBGLOG(P2P, INFO, "%-10d    %-11d    -\n"
@@ -1330,6 +1314,11 @@
 	}
 }
 
+VOID p2pFuncGetRadarInfo(IN P_P2P_RADAR_INFO_T prP2pRadarInfo)
+{
+	kalMemCopy(prP2pRadarInfo, &g_rP2pRadarInfo, sizeof(*prP2pRadarInfo));
+}
+
 PUINT_8 p2pFuncJpW53RadarType(VOID)
 {
 	UINT_32 u4Type1Diff;
@@ -1409,6 +1398,41 @@
 {
 	return g_ucRadarDetectMode;
 }
+
+VOID p2pFuncSetDfsState(IN UINT_8 ucDfsState)
+{
+	DBGLOG(P2P, INFO, "[DFS_STATE] TRANSITION: [%s] -> [%s]\n",
+		apucDfsState[g_ucDfsState], apucDfsState[ucDfsState]);
+
+	g_ucDfsState = ucDfsState;
+}
+
+UINT_8 p2pFuncGetDfsState(VOID)
+{
+	return g_ucDfsState;
+}
+
+PUINT_8 p2pFuncShowDfsState(VOID)
+{
+	return apucDfsState[g_ucDfsState];
+}
+
+VOID p2pFuncRecordCacStartBootTime(VOID)
+{
+	g_u4CacStartBootTime = kalGetBootTime();
+}
+
+UINT_32 p2pFuncGetCacRemainingTime(VOID)
+{
+	UINT_32 u4CurrentBootTime;
+	UINT_32 u4CacRemainingTime;
+
+	u4CurrentBootTime = kalGetBootTime();
+
+	u4CacRemainingTime = g_u4DriverCacTime - (u4CurrentBootTime - g_u4CacStartBootTime)/1000000;
+
+	return u4CacRemainingTime;
+}
 #endif
 
 #if 0
diff --git a/mgmt/p2p_role_fsm.c b/mgmt/p2p_role_fsm.c
index a7b96dd..2462247 100644
--- a/mgmt/p2p_role_fsm.c
+++ b/mgmt/p2p_role_fsm.c
@@ -445,6 +445,7 @@
 		case P2P_ROLE_STATE_DFS_CAC:
 			p2pRoleFsmStateTransition(prAdapter, prP2pRoleFsmInfo, P2P_ROLE_STATE_IDLE);
 			kalP2PCacFinishedUpdate(prAdapter->prGlueInfo, prP2pRoleFsmInfo->ucRoleIndex);
+			p2pFuncSetDfsState(DFS_STATE_ACTIVE);
 			break;
 #endif
 		default:
@@ -1069,6 +1070,7 @@
 			break;
 
 #if (CFG_SUPPORT_DFS_MASTER == 1)
+		p2pFuncSetDfsState(DFS_STATE_INACTIVE);
 		p2pFuncStopRdd(prAdapter, prP2pBssInfo->ucBssIndex);
 #endif
 
@@ -1218,13 +1220,17 @@
 				prP2pRoleFsmInfo->eCurrentState != P2P_ROLE_STATE_IDLE)
 			ASSERT(FALSE);
 
-		if (p2pFuncGetRadarDetectMode())
+		if (p2pFuncGetRadarDetectMode()) {
 			DBGLOG(P2P, INFO, "p2pRoleFsmRunEventRadarDet: Ignore radar event\n");
-		else {
-		if (prP2pRoleFsmInfo->eCurrentState == P2P_ROLE_STATE_DFS_CAC)
-			p2pRoleFsmStateTransition(prAdapter, prP2pRoleFsmInfo, P2P_ROLE_STATE_IDLE);
+			if (prP2pRoleFsmInfo->eCurrentState == P2P_ROLE_STATE_DFS_CAC)
+				p2pFuncSetDfsState(DFS_STATE_CHECKING);
+			else
+				p2pFuncSetDfsState(DFS_STATE_ACTIVE);
+		} else {
+			if (prP2pRoleFsmInfo->eCurrentState == P2P_ROLE_STATE_DFS_CAC)
+				p2pRoleFsmStateTransition(prAdapter, prP2pRoleFsmInfo, P2P_ROLE_STATE_IDLE);
 
-		kalP2PRddDetectUpdate(prAdapter->prGlueInfo, prP2pRoleFsmInfo->ucRoleIndex);
+			kalP2PRddDetectUpdate(prAdapter->prGlueInfo, prP2pRoleFsmInfo->ucRoleIndex);
 		}
 
 		p2pFuncShowRadarInfo(prAdapter, prMsgP2pRddDetMsg->ucBssIndex);
@@ -1939,7 +1945,7 @@
 	P_MSG_CH_GRANT_T prMsgChGrant = (P_MSG_CH_GRANT_T) NULL;
 #if (CFG_SUPPORT_DFS_MASTER == 1)
 	P_BSS_INFO_T prP2pBssInfo = (P_BSS_INFO_T) NULL;
-	UINT_32 u4CacTime;
+	UINT_32 u4CacTimeMs;
 #endif
 	UINT_8 ucTokenID = 0;
 
@@ -1991,18 +1997,24 @@
 				p2pFuncStartRdd(prAdapter, prMsgChGrant->ucBssIndex);
 
 				if (p2pFuncCheckWeatherRadarBand(prChnlReqInfo))
-					u4CacTime = P2P_AP_CAC_WEATHER_CHNL_HOLD_TIME_MS;
+					u4CacTimeMs = P2P_AP_CAC_WEATHER_CHNL_HOLD_TIME_MS;
 				else
-					u4CacTime = prP2pRoleFsmInfo->rChnlReqInfo.u4MaxInterval;
+					u4CacTimeMs = prP2pRoleFsmInfo->rChnlReqInfo.u4MaxInterval;
 
 				if (p2pFuncIsManualCac())
-					u4CacTime = p2pFuncGetManualCacTime();
+					u4CacTimeMs = p2pFuncGetDriverCacTime() * 1000;
+				else
+					p2pFuncSetDriverCacTime(u4CacTimeMs/1000);
 
 				cnmTimerStartTimer(prAdapter, &(prP2pRoleFsmInfo->rP2pRoleFsmTimeoutTimer),
-					u4CacTime);
+					u4CacTimeMs);
+
+				p2pFuncRecordCacStartBootTime();
+
+				p2pFuncSetDfsState(DFS_STATE_CHECKING);
 
 				DBGLOG(P2P, INFO, "p2pRoleFsmRunEventChnlGrant: CAC time = %ds\n",
-					u4CacTime/1000);
+					u4CacTimeMs/1000);
 				break;
 			case P2P_ROLE_STATE_SWITCH_CHANNEL:
 				p2pFuncDfsSwitchCh(prAdapter, prP2pBssInfo, prP2pRoleFsmInfo->rChnlReqInfo);
diff --git a/os/linux/gl_ate_agent.c b/os/linux/gl_ate_agent.c
index 23e766e..50f02dd 100644
--- a/os/linux/gl_ate_agent.c
+++ b/os/linux/gl_ate_agent.c
@@ -2043,6 +2043,16 @@
 	DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv Set RDD Report, prInBuf: %s\n", prInBuf);
 	DBGLOG(INIT, ERROR, "MT6632 : ATE_AGENT iwpriv Set RDD Report : Band %d\n", dbdcIdx);
 
+	if (p2pFuncGetDfsState() == DFS_STATE_INACTIVE || p2pFuncGetDfsState() == DFS_STATE_DETECTED) {
+		DBGLOG(REQ, ERROR, "RDD Report is not supported in this DFS state (inactive or deteted)\n");
+		return WLAN_STATUS_NOT_SUPPORTED;
+	}
+
+	if (dbdcIdx != 0 && dbdcIdx != 1) {
+		DBGLOG(REQ, ERROR, "RDD index is not \"0\" or \"1\", Invalid data\n");
+		return WLAN_STATUS_INVALID_DATA;
+	}
+
 	ucDbdcIdx = (UINT_8) dbdcIdx;
 
 	if (rv == 0)
@@ -2080,10 +2090,17 @@
 	DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv Set By Pass Cac, prInBuf: %s\n", prInBuf);
 	DBGLOG(INIT, ERROR, "MT6632 : ATE_AGENT iwpriv Set By Pass Cac : %dsec\n", i4ByPassCacTime);
 
+	if (i4ByPassCacTime < 0) {
+		DBGLOG(REQ, ERROR, "Cac time < 0, Invalid data\n");
+		return WLAN_STATUS_INVALID_DATA;
+	}
+
 	u4ByPassCacTime = (UINT_32) i4ByPassCacTime;
 
+	p2pFuncEnableManualCac();
+
 	if (rv == 0)
-		i4Status = p2pFuncSetManualCacTime(u4ByPassCacTime);
+		i4Status = p2pFuncSetDriverCacTime(u4ByPassCacTime);
 	else
 		return -EINVAL;
 
@@ -2116,13 +2133,18 @@
 	DBGLOG(REQ, INFO, "MT6632 : ATE_AGENT iwpriv Set Radar Detect Mode, prInBuf: %s\n", prInBuf);
 	DBGLOG(INIT, ERROR, "MT6632 : ATE_AGENT iwpriv Set Radar Detect Mode : %d\n", radarDetectMode);
 
-	ucRadarDetectMode = (UINT_8) radarDetectMode;
+	if (p2pFuncGetDfsState() == DFS_STATE_INACTIVE || p2pFuncGetDfsState() == DFS_STATE_DETECTED) {
+		DBGLOG(REQ, ERROR, "RDD Report is not supported in this DFS state (inactive or deteted)\n");
+		return WLAN_STATUS_NOT_SUPPORTED;
+	}
 
-	if (ucRadarDetectMode > 1) {
-		DBGLOG(REQ, ERROR, "Radar Detect Mode > 1, Invalid data\n");
+	if (radarDetectMode != 0 && radarDetectMode != 1) {
+		DBGLOG(REQ, ERROR, "Radar Detect Mode is not \"0\" or \"1\", Invalid data\n");
 		return WLAN_STATUS_INVALID_DATA;
 	}
 
+	ucRadarDetectMode = (UINT_8) radarDetectMode;
+
 	p2pFuncSetRadarDetectMode(ucRadarDetectMode);
 
 	if (rv == 0)
diff --git a/os/linux/gl_p2p_cfg80211.c b/os/linux/gl_p2p_cfg80211.c
index d3a82b3..cd4ce9a 100644
--- a/os/linux/gl_p2p_cfg80211.c
+++ b/os/linux/gl_p2p_cfg80211.c
@@ -1242,6 +1242,11 @@
 		pucBuffer = prP2pBcnUpdateMsg->aucBuffer;
 		DBGLOG(P2P, INFO, "mtk_p2p_cfg80211_start_ap.(role %d)\n", ucRoleIdx);
 
+#if (CFG_SUPPORT_DFS_MASTER == 1)
+		if (p2pFuncGetDfsState() == DFS_STATE_DETECTED) {
+			p2pFuncSetDfsState(DFS_STATE_INACTIVE);
+		}
+#endif
 		if (settings->beacon.head_len != 0) {
 			kalMemCopy(pucBuffer, settings->beacon.head, settings->beacon.head_len);
 
@@ -1400,8 +1405,10 @@
 
 		DBGLOG(P2P, INFO, "mtk_p2p_cfg80211_start_radar_detection.(role %d)\n", ucRoleIdx);
 
+		p2pFuncSetDfsState(DFS_STATE_INACTIVE);
+
 		prP2pDfsCacMsg = (P_MSG_P2P_DFS_CAC_T) cnmMemAlloc(prGlueInfo->prAdapter,
-								RAM_TYPE_MSG, sizeof(MSG_P2P_DFS_CAC_T));
+								RAM_TYPE_MSG, sizeof(*prP2pDfsCacMsg));
 
 		if (prP2pDfsCacMsg == NULL) {
 			ASSERT(FALSE);
@@ -1512,6 +1519,8 @@
 
 		DBGLOG(P2P, INFO, "mtk_p2p_cfg80211_channel_switch.(role %d)\n", ucRoleIdx);
 
+		p2pFuncSetDfsState(DFS_STATE_INACTIVE);
+
 		/* Set CSA IE parameters */
 		prGlueInfo->prAdapter->rWifiVar.fgCsaInProgress = TRUE;
 		prGlueInfo->prAdapter->rWifiVar.ucChannelSwitchMode = 1;
@@ -1521,7 +1530,7 @@
 
 		/* Set new channel parameters */
 		prP2pSetNewChannelMsg = (P_MSG_P2P_SET_NEW_CHANNEL_T) cnmMemAlloc(prGlueInfo->prAdapter,
-								RAM_TYPE_MSG, sizeof(P_MSG_P2P_SET_NEW_CHANNEL_T));
+								RAM_TYPE_MSG, sizeof(*prP2pSetNewChannelMsg));
 
 		if (prP2pSetNewChannelMsg == NULL) {
 			ASSERT(FALSE);
diff --git a/os/linux/gl_wext_priv.c b/os/linux/gl_wext_priv.c
index b25d611..a5d38f8 100644
--- a/os/linux/gl_wext_priv.c
+++ b/os/linux/gl_wext_priv.c
@@ -2232,6 +2232,13 @@
 #define CMD_SETROAMMODE	"SETROAMMODE"
 #define CMD_MIRACAST		"MIRACAST"
 
+#if (CFG_SUPPORT_DFS_MASTER == 1)
+#define CMD_SHOW_DFS_STATE			"SHOW_DFS_STATE"
+#define CMD_SHOW_DFS_RADAR_PARAM	"SHOW_DFS_RADAR_PARAM"
+#define CMD_SHOW_DFS_HELP			"SHOW_DFS_HELP"
+#define CMD_SHOW_DFS_CAC_TIME		"SHOW_DFS_CAC_TIME"
+#endif
+
 #define CMD_PNOSSIDCLR_SET	"PNOSSIDCLR"
 #define CMD_PNOSETUP_SET	"PNOSETUP "
 #define CMD_PNOENABLE_SET	"PNOFORCE"
@@ -6794,7 +6801,173 @@
 	return i4BytesWritten;
 }
 
+#if (CFG_SUPPORT_DFS_MASTER == 1)
+int priv_driver_show_dfs_state(IN struct net_device *prNetDev, IN char *pcCommand, IN int i4TotalLen)
+{
+	INT_32 i4Argc = 0;
+	PCHAR apcArgv[WLAN_CFG_ARGV_MAX];
+	INT_32 i4BytesWritten = 0;
 
+	ASSERT(prNetDev);
+	if (GLUE_CHK_PR2(prNetDev, pcCommand) == FALSE)
+		return -1;
+
+	DBGLOG(REQ, LOUD, "command is %s\n", pcCommand);
+	wlanCfgParseArgument(pcCommand, &i4Argc, apcArgv);
+	DBGLOG(REQ, LOUD, "argc is %i\n", i4Argc);
+
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nDFS State: \"%s\"",
+			p2pFuncShowDfsState());
+
+	return	i4BytesWritten;
+}
+
+int priv_driver_show_dfs_radar_param(IN struct net_device *prNetDev, IN char *pcCommand, IN int i4TotalLen)
+{
+	P_GLUE_INFO_T prGlueInfo = NULL;
+	INT_32 i4Argc = 0;
+	PCHAR apcArgv[WLAN_CFG_ARGV_MAX];
+	INT_32 i4BytesWritten = 0;
+	UINT_8 ucCnt = 0;
+	P_P2P_RADAR_INFO_T prP2pRadarInfo = (P_P2P_RADAR_INFO_T) NULL;
+
+	ASSERT(prNetDev);
+	if (GLUE_CHK_PR2(prNetDev, pcCommand) == FALSE)
+		return -1;
+	prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prNetDev));
+
+	prP2pRadarInfo = (P_P2P_RADAR_INFO_T) cnmMemAlloc(prGlueInfo->prAdapter,
+		RAM_TYPE_MSG, sizeof(*prP2pRadarInfo));
+
+	DBGLOG(REQ, LOUD, "command is %s\n", pcCommand);
+	wlanCfgParseArgument(pcCommand, &i4Argc, apcArgv);
+	DBGLOG(REQ, LOUD, "argc is %i\n", i4Argc);
+
+	p2pFuncGetRadarInfo(prP2pRadarInfo);
+
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nRDD idx: %d\n",
+			prP2pRadarInfo->ucRddIdx);
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nLong Pulse detected: %d\n",
+			prP2pRadarInfo->ucLongDetected);
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nPeriodic Pulse detected: %d\n",
+			prP2pRadarInfo->ucPeriodicDetected);
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nLPB Num: %d\n",
+			prP2pRadarInfo->ucLPBNum);
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nPPB Num: %d\n",
+			prP2pRadarInfo->ucPPBNum);
+
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\n===========================");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nLong Pulse Buffer Contents:\n");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\npulse_time    pulse_width    PRI\n");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\n%-10d    %-11d    -\n"
+		, prP2pRadarInfo->arLpbContent[ucCnt].u4LongStartTime
+		, prP2pRadarInfo->arLpbContent[ucCnt].u2LongPulseWidth);
+	for (ucCnt = 1; ucCnt < prP2pRadarInfo->ucLPBNum; ucCnt++) {
+		LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\n%-10d    %-11d    %d\n"
+			, prP2pRadarInfo->arLpbContent[ucCnt].u4LongStartTime
+			, prP2pRadarInfo->arLpbContent[ucCnt].u2LongPulseWidth
+			, (prP2pRadarInfo->arLpbContent[ucCnt].u4LongStartTime
+				- prP2pRadarInfo->arLpbContent[ucCnt-1].u4LongStartTime) * 2 / 5);
+	}
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nLPB Period Valid: %d",
+			prP2pRadarInfo->ucLPBPeriodValid);
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nLPB Period Valid: %d\n",
+			prP2pRadarInfo->ucLPBWidthValid);
+
+	ucCnt = 0;
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\n===========================");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nPeriod Pulse Buffer Contents:\n");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\npulse_time    pulse_width    PRI\n");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\n%-10d    %-11d    -\n"
+		, prP2pRadarInfo->arPpbContent[ucCnt].u4PeriodicStartTime
+		, prP2pRadarInfo->arPpbContent[ucCnt].u2PeriodicPulseWidth);
+	for (ucCnt = 1; ucCnt < prP2pRadarInfo->ucPPBNum; ucCnt++) {
+		LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\n%-10d    %-11d    %d\n"
+			, prP2pRadarInfo->arPpbContent[ucCnt].u4PeriodicStartTime
+			, prP2pRadarInfo->arPpbContent[ucCnt].u2PeriodicPulseWidth
+			, (prP2pRadarInfo->arPpbContent[ucCnt].u4PeriodicStartTime
+				- prP2pRadarInfo->arPpbContent[ucCnt-1].u4PeriodicStartTime) * 2 / 5);
+	}
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nPRI Count M1 TH: %d; PRI Count M1: %d",
+			prP2pRadarInfo->ucPRICountM1TH, prP2pRadarInfo->ucPRICountM1);
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nPRI Count M2 TH: %d; PRI Count M2: %d",
+			prP2pRadarInfo->ucPRICountM2TH, prP2pRadarInfo->ucPRICountM2);
+
+
+	cnmMemFree(prGlueInfo->prAdapter, prP2pRadarInfo);
+
+	return	i4BytesWritten;
+}
+
+int priv_driver_show_dfs_help(IN struct net_device *prNetDev, IN char *pcCommand, IN int i4TotalLen)
+{
+	INT_32 i4Argc = 0;
+	PCHAR apcArgv[WLAN_CFG_ARGV_MAX];
+	INT_32 i4BytesWritten = 0;
+
+	ASSERT(prNetDev);
+	if (GLUE_CHK_PR2(prNetDev, pcCommand) == FALSE)
+		return -1;
+
+	DBGLOG(REQ, LOUD, "command is %s\n", pcCommand);
+	wlanCfgParseArgument(pcCommand, &i4Argc, apcArgv);
+	DBGLOG(REQ, LOUD, "argc is %i\n", i4Argc);
+
+
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\n--iwpriv wlanX driver \"show_dfs_state\"\n");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nINACTIVE: RDD disable or temporary RDD disable");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nCHECKING: During CAC time");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nACTIVE  : In-serive monitoring");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten,
+		"\nDETECTED: Has detected radar but hasn't moved to new channel\n");
+
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\n--iwpriv wlanX driver \"show_dfs_radar_param\"\n");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nShow the latest pulse information\n");
+
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\n--iwpriv wlanX driver \"show_dfs_cac_time\"\n");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nShow the remaining time of CAC\n");
+
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\n--iwpriv wlanX set ByPassCac=yy\n");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nValue yy: set the time of CAC\n");
+
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\n--iwpriv wlanX set RDDReport=yy\n");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nValue yy is \"0\" or \"1\"");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\n\"0\": Emulate RDD0 manual radar event");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\n\"1\": Emulate RDD1 manual radar event\n");
+
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\n--iwpriv wlanX set RadarDetectMode=yy\n");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nValue yy is \"0\" or \"1\"");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\n\"0\": Switch channel when radar detected (default)");
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\n\"1\": Do not switch channel when radar detected");
+
+	return	i4BytesWritten;
+}
+
+int priv_driver_show_dfs_cac_time(IN struct net_device *prNetDev, IN char *pcCommand, IN int i4TotalLen)
+{
+	INT_32 i4Argc = 0;
+	PCHAR apcArgv[WLAN_CFG_ARGV_MAX];
+	INT_32 i4BytesWritten = 0;
+
+	ASSERT(prNetDev);
+	if (GLUE_CHK_PR2(prNetDev, pcCommand) == FALSE)
+		return -1;
+
+	DBGLOG(REQ, LOUD, "command is %s\n", pcCommand);
+	wlanCfgParseArgument(pcCommand, &i4Argc, apcArgv);
+	DBGLOG(REQ, LOUD, "argc is %i\n", i4Argc);
+
+	if (p2pFuncGetDfsState() != DFS_STATE_CHECKING) {
+		LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nNot in CAC period");
+		return i4BytesWritten;
+	}
+
+	LOGBUF(pcCommand, i4TotalLen, i4BytesWritten, "\nRemaining time of CAC: %dsec", p2pFuncGetCacRemainingTime());
+
+	return	i4BytesWritten;
+}
+
+#endif
 int priv_driver_set_miracast(IN struct net_device *prNetDev, IN char *pcCommand, IN int i4TotalLen)
 {
 
@@ -9044,6 +9217,17 @@
 		} else if (strnicmp(pcCommand, CMD_CLEAR_ACL_ENTRY, strlen(CMD_CLEAR_ACL_ENTRY)) == 0) {
 			i4BytesWritten = priv_driver_clear_acl_entry(prNetDev, pcCommand, i4TotalLen);
 		}
+#if (CFG_SUPPORT_DFS_MASTER == 1)
+		else if (strnicmp(pcCommand, CMD_SHOW_DFS_STATE, strlen(CMD_SHOW_DFS_STATE)) == 0) {
+			i4BytesWritten = priv_driver_show_dfs_state(prNetDev, pcCommand, i4TotalLen);
+		} else if (strnicmp(pcCommand, CMD_SHOW_DFS_RADAR_PARAM, strlen(CMD_SHOW_DFS_RADAR_PARAM)) == 0) {
+			i4BytesWritten = priv_driver_show_dfs_radar_param(prNetDev, pcCommand, i4TotalLen);
+		} else if (strnicmp(pcCommand, CMD_SHOW_DFS_HELP, strlen(CMD_SHOW_DFS_HELP)) == 0) {
+			i4BytesWritten = priv_driver_show_dfs_help(prNetDev, pcCommand, i4TotalLen);
+		} else if (strnicmp(pcCommand, CMD_SHOW_DFS_CAC_TIME, strlen(CMD_SHOW_DFS_CAC_TIME)) == 0) {
+			i4BytesWritten = priv_driver_show_dfs_cac_time(prNetDev, pcCommand, i4TotalLen);
+		}
+#endif
 #if CFG_SUPPORT_CAL_RESULT_BACKUP_TO_HOST
 		else if (strnicmp(pcCommand,
 			CMD_SET_CALBACKUP_TEST_DRV_FW, strlen(CMD_SET_CALBACKUP_TEST_DRV_FW)) == 0)