[WCNCR00152247] softap: add dfs test cmd
[Description]
Add dfs test cmd show_dfs_state
Add dfs test cmd show_dfs_radar_param
Add dfs test cmd show_dfs_help
Add dfs test cmd show_dfs_time
Change-Id: I5aec2e5227566acb799d6aa91a299ee265eade4a
Feature: softap
Signed-off-by: Chun Lee <chun.lee@mediatek.com>
CR-Id: WCNCR00152247
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)
