--- ./source/private_module/hdm/hdm_debug.c	2018-02-09 07:36:26.000000000 +0000
+++ ./source/private_module/hdm/hdm_debug.c.hotpatch	2023-01-05 15:02:07.000000000 +0000
@@ -1,15 +1,15 @@
 /**************************************************************************
-     Ȩ (C) 2012 - 2012  Ϊּ(ɶ)޹˾
+     版权所有 (C) 2012 - 2012  华为数字技术(成都)有限公司
 ***************************************************************************
-*   : 
-*     : w90006892
-* : 2012821
-* : HDMԽӿ
-*     ע: 
-* ޸ļ¼: 
-*        1.ʱ    : 
-*            : 
-*          ޸: 
+* 版 本 号: 初稿
+* 作    者: w90006892
+* 生成日期: 2012年8月21日
+* 功能描述: HDM调试接口
+* 备    注: 
+* 修改记录: 
+*        1.时    间: 
+*          修 改 人: 
+*          修改内容: 
 **************************************************************************/
 #include "bdm_inc.h"
 #include "bdm_common.h"
@@ -37,9 +37,9 @@
 #include "hdm_pool_manage.h"
 #include "hdm_debug.h"
 #include "hdm_id.h"
-
+#include "customize.h"
+#include "econf.h"
 #include "stub_hdm_debug.h"
-
 /* Dorado 5000 modified begin */
 #include "bdm_nvme_intf.h"
 #include "hdm_nvme_intf.h"
@@ -53,8 +53,8 @@
 uint8_t g_hdmDbgBuffer[HDM_DBG_BUFF_LEN];
 static HDM_RT_BY_FM_VAR_S g_hdmDbgFmRtConf;
 
-extern uint32_t g_quickDiagDelaySec;     /* ӳٿʼʱ䣬ɲ */
-extern uint32_t g_normalDiagDelaySec;    /* ӳٿʼʱ䣬ɲ */
+extern uint32_t g_quickDiagDelaySec;     /* 快速诊断延迟开始时间，可测试性 */
+extern uint32_t g_normalDiagDelaySec;    /* 正常诊断延迟开始时间，可测试性 */
 
 extern bool g_hssdCapRtSwitch;
 
@@ -63,7 +63,7 @@
 extern HDM_DEBUG_CMD_S g_hdmDebugCliShowCmd[];
 static struct list_head g_cliCmdListHead = LIST_HEAD_INIT(g_cliCmdListHead);
 static BDM_DEBUG_CMD_S g_cliCmdShow = {{NULL,NULL}, "show", hdmDebugCliShowCmd, hdmDebugCliShowHelp, hdmDebugCliDestroy};
-/* ʽַ */
+/* 格式化结果字符串 */
 static const char *g_hdmFmtResult[HDM_FMAT_BUTT + 1] =
 {
     "Format has stop. Since disk in, last format complete 100%",
@@ -89,12 +89,12 @@
 /*End Modified by s00400440 DTS2017020600398 20170123 */
 
 /**************************************************************************
-   : hdmDebugIsRootDisk
-     : ͨsd idѯǷroot
- : sdevId : sd豸id
- : 
-   ֵ: TRUE root FALSE root
-     : 
+ 函 数 名: hdmDebugIsRootDisk
+ 功    能: 通过sd id查询是否root盘
+ 输入参数: sdevId : sd的设备id
+ 输出参数: 无
+ 返 回 值: TRUE root盘 FALSE 非root盘
+ 其    它: 无
 **************************************************************************/
 bool hdmDebugIsRootDiskBySdId(uint32_t sdevId)
 {
@@ -105,7 +105,7 @@
     sdDev = HDM_GET_SD_DEV(sdevId);
     if (NULL == sdDev)
     {
-        /* ѯʧܣroot̴ */
+        /* 查询失败，当做非root盘处理 */
         return FALSE;
     }
 
@@ -116,12 +116,12 @@
 }
 
 /**************************************************************************
-   : hdmDebugGetSdevId
-     : ַȡ豸ID
- : const char *strDevId  
- : 
-   ֵ: 豸ID
-     : 
+ 函 数 名: hdmDebugGetSdevId
+ 功    能: 根据字符串获取设备ID
+ 输入参数: const char *strDevId  
+ 输出参数: 无
+ 返 回 值: 设备ID
+ 其    它: 无
 **************************************************************************/
 uint32_t hdmDebugGetSdevId(const char *strDevId)
 {
@@ -138,13 +138,13 @@
 }
 
 /**************************************************************************
-   : hdmGetRetMsg
-     : ݷֵʾϢ
- : const char *cmdName : 
-           int32_t result      : ֵ
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmGetRetMsg
+ 功    能: 根据返回值显示相关信息
+ 输入参数: const char *cmdName : 命令名称
+           int32_t result      : 返回值
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmShowRetMsg(const char *cmdName, int32_t result)
 {
@@ -174,13 +174,13 @@
 }
 
 /**************************************************************************
-   : hdmDebugStateDone
-     : ״̬ص
- : void *context :  
-           bool state    : 첽ִн(ɹ/ʧ) 
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugStateDone
+ 功    能: 状态回调函数
+ 输入参数: void *context : 上下文 
+           bool state    : 异步函数执行结果(成功/失败) 
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugStateDone(void *context, bool state)
 {
@@ -191,13 +191,13 @@
 }
 
 /**************************************************************************
-   : hdmDebugResultDone
-     : ص
- : void *context  :  
-           int32_t result : 첽ִн 
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugResultDone
+ 功    能: 结果回调函数
+ 输入参数: void *context  : 上下文 
+           int32_t result : 异步函数执行结果 
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugResultDone(void *context, int32_t result)
 {
@@ -209,14 +209,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugResultStateDone
-     : ״̬ص
- : void *context  :  
-           int32_t result : 첽ִн 
-           bool state     : 첽ص״̬ 
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugResultStateDone
+ 功    能: 结果和状态回调函数
+ 输入参数: void *context  : 上下文 
+           int32_t result : 异步函数执行结果 
+           bool state     : 异步函数返回的状态 
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugResultStateDone(void *context, int32_t result, bool state)
 {
@@ -230,13 +230,13 @@
 }
 
 /**************************************************************************
-    : ӲFW
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : ָfirmwareļ
+功    能: 硬盘FW升级
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 根据指定firmware文件升级
 **************************************************************************/
 int32_t hdmDebugFwUpgrade(int32_t argc, char *argv[])
 {    
@@ -302,13 +302,13 @@
 }
 
 /**************************************************************************
-    : ӲFW
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : firmware汾Ž
+功    能: 硬盘FW升级
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 根据firmware版本号进行升级
 **************************************************************************/
 int32_t hdmDebugFwUpgradeExp(int32_t argc, char *argv[])
 {
@@ -348,14 +348,14 @@
 }
 
 /**************************************************************************
-    : SATA̵NCQܻص
-: context: 
-          result: ncqز
-          switchFlag: ǰncq״̬
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : 
+功    能: 开关SATA盘的NCQ功能回调函数
+输入参数: context: 调用者上下文
+          result: ncq开关操作结果
+          switchFlag: 当前ncq开关状态
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 无
 **************************************************************************/
 void hdmDebugNcqSwtichDone(void *context, int32_t result, uint32_t switchFlag)
 {
@@ -368,13 +368,13 @@
 }
 
 /**************************************************************************
-    : SATA̵NCQ
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : 
+功    能: 开关SATA盘的NCQ功能
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugNcqSwtich(int32_t argc, char *argv[])
 {
@@ -431,13 +431,13 @@
 
 
 /**************************************************************************
-    : ӲPHY
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : 
+功    能: 开关硬盘PHY
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugPhySwitch(int32_t argc, char *argv[])
 {
@@ -483,13 +483,13 @@
 }
 
 /**************************************************************************
-    : BGMS
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : 
+功    能: 开关BGMS功能
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugBgmsSwitch(int32_t argc, char *argv[])
 {
@@ -510,7 +510,7 @@
     sdevId = (uint32_t)LVOS_StrToU64(argv[2]);
     switchFlag = (uint8_t)LVOS_StrToU64(argv[3]);
     /*Begin Modified by y00406735 DTS2017041305135   20170413*/
-    /*жsdevIdЧ*/
+    /*判断sdevId的有效性*/
     if ( unlikely(sdevId >= SD_MAX_DEVICE_NUM) )
     {
         DBG_Print("device ID (%u) is invalid.\n",sdevId);
@@ -563,13 +563,13 @@
 }
 
 /**************************************************************************
-    : Ӳһθλʱ
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : 
+功    能: 检查允许硬盘下一次复位的时间点
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugAllResetTime(int32_t argc, char *argv[])
 {
@@ -592,13 +592,13 @@
 
 
 /**************************************************************************
-    : ѯhdmǰSD豸ü
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : 
+功    能: 查询hdm当前对SD设备的引用计数
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugUseSdCnt(int32_t argc, char *argv[])
 {
@@ -623,7 +623,7 @@
         type = (uint32_t)LVOS_StrToU64(argv[2]);
         delaySec = (uint32_t)LVOS_StrToU64(argv[3]);   
         /*Begin Modified by y00406735 DTS2017041305135    20170413*/
-        /*ƿϺͨϵӳʱ1~300s */
+        /*限制快速诊断和普通诊断的延迟时间1~300s */
         if ((1 > delaySec) || (300 < delaySec))
         {
             DBG_Print("Normal diagnose and Quick diagnose delay(sec) must be in [1 -300].\n");
@@ -655,14 +655,14 @@
 
 
 /**************************************************************************
-   : self-testܻص
-     : ȡӲFWϷԵĵԺ
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: 开关self-test功能回调函数
+ 功    能: 获取硬盘FW合法性的调试函数
+ 输入参数: int32_t argc : 输入参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 void hdmDebugSelfTestSwitchDone(void *context, SELF_TEST_SWITCH_RESULT_E stState)
 {
@@ -672,14 +672,14 @@
 
 
 /**************************************************************************
-   : self-test
-     : ͹رӲ̵self-test
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: 开关self-test功能
+ 功    能: 开启和关闭硬盘的self-test
+ 输入参数: int32_t argc : 输入参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugSelfTestSwitch(int32_t argc, char *argv[])
 {
@@ -775,13 +775,13 @@
 
 
 /**************************************************************************
-    : ѯself-test״̬ص
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : 
+功    能: 查询self-test状态回调函数
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 无
 **************************************************************************/
 void hdmDebugSelfTestQueryDone(void *context, int32_t result, SELF_TEST_STATE_S state)
 {
@@ -796,13 +796,13 @@
 }
 
 /**************************************************************************
-    : ѯself-test״̬
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : 
+功    能: 查询self-test状态
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugSelfTestQuery(int32_t argc, char *argv[])
 {
@@ -829,7 +829,7 @@
         return RETURN_OK;
     }
     
-    /* Dorado 5000 modified begin 20161228 diagnoseģʱģԼṩ֮ٸһ*/
+    /* Dorado 5000 modified begin 20161228 diagnose命令整改，这里暂时这样整改，后面自研盘自检命令提供出来之后再改一次*/
     ret = sdIsNvmeDevById(sdevId, &isNvmeDevice);
     if (RETURN_OK != ret)
     {
@@ -886,13 +886,13 @@
 }
 
 /**************************************************************************
-    : Ӳ̸ʽ
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ɹ
-          RETURN_ERROR: ʧ
-    : 
+功    能: 硬盘格式化
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 成功
+          RETURN_ERROR: 失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugFormatUnit(int32_t argc, char *argv[])
 {
@@ -968,13 +968,13 @@
 
 
 /**************************************************************************
-    : ѯӲ̸ʽ
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ɹ
-          RETURN_ERROR: ʧ
-    : 
+功    能: 查询硬盘格式化进度
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 成功
+          RETURN_ERROR: 失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugChkFmtStas(int32_t argc, char *argv[])
 {
@@ -1005,7 +1005,7 @@
         return RETURN_OK;
     }
 
-    /* Dorado 5000 modified begin 20161228 diagnose*/
+    /* Dorado 5000 modified begin 20161228 diagnose命令整改*/
     ret = sdIsNvmeDevById(sdevId, &isNvmeDevice);
     if (RETURN_OK != ret)
     {
@@ -1029,7 +1029,7 @@
 
     LVOS_WaitForCompletion(&myContext.completion);
 
-    /* ڸʽ */
+    /* 正在格式 */
     if (myContext.state)
     {
         DBG_Print("Disk is formating, current progress %d %%\n", myContext.result);
@@ -1042,20 +1042,20 @@
         myContext.result = HDM_FMAT_BUTT;
     }
 
-    /* ʽѾֹͣ */
+    /* 格式化已经停止 */
     DBG_Print("%s\n", g_hdmFmtResult[myContext.result]);
 
     return RETURN_OK;
 }
 
 /**************************************************************************
-    : ִӲµ
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : 
+功    能: 执行硬盘上下电
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 
 **************************************************************************/
 int32_t hdmDebugPowerCtrl(int32_t argc, char *argv[])
 {
@@ -1094,13 +1094,13 @@
 }
 
 /**************************************************************************
-    : ϼ鿪
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : 
+功    能: 在线诊断间隔检查开关
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugDiagStatCheck(int32_t argc, char *argv[])
 {
@@ -1158,13 +1158,13 @@
 
 
 /**************************************************************************
-    : ӲϵĵԺ
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ɹ
-          RETURN_ERROR: ʧ
-    : 
+功    能: 硬盘在线诊断的调试函数
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 成功
+          RETURN_ERROR: 失败
+其    他: 无
 **************************************************************************/
 void hdmDebugDiagnoseDone(void *context, DIAG_RESULT_E result)
 {
@@ -1174,13 +1174,13 @@
 
 
 /**************************************************************************
-    : ӲϵĵԺ
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ɹ
-          RETURN_ERROR: ʧ
-    : 
+功    能: 硬盘在线诊断的调试函数
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 成功
+          RETURN_ERROR: 失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugDiagnose(int32_t argc, char *argv[])
 {
@@ -1261,13 +1261,13 @@
 }
 
 /**************************************************************************
-    : ӲϼʱĵԺ
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ɹ
-          RETURN_ERROR: ʧ
-    : 
+功    能: 硬盘诊断间隔时间的调试函数
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 成功
+          RETURN_ERROR: 失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugDiagIntv(int32_t argc, char *argv[])
 {
@@ -1283,7 +1283,7 @@
     {
         interval = (int64_t)LVOS_StrToU64(argv[2]);
         /*Begin Modified by y00406735 DTS2017041305135   20170413*/
-        /*ϵļʱ5*/
+        /*诊断的间隔时间是5年内*/
         if ((1 > interval) || (DIAG_INTERVAL_TIME < interval))
         {
             DBG_Print("Diagnose interval time(sec) must be in 5 years.\n");
@@ -1301,13 +1301,13 @@
 }
 
 /**************************************************************************
-    : Ӳ̿ϼʱĵԺ
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ɹ
-          RETURN_ERROR: ʧ
-    : 
+功    能: 硬盘快速诊断间隔时间的调试函数
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 成功
+          RETURN_ERROR: 失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugQuickDiagIntv(int32_t argc, char *argv[])
 {
@@ -1323,7 +1323,7 @@
     {
         interval = (int64_t)LVOS_StrToU64(argv[2]);
         /*Begin Modified by y00406735 DTS2017041305135   20170413*/
-        /*ϵļʱ5*/
+        /*诊断的间隔时间是5年内*/
         if ((1 > interval) || (DIAG_INTERVAL_TIME < interval))
         {
             DBG_Print("Diagnose interval time(sec) must be in 5 years.\n");
@@ -1342,13 +1342,13 @@
 
 
 /**************************************************************************
-    : ѯӲ̵ʵʱϢ
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : 
+功    能: 查询硬盘的实时信息
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugRealInfo(int32_t argc, char *argv[])
 {
@@ -1374,7 +1374,7 @@
         return RETURN_OK;
     }
 
-    /*ѯʵʱϢ*/
+    /*查询实时信息*/
     ret = hdmRoutineInfo(sdevId, &realInfo, &myContext, hdmDebugStateDone);
     if (RETURN_OK != ret)
     {
@@ -1401,11 +1401,11 @@
 }
 
 /**************************************************************************
-    : ѯӲ̵Ϣ
-: uint32_t sdevId: 豸Id
-: 
-  ֵ: 
-    : 
+功    能: 查询单个硬盘的例测信息
+输入参数: uint32_t sdevId: 设备Id
+输出参数: 无
+返 回 值: 无
+其    他: 无
 **************************************************************************/
 void hdmDebugDiskRtInfo(uint32_t sdevId)
 {
@@ -1438,11 +1438,11 @@
 
 
 /**************************************************************************
-    : ѯȫֵϢ
-: 
-: 
-  ֵ: 
-    : 
+功    能: 查询全局的例测信息
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    他: 无
 **************************************************************************/
 void hdmDebugAllRtInfo(void)
 {
@@ -1471,13 +1471,13 @@
 
 
 /**************************************************************************
-    : ѯӲ̵Ϣ
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : 
+功    能: 查询硬盘的例测信息
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugRtInfo(int32_t argc, char *argv[])
 {
@@ -1488,25 +1488,25 @@
         return RETURN_ERROR;
     }
 
-    /* ʾȫϢ */
+    /* 显示全局例测信息 */
     if (2 == argc)
     {   
         hdmDebugAllRtInfo();
         return RETURN_OK;
     }
 
-    /* ʾϢ */
+    /* 显示单盘信息 */
     sdevId = (uint32_t)LVOS_StrToU64(argv[2]);
     hdmDebugDiskRtInfo(sdevId);
     return RETURN_OK;
 }
 
 /**************************************************************************
-    : ѯȫϢ
-: rtType : 
-: 
-  ֵ: 
-    : 
+功    能: 查询框例测的全局例测信息
+输入参数: rtType : 例测类型
+输出参数: 无
+返 回 值: 无
+其    他: 无
 **************************************************************************/
 void hdmDebugAllFmRtInfo(HDM_RT_BY_FM_TYPE_E rtType)
 {
@@ -1547,13 +1547,13 @@
 int32_t stub_hdmDebugFmRtInfo(int32_t argc, char *argv[]);
 
 /**************************************************************************
-    : ѯӲ̵Ϣ
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : 
+功    能: 查询硬盘的例测信息
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugFmRtInfo(int32_t argc, char *argv[])
 {
@@ -1563,13 +1563,13 @@
 
 
 /**************************************************************************
-    : 
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : 
+功    能: 设置例测间隔
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugRtCycle(int32_t argc, char *argv[])
 {
@@ -1677,13 +1677,13 @@
 }
 
 /**************************************************************************
-    : ⿪
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : 
+功    能: 设置例测开关
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugRtSwitch(int32_t argc, char *argv[])
 {
@@ -1716,13 +1716,13 @@
 }
 
 /**************************************************************************
-    : SSD⿪
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : 
+功    能: 设置SSD例测开关
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugSetSsdRtSwitch(int32_t argc, char *argv[])
 {
@@ -1735,11 +1735,11 @@
     }
 
     ssdSwitch = (uint32_t)LVOS_StrToU64(argv[2]);
-    if (0 == ssdSwitch)  /* 0ʾرSSD */
+    if (0 == ssdSwitch)  /* 0表示关闭SSD例测 */
     {
         ret = hdmRtSetSSDSwitch(HDM_ROUTINE_SSD_CLOSE);
     }
-    else if (1 == ssdSwitch) /* 1ʾSSD */
+    else if (1 == ssdSwitch) /* 1表示开启SSD例测 */
     {
         ret = hdmRtSetSSDSwitch(HDM_ROUTINE_SSD_OPEN);
     }
@@ -1755,13 +1755,13 @@
 }
 
 /**************************************************************************
-    : ѯSSD⿪
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-          : ִʧ
-    : 
+功    能: 查询SSD例测开关
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 执行成功
+          其它: 执行失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugGetSsdRtSwitch(int32_t argc, char *argv[])
 {
@@ -1783,15 +1783,15 @@
 }
 
 /**************************************************************************
-   : hdmDebugModeSenseDone
-     : ִmode senseĻص
- : void *context    
+ 函 数 名: hdmDebugModeSenseDone
+ 功    能: 执行mode sense的回调函数
+ 输入参数: void *context    
            uint8_t *buffer  
            uint32_t len     
            bool state       
- : 
-   ֵ: 
-     : 
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugModeSenseDone(void *context, uint8_t *buffer,
                                                 uint32_t len, bool state)
@@ -1806,7 +1806,7 @@
     hdmDebugStateDone(context, state);
 }
 
-/* Dorado 5000 modified begin ȦӶ */
+/* Dorado 5000 modified begin 降低圈复杂度 */
 #define HDM_DEBUG_PRINT_MODE_SENSE(i,segLen,modeDataLen,modePageOffset)\
 {\
     DBG_Print("\nparameter header:");\
@@ -1834,13 +1834,13 @@
 
 
 /**************************************************************************
-   : hdmDebugModeSense
-     : ModeSenseԽӿ
- : int32_t argc  
+ 函 数 名: hdmDebugModeSense
+ 功    能: ModeSense调试接口
+ 输入参数: int32_t argc  
            char *argv[]  
- : 
-   ֵ: 
-     : 
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugModeSense(int32_t argc, char *argv[])
 {
@@ -1871,7 +1871,7 @@
     memset(g_hdmDbgBuffer, 0, HDM_DBG_BUFF_LEN);
 
     /*Begin DTS2017122307100 z00225684 2017.12.28*/ 
-    HDM_PARAMTER_IS_DIGIT(argv[2]); /*жargv[2]Ƿ*/
+    HDM_PARAMTER_IS_DIGIT(argv[2]); /*判断argv[2]是否是数字*/
     sdevId = (uint32_t)LVOS_StrToU64(argv[2]);
     if (hdmDebugIsRootDiskBySdId(sdevId))
     {
@@ -1879,7 +1879,7 @@
         return RETURN_OK;
     }
 
-    /* Dorado 5000 modified begin 20161228 diagnose*/
+    /* Dorado 5000 modified begin 20161228 diagnose命令整改*/
     ret = sdIsNvmeDevById(sdevId, &isNvmeDevice);
     if (RETURN_OK != ret)
     {
@@ -1894,13 +1894,13 @@
     }
     /* Dorado 5000 modified end*/
 
-    HDM_PARAMTER_IS_DIGIT(argv[3]); /*жargv[3]Ƿ*/
+    HDM_PARAMTER_IS_DIGIT(argv[3]); /*判断argv[3]是否是数字*/
     pgCode = (uint8_t)LVOS_StrToU64(argv[3]); 
 
-    HDM_PARAMTER_IS_DIGIT(argv[4]); /*жargv[4]Ƿ*/
+    HDM_PARAMTER_IS_DIGIT(argv[4]); /*判断argv[4]是否是数字*/
     subPgCode = (uint8_t)LVOS_StrToU64(argv[4]); 
 
-    HDM_PARAMTER_IS_DIGIT(argv[5]); /*жargv[5]Ƿ*/
+    HDM_PARAMTER_IS_DIGIT(argv[5]); /*判断argv[5]是否是数字*/
     pc = (uint8_t)LVOS_StrToU64(argv[5]);
 
     if (argc == 6)
@@ -1912,9 +1912,9 @@
                               &myContext,
                               hdmDebugModeSenseDone);
     }
-    else /* Ȳѡ粻ѡԶȡ */
+    else /* 长度参数可选，如不选择，则自动读取长度 */
     {
-        HDM_PARAMTER_IS_DIGIT(argv[6]); /*жargv[6]Ƿ*/
+        HDM_PARAMTER_IS_DIGIT(argv[6]); /*判断argv[6]是否是数字*/
         length = (uint32_t)LVOS_StrToU64(argv[6]);
         ret = hdmModeSense10Ex(sdevId,
                                  pgCode,
@@ -1961,13 +1961,13 @@
 }    
 
 /**************************************************************************
-   : hdmDebugModeSel2
-     : ִMODE SELECT
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugModeSel2
+ 功    能: 执行MODE SELECT功能
+ 输入参数: int32_t argc : 参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugModeSel(int32_t argc, char *argv[])
 {
@@ -2000,7 +2000,7 @@
         return RETURN_OK;
     }
     
-    /* Dorado 5000 modified begin 20161228 diagnose*/
+    /* Dorado 5000 modified begin 20161228 diagnose命令整改*/
     ret = sdIsNvmeDevById(sdevId, &isNvmeDevice);
     if (RETURN_OK != ret)
     {
@@ -2063,13 +2063,13 @@
 }
 
 /**************************************************************************
-   : hdmDebugSetLightState
-     : Ӳ̵״̬
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugSetLightState
+ 功    能: 设置硬盘点灯状态
+ 输入参数: int32_t argc : 参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugSetLightState(int32_t argc, char *argv[])
 {
@@ -2129,13 +2129,13 @@
 }
 
 /**************************************************************************
-   : hdmDebugGetLightState
-     : ѯӲ̵״̬
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugGetLightState
+ 功    能: 查询硬盘点灯状态
+ 输入参数: int32_t argc : 参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugGetLightState(int32_t argc, char *argv[])
 {
@@ -2163,13 +2163,13 @@
 }
 
 /**************************************************************************
-   : hdmDebugDiskInFin
-     : ģӲ̽(sdû֪ͨʹ)
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugDiskInFin
+ 功    能: 模拟硬盘接入完成(仅在sd没有通知的情况下使用)
+ 输入参数: int32_t argc : 参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugDiskInFin(int32_t argc, char *argv[])
 {
@@ -2183,13 +2183,13 @@
 
 
 /**************************************************************************
-   : hdmDebugVersion
-     : 鿴汾
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugVersion
+ 功    能: 查看版本号
+ 输入参数: int32_t argc : 参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugVersion(int32_t argc, char *argv[])
 {
@@ -2202,20 +2202,20 @@
 
 
 /**************************************************************************
-   : hdmDebugDiagResultClearPreProc
-     : Ӳϼ¼
- : hdmReq : REQ
-           done : Ԥص̵ĺ ṩ           
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugDiagResultClearPreProc
+ 功    能: 清除硬盘中在线诊断记录
+ 输入参数: hdmReq : 父REQ
+           done : 预处理回到主流程的函数 框架提供           
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugDiagResultClearPreProc(REQ_S *hdmReq, HDM_STATE_DONE bcakToMainFlow)
 {
     char *sglBuf = NULL;
     uint32_t len = 0;
     
-    /*ϼ¼*/
+    /*清除诊断记录*/
     sglBuf = hdmReq->sgl->entrys[0].buf;
     len = sizeof(HDM_DIAG_INFO_HDR_S);
     if (hdmReq->sgl->entrys[0].len < len)
@@ -2239,13 +2239,13 @@
 }
 
 /**************************************************************************
-   : hdmDebugDiagResultClearDone
-     : Ӳϼ¼
- : hdmReq : REQ
-           done : Ԥص̵ĺ ṩ           
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugDiagResultClearDone
+ 功    能: 清除硬盘中在线诊断记录
+ 输入参数: hdmReq : 父REQ
+           done : 预处理回到主流程的函数 框架提供           
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugDiagResultClearDone(REQ_S *req)
 {
@@ -2269,13 +2269,13 @@
 
 
 /**************************************************************************
-   : hdmDebugClearDiagRecord
-     : Ӳϼ¼
- : hdmReq : REQ
-           done : Ԥص̵ĺ ṩ           
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugClearDiagRecord
+ 功    能: 清除硬盘中在线诊断记录
+ 输入参数: hdmReq : 父REQ
+           done : 预处理回到主流程的函数 框架提供           
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugClearDiagRecord(uint32_t sdevId, void *context)
 {
@@ -2348,13 +2348,13 @@
 }
 
 /**************************************************************************
-   : hdmDebugGetDiagRecordDone
-     : ȡӲϼ¼Ļص
- : hdmReq : REQ
-           done : Ԥص̵ĺ ṩ           
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugGetDiagRecordDone
+ 功    能: 获取硬盘中在线诊断记录的回调函数
+ 输入参数: hdmReq : 父REQ
+           done : 预处理回到主流程的函数 框架提供           
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugGetDiagRecordDone(REQ_S *hdmReq)
 {
@@ -2389,13 +2389,13 @@
 
 
 /**************************************************************************
-   : hdmDebugClearDiagRecord
-     : ѯӲϼ¼
- : hdmReq : REQ
-           done : Ԥص̵ĺ ṩ           
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugClearDiagRecord
+ 功    能: 查询硬盘中在线诊断记录
+ 输入参数: hdmReq : 父REQ
+           done : 预处理回到主流程的函数 框架提供           
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugGetDiagRecord(uint32_t sdevId, void *context)
 {
@@ -2433,13 +2433,13 @@
 
 
 /**************************************************************************
-   : hdmDebugDiagRecord
-     : ѯ Ӳϼ¼
- : hdmReq : REQ
-           done : Ԥص̵ĺ ṩ           
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugDiagRecord
+ 功    能: 查询 清除硬盘中在线诊断记录
+ 输入参数: hdmReq : 父REQ
+           done : 预处理回到主流程的函数 框架提供           
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugDiagResult(int32_t argc, char *argv[])
 {   
@@ -2525,13 +2525,13 @@
 }
 
 /**************************************************************************
-   : hdmDebugLastDiagDetail
-     : Ӳϼ¼
- : hdmReq : REQ
-           done : Ԥص̵ĺ ṩ           
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugLastDiagDetail
+ 功    能: 清除硬盘中在线诊断记录
+ 输入参数: hdmReq : 父REQ
+           done : 预处理回到主流程的函数 框架提供           
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugLastDiagDetail(int32_t argc, char *argv[])
 {
@@ -2579,7 +2579,7 @@
     DBG_Print("%u CFG_DIAG_PHASE_TUR\n", CFG_DIAG_PHASE_TUR);
     DBG_Print("%u CFG_DIAG_PHASE_QUICK_DIAGNOSE\n", CFG_DIAG_PHASE_QUICK_DIAGNOSE);
     DBG_Print("%u CFG_DIAG_PHASE_READ_WRITE_TEST\n", CFG_DIAG_PHASE_READ_WRITE_TEST);
-    /* Dorado 5000 modified begin j90006936ⵥDTS2014111707666޸Ĵʱ©*/
+    /* Dorado 5000 modified begin 发现j90006936在问题单DTS2014111707666修改代码的时候遗漏了这两条*/
     DBG_Print("%u CFG_DIAG_PHASE_RESERVE_AREA_TEST\n", CFG_DIAG_PHASE_RESERVE_AREA_TEST);
     DBG_Print("%u CFG_DIAG_PHASE_SELF_TEST\n", CFG_DIAG_PHASE_SELF_TEST);
     /* Dorado 5000 modified end */
@@ -2616,14 +2616,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugGetFwState
-     : ȡӲFWϷԵĵԺ
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugGetFwState
+ 功    能: 获取硬盘FW合法性的调试函数
+ 输入参数: int32_t argc : 输入参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugGetFwState(int32_t argc, char *argv[])
 {
@@ -2650,13 +2650,13 @@
 }
 
 /**************************************************************************
-    : ȡӲϢĵԺ
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ɹ
-          RETURN_ERROR: ʧ
-    : 
+功    能: 获取硬盘配置信息的调试函数
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 成功
+          RETURN_ERROR: 失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugGetDiskConf(int32_t argc, char *argv[])
 {
@@ -2762,13 +2762,13 @@
 }
 
 /**************************************************************************
-    : Ӳ֤ĵԺ
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ɹ
-          RETURN_ERROR: ʧ
-    : 
+功    能: 硬盘认证的调试函数
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 成功
+          RETURN_ERROR: 失败
+其    他: 无
 **************************************************************************/
 int32_t hdmDebugDiskAuth(int32_t argc, char *argv[])
 {
@@ -2806,13 +2806,13 @@
 }
 
 /***************************************************************************
-    : ȡӲдcache״̬ĵԺ
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ɹ
-          RETURN_ERROR: ʧ
-    : 
+功    能: 获取硬盘写cache状态的调试函数
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 无
+返 回 值: RETURN_OK: 成功
+          RETURN_ERROR: 失败
+其    他: 无
 ***************************************************************************/
 int32_t hdmDebugGetWcState(int32_t argc, char *argv[])
 {
@@ -2839,7 +2839,7 @@
         return RETURN_OK;
     }
 
-    /* Dorado 5000 modified begin 20161228 diagnose*/
+    /* Dorado 5000 modified begin 20161228 diagnose命令整改*/
     ret = sdIsNvmeDevById(sdevId, &isNvmeDevice);
     if (RETURN_OK != ret)
     {
@@ -2876,14 +2876,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugSetWcState
-     : Ӳдcache״̬ĵԺ
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugSetWcState
+ 功    能: 设置硬盘写cache状态的调试函数
+ 输入参数: int32_t argc : 输入参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugSetWcState(int32_t argc, char *argv[])
 {
@@ -2938,13 +2938,13 @@
 }
 
 /**************************************************************************
-   : hdmDebugScanDone
-     : ɨɻص
- : void *context            :  
-           HDM_SCAN_RESULT_E result : ɨ 
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugScanDone
+ 功    能: 扫描完成回调函数
+ 输入参数: void *context            : 上下文 
+           HDM_SCAN_RESULT_E result : 扫描结果 
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugScanDone(void *context, HDM_SCAN_RESULT_E result)
 {
@@ -2953,16 +2953,16 @@
 }
 
 /**************************************************************************
-   : hdmDebugScanByType
-     : ͽӲɨ
- : uint32_t sdevId      : 豸ID 
-           uint64_t startLba    : ɨʼLBA 
-           uint64_t endLba      : ɨLBA 
-           HDM_SCAN_TYPE_E type : ɨ 
-           bool diagnose        : Ƿɨ
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugScanByType
+ 功    能: 根据类型进行硬盘扫描
+ 输入参数: uint32_t sdevId      : 设备ID 
+           uint64_t startLba    : 扫描起始LBA 
+           uint64_t endLba      : 扫描结束LBA 
+           HDM_SCAN_TYPE_E type : 扫描类型 
+           bool diagnose        : 是否是诊断扫描
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugScanByType(uint32_t sdevId, uint64_t startLba,
                                           uint64_t endLba, HDM_SCAN_TYPE_E type)
@@ -2990,7 +2990,7 @@
     else
     {
         hdmScanDiagnose(sdevId, startLba, endLba, NULL, hdmDebugScanDone);
-        ret = HDM_SCAN_RET_OK; /* ɨ޷ֵʼܳɹ */
+        ret = HDM_SCAN_RET_OK; /* 诊断扫描无返回值，函数调用始终能成功 */
     }
     
     switch (ret)
@@ -3024,14 +3024,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugScanOpening
-     : Ӳ̽пɨĵԺ
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugScanOpening
+ 功    能: 对硬盘进行开局扫描的调试函数
+ 输入参数: int32_t argc : 输入参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugScanOpening(int32_t argc, char *argv[])
 {
@@ -3055,14 +3055,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugDiagScan
-     : ɨĵԺ
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugDiagScan
+ 功    能: 诊断扫描的调试函数
+ 输入参数: int32_t argc : 输入参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugDiagScan(int32_t argc, char *argv[])
 {
@@ -3090,14 +3090,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugScanRegion
-     : Ӳָ̽ɨĵԺ
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugScanRegion
+ 功    能: 对硬盘进行指定区域扫描的调试函数
+ 输入参数: int32_t argc : 输入参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugScanRegion(int32_t argc, char *argv[])
 {
@@ -3127,14 +3127,14 @@
 int32_t stub_hdmDebugScanGlobal(int32_t argc, char *argv[]);
 
 /**************************************************************************
-   : hdmDebugScanGlobal
-     : Ӳ̽ȫɨĵԺ
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugScanGlobal
+ 功    能: 对硬盘进行全局扫描的调试函数
+ 输入参数: int32_t argc : 输入参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugScanGlobal(int32_t argc, char *argv[])
 {
@@ -3143,14 +3143,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugGetScanState
-     : ȡӲɨ״̬ĵԺ
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugGetScanState
+ 功    能: 获取硬盘扫描状态的调试函数
+ 输入参数: int32_t argc : 输入参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugGetScanState(int32_t argc, char *argv[])
 {
@@ -3217,14 +3217,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugScanStop
-     : ֹͣɨ
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugScanStop
+ 功    能: 停止扫描
+ 输入参数: int32_t argc : 输入参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugScanStop(int32_t argc, char *argv[])
 {
@@ -3257,14 +3257,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugScanSwitch
-     : ɨ蹦
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugScanSwitch
+ 功    能: 开关扫描功能
+ 输入参数: int32_t argc : 输入参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugScanSwitch(int32_t argc, char *argv[])
 {
@@ -3294,14 +3294,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugStartStop
-     : ӲߺͻѵĵԺ
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugStartStop
+ 功    能: 硬盘休眠和唤醒的调试函数
+ 输入参数: int32_t argc : 输入参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugStartStop(int32_t argc, char *argv[])
 {
@@ -3357,14 +3357,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugSyncCache
-     : ˢӲcacheĻص
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugSyncCache
+ 功    能: 刷新硬盘cache的回调函数
+ 输入参数: int32_t argc : 输入参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugSyncCache(int32_t argc, char *argv[])
 {
@@ -3402,14 +3402,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugTestRdy
-     : not readyӲ̽TURԵĵԺ
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugTestRdy
+ 功    能: 对not ready硬盘进行TUR测试的调试函数
+ 输入参数: int32_t argc : 输入参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugTestRdy(int32_t argc, char *argv[])
 {
@@ -3467,14 +3467,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugTestSleep
-     : ӲǷ״̬
- : int32_t argc :   
-           char *argv[] : Ĳ  
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugTestSleep
+ 功    能: 检查硬盘是否处于休眠状态
+ 输入参数: int32_t argc : 输入参数个数  
+           char *argv[] : 输入的参数  
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugTestSleep(int32_t argc, char *argv[])
 {
@@ -3524,13 +3524,13 @@
 }
 
 /**************************************************************************
-   : hdmDebugGetSmartFromDisk
-     : ̶smartϢ
- : uint32_t sdevId 豸ID 
- : void *smartBuf ȡsmartϢŵ
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugGetSmartFromDisk
+ 功    能: 从盘读出smart信息
+ 输入参数: uint32_t sdevId 设备ID 
+ 输出参数: void *smartBuf 获取的smart信息存放地
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugGetSmartFromDisk(uint32_t sdevId, void *smartBuf)
 {
@@ -3550,14 +3550,14 @@
     diskType = sdDisk->portType;
     HDM_PUT_SD_DEV(sdDev);
 
-    /* ȷӲȷ*/
+    /* 确保硬盘类型正确*/
     if (DISK_TYPE_SATA != diskType)
     {
         DBG_Print("Disk(disk id: %u) is not SATA.\n", sdevId);
         return RETURN_ERROR;
     }
 
-    /*ȡsmartϢ*/
+    /*获取smart信息*/
     ret = hdmGetAtaDiskSmartData(sdevId,
                                  sizeof(HDM_ATA_SMART_DATA_S),
                                  smartBuf);
@@ -3571,13 +3571,13 @@
 }
 
 /*****************************************************************************
-  : hdmDebugParseSmartRawValue
-    : RawValueֵ
-: id ID
-          raw  ԭʼֵ
-: rawValue ֵ
-  ֵ: 
-    : 
+函 数 名: hdmDebugParseSmartRawValue
+功    能: 解析RawValue值函数
+输入参数: id 解析项ID
+          raw  原始值
+输出参数: rawValue 解析出来的值
+返 回 值: 无
+其    他: 无
 *****************************************************************************/
 void hdmDebugParseSmartRawValue(uint8_t id, int64_t *rawValue, uint8_t *raw)
 {
@@ -3589,7 +3589,7 @@
     *rawValue = 0;
     value = 0;
 
-    /* תRawValue6ֽΪһint64_tֵ */
+    /* 转换RawValue的6个字节为一个int64_t值 */
     for (index = 0; index < 6; index++)
     {
         rawValueTemp = (uint64_t)raw[index];
@@ -3597,7 +3597,7 @@
         value |= rawValueTemp;
     }
 
-    /* 6ֽתΪ3Word */
+    /* 6个字节转换为3个Word */
     /* Begin Modified by d00282183 DTS2014111810841  20141119 */
     for (index = 0; index < 3; index++)
     {
@@ -3607,26 +3607,26 @@
     }
     /* End   Modified by d00282183 DTS2014111810841  20141119 */
 
-    /* IDRawValueֵ */
+    /* 根据ID输出RawValue值 */
     if (REALLOCATED_SECTOR_COUNT == id)
     {
-        /* 4ֽ */
+        /* 输出4个字节 */
         rawValueTemp = (uint64_t)word[1];
         value = (int64_t)(((uint64_t)rawValueTemp << 16) | (uint64_t)word[0]);
     }
     else if (SPIN_UP_TIME == id)
     {
-        /* 2ֽ */
+        /* 输出2个字节 */
         value = (int64_t)word[0];
     }
     else if (AIRFLOW_TEMPERATURE == id)
     {
-        /* 2ֽ */
+        /* 输出2个字节 */
         value = (int64_t)word[0];
     }
     else if (TEMPERATURE_CELSIUS == id)
     {
-        /* 2ֽ */
+        /* 输出2个字节 */
         value = (int64_t)word[0];
     }
 
@@ -3637,13 +3637,13 @@
 
 
 /**************************************************************************
-   : hdmDebugPrintSmart
-     : ʾӲsmartϢ
- : void *smartBuf Ӳsmart
-           void *thresholdBuf Ӳthreshold
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugPrintSmart
+ 功    能: 显示硬盘smart信息
+ 输入参数: void *smartBuf 读出的硬盘smart数据
+           void *thresholdBuf 硬盘threshold数据
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugPrintSmart(void *smartBuf, void *thresholdBuf)
 {
@@ -3687,24 +3687,24 @@
 }
 
 /**************************************************************************
-   : hdmDebugGetAtaThreshold
-     : ȡӲthresholdϢ
- : uint32_t sdevId 豸ID  
-           char *buf buf
-           uint32_t bufLen buf
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugGetAtaThreshold
+ 功    能: 获取硬盘threshold信息
+ 输入参数: uint32_t sdevId 设备ID  
+           char *buf 数据buf
+           uint32_t bufLen buf长度
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugGetAtaThreshold(uint32_t sdevId, char *buf, uint32_t bufLen)
 {
     uint8_t cdb[SD_MAX_CDB_LEN] = {0};
     int32_t ret = RETURN_ERROR;
 
-    hdmScsiFillSmartThresCdb(cdb, 1); /* 1ʾ1 */
+    hdmScsiFillSmartThresCdb(cdb, 1); /* 1表示1个扇区 */
 
-    /* ȡATAϢ */
+    /* 获取磁盘ATA信息 */
     ret = sdExecuteScsiCmd(sdevId, 
                            cdb,
                            DMA_FROM_DEVICE, 
@@ -3725,14 +3725,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugGetSmart
-     : ȡӲsmartϢ
- : int32_t argc :   
-           char *argv[] : Ĳ  
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugGetSmart
+ 功    能: 获取硬盘smart信息
+ 输入参数: int32_t argc : 输入参数个数  
+           char *argv[] : 输入的参数  
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugGetSmart(int32_t argc, char *argv[])
 {
@@ -3747,7 +3747,7 @@
 
     sdevId = (uint32_t)LVOS_StrToU64(argv[2]);
 
-    /* ʱʹ첽ܵԤڴȡsmartϢ */
+    /* 临时使用异步框架的预留内存来读取smart信息 */
     ALLOCATE_STRUCTURE(MY_PID, HDM_ASYNC_FRAME_16K_POOL_ID, (void **)&smartBuf);
     if (NULL == smartBuf)
     {
@@ -3756,7 +3756,7 @@
     }
 
     memset(smartBuf, 0, HDM_ASYNC_FRAME_POOL_16K);
-    /* ȡӲsmart */
+    /* 读取硬盘smart */
     if (RETURN_OK != hdmDebugGetSmartFromDisk(sdevId, smartBuf))
     {
         DBG_Print("Get disk(%u) smart fail.", sdevId);
@@ -3764,7 +3764,7 @@
         return RETURN_OK;
     }
 
-    /* ʱʹ첽ܵԤڴȡthresholdϢ */
+    /* 临时使用异步框架的预留内存来读取threshold信息 */
     ALLOCATE_STRUCTURE(MY_PID, HDM_ASYNC_FRAME_16K_POOL_ID, (void **)&thresholdBuf);
     if (NULL == thresholdBuf)
     {
@@ -3774,7 +3774,7 @@
     }
     memset(thresholdBuf, 0, HDM_ASYNC_FRAME_POOL_16K);
 
-    /* ȡӲthreshold */
+    /* 读取硬盘threshold */
     if (RETURN_OK != hdmDebugGetAtaThreshold(sdevId, thresholdBuf, sizeof(HDM_SMART_THRESHOLD_S)))
     {
         DBG_Print("Get disk(%u) threshold fail.", sdevId);
@@ -3783,7 +3783,7 @@
         return RETURN_OK;
     }
 
-    /* ӡӲsmartϢ */
+    /* 打印硬盘smart信息 */
     hdmDebugPrintSmart(smartBuf, thresholdBuf);
 
     FREE_STRUCTURE(smartBuf, HDM_ASYNC_FRAME_16K_POOL_ID);
@@ -3793,12 +3793,12 @@
 }
 
 /**************************************************************************
-   : hdmDebugDiskReserveAreaCallBack
-     : Ӳ̿ռֲ
- : REQ_S *req : Я̶ͷϢIO 
- : 
-   ֵ: HDM_ANALYSE_RESULT_E : 
-     : 
+ 函 数 名: hdmDebugDiskReserveAreaCallBack
+ 功    能: 硬盘空间分布描述区域分析函数
+ 输入参数: REQ_S *req : 携带固定头部信息的IO 
+ 输出参数: 无
+ 返 回 值: HDM_ANALYSE_RESULT_E : 分析结果
+ 其    它: 无
 **************************************************************************/
 HDM_ANALYSE_RESULT_E hdmDebugDiskReserveAreaCallBack(REQ_S *req)
 {
@@ -3809,13 +3809,13 @@
 }
 
 /**************************************************************************
-   : hdmDebugGetReserveAreaDone
-     : ȡӲ̿ռֲɵĻص
- : void *context :  
-           bool state    : Ƿɹʼ̶ͷ
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugGetReserveAreaDone
+ 功    能: 获取硬盘空间分布描述区域完成的回调函数
+ 输入参数: void *context : 上下文 
+           bool state    : 是否成功初始化固定头部
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugGetReserveAreaDone(void *context, bool state)
 {
@@ -3829,14 +3829,14 @@
 
 
 /**************************************************************************
-   : hdmDebugGetReserveArea
-     : ȡӲ̿ռֲ
- : int32_t argc :   
-           char *argv[] : Ĳ  
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : ڼȡӲ̿ռʧܵtracepoint Ƿɹ
+ 函 数 名: hdmDebugGetReserveArea
+ 功    能: 获取硬盘空间分布描述区域
+ 输入参数: int32_t argc : 输入参数个数  
+           char *argv[] : 输入的参数  
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 用于检测读取硬盘空间区域失败的tracepoint 是否成功设置
 **************************************************************************/
 int32_t hdmDebugGetReserveArea(int32_t argc, char *argv[])
 {
@@ -3866,13 +3866,13 @@
 }
 
 /**************************************************************************
-   : hdmDebugTechParamSaveDone
-     : д
- : void *context 
-           bool state ״̬
- : 
-   ֵ: HDM_ANALYSE_RESULT_E : 
-     : 
+ 函 数 名: hdmDebugTechParamSaveDone
+ 功    能: 读写结束处理函数
+ 输入参数: void *context 上下文
+           bool state 结束状态
+ 输出参数: 无
+ 返 回 值: HDM_ANALYSE_RESULT_E : 分析结果
+ 其    它: 无
 **************************************************************************/
 static void hdmDebugTechParamSaveDone(void *context, bool state)
 {
@@ -3885,13 +3885,13 @@
 }
 
 /**************************************************************************
-   : hdmAnalyseTechParam
-     : 
- : uint8_t *buf buffer
-           uint32_t dataLen ݳ
- : 
-   ֵ: HDM_ANALYSE_RESULT_E : 
-     : 
+ 函 数 名: hdmAnalyseTechParam
+ 功    能: 分析技术参数
+ 输入参数: uint8_t *buf 数据buffer
+           uint32_t dataLen 数据长度
+ 输出参数: 无
+ 返 回 值: HDM_ANALYSE_RESULT_E : 分析结果
+ 其    它: 无
 **************************************************************************/
 static int32_t hdmDebugAnalyseTechParam(uint8_t *buf, uint32_t dataLen)
 {
@@ -3906,17 +3906,17 @@
 }
 
 /**************************************************************************
-   : hdmDebugGetTechParamLen
-     : ȡӲ̼
- : uint32_t sdevId 豸ID
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugGetTechParamLen
+ 功    能: 获取硬盘技术参数长度
+ 输入参数: uint32_t sdevId 设备ID
+ 输出参数: 无
+ 返 回 值: 技术参数长度
+ 其    它: 无
 **************************************************************************/
 uint64_t hdmDebugGetTechParamLen(uint32_t sdevId)
 {
     HDM_DISK_PRIVATE_S *hdmDiskPriv = NULL;
-    HDM_RESERVE_DESC_S *areaHeaderDesc = NULL;      /* ռֲ */
+    HDM_RESERVE_DESC_S *areaHeaderDesc = NULL;      /* 空间分布区域的描述符 */
     uint64_t len = 0;
 
     SD_SCSI_DEVICE_S *sdDev = NULL;
@@ -3943,12 +3943,12 @@
 
 
 /**************************************************************************
-   : hdmAnalyseAreaHeader
-     : ռֲͷ
- : REQ_S *req : ЯռֲϢĵIO  
- : 
-   ֵ: HDM_ANALYSE_RESULT_E : 
-     : 
+ 函 数 名: hdmAnalyseAreaHeader
+ 功    能: 分析空间分布描述头部
+ 输入参数: REQ_S *req : 携带空间分布描述信息的的IO  
+ 输出参数: 无
+ 返 回 值: HDM_ANALYSE_RESULT_E : 分析结果
+ 其    它: 无
 **************************************************************************/
 void hdmDebugReadTechParamDone(REQ_S *req)
 {
@@ -4014,16 +4014,16 @@
 }
 
 /**************************************************************************
-   : hdmDebugReadDataFromDisk
-     : ̶
- : uint32_t sdevId ID
-           void *context 
-           uint64_t startAddr ʼַ
-           HDM_STATE_DONE done ϲص
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugReadDataFromDisk
+ 功    能: 从盘读数据
+ 输入参数: uint32_t sdevId 盘ID
+           void *context 上下文
+           uint64_t startAddr 读起始地址
+           HDM_STATE_DONE done 结束上层回调
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 
 **************************************************************************/
 int32_t hdmDebugReadDataFromDisk(uint32_t sdevId, void *context, uint64_t startAddr,
                                  HDM_STATE_DONE done)
@@ -4060,13 +4060,13 @@
 }
 
 /**************************************************************************
-   : hdmDebugResumeTechParamPreProc
-     : ָԤ
- : hdmReq : REQ
-           HDM_STATE_DONE bcakToMainFlow һ        
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugResumeTechParamPreProc
+ 功    能: 恢复技术参数预处理函数
+ 输入参数: hdmReq : 父REQ
+           HDM_STATE_DONE bcakToMainFlow 下一步处理函数        
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugResumeTechParamPreProc(REQ_S *hdmReq, HDM_STATE_DONE bcakToMainFlow)
 {
@@ -4094,12 +4094,12 @@
 }
 
 /**************************************************************************
-   : hdmDebugResumeTechParamDone
-     : ָص
- : req : REQ           
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugResumeTechParamDone
+ 功    能: 恢复技术参数回调
+ 输入参数: req : REQ           
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugResumeTechParamDone(REQ_S *req)
 {
@@ -4127,12 +4127,12 @@
 
 
 /**************************************************************************
-   : hdmDebugResumeTechParamToDisk
-     : ָȥ
- : req : REQ           
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugResumeTechParamToDisk
+ 功    能: 恢复技术参数去数据
+ 输入参数: req : REQ           
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugResumeTechParamToDisk(uint32_t sdevId, void *context, uint64_t startAddr)
 {
@@ -4156,12 +4156,12 @@
 }
 
 /**************************************************************************
-   : hdmDebugWriteTechParamDone
-     : дص
- : req : REQ           
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugWriteTechParamDone
+ 功    能: 写技术参数回调
+ 输入参数: req : REQ           
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugWriteTechParamDone(REQ_S *req)
 {
@@ -4186,7 +4186,7 @@
                     techParam->dataType,
                     sdevId);
         
-        /* дʧܣҪ */
+        /* 如果是写备份区失败，则技术参数区需要回退 */
         if (HDM_AREA_TECH_PARAM_BACKUP == techParam->dataType)
         {
             ret = hdmDebugResumeTechParamToDisk(sdevId, techParam, HDM_TECH_PARAM_ADDR);
@@ -4219,7 +4219,7 @@
                     techParam->dataType,
                     sdevId);
         
-        /* дʧܣҪ */
+        /* 如果是写备份区失败，则技术参数区需要回退 */
         if (HDM_AREA_TECH_PARAM_BACKUP == techParam->dataType)
         {
             ret = hdmDebugResumeTechParamToDisk(sdevId, techParam, HDM_TECH_PARAM_ADDR);
@@ -4239,13 +4239,13 @@
 }
 
 /**************************************************************************
-   : hdmDebugWriteTechParamPreProc
-     : дԤ
- : hdmReq : REQ
-           HDM_STATE_DONE bcakToMainFlow һ        
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugWriteTechParamPreProc
+ 功    能: 写技术参数预处理函数
+ 输入参数: hdmReq : 父REQ
+           HDM_STATE_DONE bcakToMainFlow 下一步处理函数        
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugWriteTechParamPreProc(REQ_S *hdmReq, HDM_STATE_DONE bcakToMainFlow)
 {
@@ -4273,16 +4273,16 @@
 }
 
 /**************************************************************************
-   : hdmDebugWriteDataToDisk
-     : ̶
- : uint32_t sdevId ID
-           void *context 
-           uint64_t startAddr дʼַ
-           HDM_STATE_DONE done ϲص
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugWriteDataToDisk
+ 功    能: 从盘读数据
+ 输入参数: uint32_t sdevId 盘ID
+           void *context 上下文
+           uint64_t startAddr 写起始地址
+           HDM_STATE_DONE done 结束上层回调
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 
 **************************************************************************/
 int32_t hdmDebugWriteDataToDisk(uint32_t sdevId, void  *context, uint64_t startAddr,
                                 HDM_STATE_DONE done)
@@ -4320,14 +4320,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugSetDiskCapacity
-     : ùһ
- : int32_t argc :   
-           char *argv[] : Ĳ  
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugSetDiskCapacity
+ 功    能: 设置归一化容量
+ 输入参数: int32_t argc : 输入参数个数  
+           char *argv[] : 输入的参数  
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 
 **************************************************************************/
 int32_t hdmDebugSetDiskCapacity(int32_t argc, char *argv[])
 {
@@ -4357,7 +4357,7 @@
         return RETURN_OK;
     }
 
-    /* ʱڴ */
+    /* 分配存放临时数据内存 */
     ALLOCATE_STRUCTURE(MY_PID, HDM_ASYNC_FRAME_16K_POOL_ID, (void **)&techParamBuf);
     if (NULL == techParamBuf)
     {
@@ -4432,14 +4432,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugPowerOffPreProc
-     : ӲµǰԤĵԺ
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugPowerOffPreProc
+ 功    能: 硬盘下电前预处理的调试函数
+ 输入参数: int32_t argc : 输入参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugPowerOffPreProc(int32_t argc, char *argv[])
 {
@@ -4477,13 +4477,13 @@
 }
 
 /**************************************************************************
-   : hdmDebugTracePointPrint
-     : ӡǰTrace point״̬
- : 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugTracePointPrint
+ 功    能: 打印当前所有Trace point状态
+ 输入参数: 无
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 void hdmDebugTracePointPrint(void)
 {
@@ -4500,14 +4500,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugTracePoint
-     : Trace point ͹رպ
- : int32_t argc :  
-           char *argv[] : Ĳ 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugTracePoint
+ 功    能: Trace point 激活和关闭函数
+ 输入参数: int32_t argc : 输入参数个数 
+           char *argv[] : 输入的参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugTracePoint(int32_t argc, char *argv[])
 {
@@ -4534,7 +4534,7 @@
         return RETURN_OK;
     }
 
-    /* id Ϊ65535ʱʾȫtrace pointΪͬstatus */
+    /* id 为65535时，表示设置全部trace point为相同的status */
     if (65535 == tpId)
     {
         
@@ -4546,7 +4546,7 @@
         return RETURN_OK;
     }
 
-    /* ĳһtrace point״̬ */
+    /* 设置某一个trace point的状态 */
     DBG_LogInfo(LOG_ID_HDM_004D, "Somebody set trace point(%u), status(%u).", tpId, tpActive);
     hdmTpSetTracePoint(g_hdmTp[tpId].id, (bool)tpActive);
 
@@ -4556,15 +4556,15 @@
 }
 
 /**************************************************************************
-   : hdmDebugReadElecLabelDone
-     : ȡӱǩɻص
- : void *context   :  
-           uint8_t *buffer : ӱǩ 
-           uint32_t length : ӱǩ 
-           bool state      : ִ״̬ 
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugReadElecLabelDone
+ 功    能: 获取电子标签完成回调函数
+ 输入参数: void *context   : 上下文 
+           uint8_t *buffer : 电子标签缓冲区 
+           uint32_t length : 电子标签长度 
+           bool state      : 执行命令状态 
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugReadElecLabelDone(void *context, uint8_t *buffer, uint32_t length, bool state)
 {
@@ -4584,14 +4584,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugReadElecLabel
-     : ȡӲ̵ӱǩ
- : int32_t argc :  
-           char *argv[] :  
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugReadElecLabel
+ 功    能: 读取硬盘电子标签
+ 输入参数: int32_t argc : 参数个数 
+           char *argv[] : 参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugReadElecLabel(int32_t argc, char *argv[])
 {
@@ -4638,12 +4638,12 @@
 
 
 /**************************************************************************
-   : hdmDebugRequestSenseDone
-     : ȡSCSIӲrequest Senseɻص
- : req: ȡrequest senseREQ
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugRequestSenseDone
+ 功    能: 获取SCSI硬盘request Sense完成回调函数
+ 输入参数: req: 获取request sense的REQ
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugRequestSenseDone(REQ_S *req)
 {
@@ -4679,14 +4679,14 @@
 
 
 /**************************************************************************
-   : hdmDebugRequestSense
-     : ȡӲsense
- : int32_t argc :  
-           char *argv[] :  
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugRequestSense
+ 功    能: 读取硬盘sense数据
+ 输入参数: int32_t argc : 参数个数 
+           char *argv[] : 参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugRequestSense(int32_t argc, char *argv[])
 {
@@ -4717,7 +4717,7 @@
         return RETURN_OK;
     }
 
-    /* Dorado 5000 modified begin 20161228 diagnose*/
+    /* Dorado 5000 modified begin 20161228 diagnose命令整改*/
     ret = sdIsNvmeDevById(sdevId, &isNvmeDevice);
     if (RETURN_OK != ret)
     {
@@ -4756,7 +4756,7 @@
         return RETURN_OK; 
     }
 
-    /* requeset ֻӡǰ255ֽ */
+    /* requeset 只打印前255个字节 */
     for(index = 0; index < 256; index++)
     {
         if (0 == index % 8)
@@ -4770,15 +4770,15 @@
 }
 
 /**************************************************************************
-   : hdmDebugLogSenseDone
-     : ȡSCSIӲLogSenseɻص
- : void *context   :  
-           uint8_t *buffer : LogPageݻ 
-           uint32_t length :  
-           bool state      : ִ
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugLogSenseDone
+ 功    能: 获取SCSI硬盘LogSense完成回调函数
+ 输入参数: void *context   : 上下文 
+           uint8_t *buffer : LogPage数据缓冲 
+           uint32_t length : 缓冲区长度 
+           bool state      : 执行命令结果
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugLogSenseDone(void *context, uint8_t *buffer,
                                        uint32_t length, bool state)
@@ -4813,7 +4813,7 @@
         return;
     }
 
-    /* Dorado 5000 modified begin 20161228 diagnose*/
+    /* Dorado 5000 modified begin 20161228 diagnose命令整改*/
     ret = sdIsNvmeDevById(sdevId, &isNvmeDevice);
     if (RETURN_OK != ret)
     {
@@ -4891,14 +4891,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugLogSense
-     : ȡSCSIӲLogSense
- : int32_t argc :  
-           char *argv[] :  
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugLogSense
+ 功    能: 获取SCSI硬盘LogSense
+ 输入参数: int32_t argc : 参数个数 
+           char *argv[] : 参数 
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 无
 **************************************************************************/
 int32_t hdmDebugLogSense(int32_t argc, char *argv[])
 {
@@ -4946,7 +4946,7 @@
     sdevId = (uint32_t)LVOS_StrToU64(argv[2]);
     t = LVOS_StrToU64(argv[3]);
 
-    /* Dorado 5000 modified begin 20161228 diagnose*/
+    /* Dorado 5000 modified begin 20161228 diagnose命令整改*/
     ret = sdIsNvmeDevById(sdevId, &isNvmeDevice);
     if (RETURN_OK != ret)
     {
@@ -5005,14 +5005,14 @@
 
 /*Begin Modified by j90006936 SR-0000408900_02 2016.1.24*/
 /**************************************************************************
-   : hdmDebugSSDGetDiagSwitch
-     : ѯSSDϿص
- : argc 
-           argv 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugSSDGetDiagSwitch
+ 功    能: 查询SSD诊断开关调试命令
+ 输入参数: argc 输入参数个数
+           argv 输入参数
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 
 **************************************************************************/
 int32_t hdmDebugSSDGetDiagSwitch(int32_t argc, char *argv[])
 {
@@ -5028,14 +5028,14 @@
 }
 
 /**************************************************************************
-   : hdmDebugSSDSetDiagSwitch
-     : SSDϿص
- : argc 
-           argv 
- : 
-   ֵ: RETURN_OK: ɹ
-           RETURN_ERROR: ʧ
-     : 
+ 函 数 名: hdmDebugSSDSetDiagSwitch
+ 功    能: SSD诊断开关调试命令
+ 输入参数: argc 输入参数个数
+           argv 输入参数
+ 输出参数: 无
+ 返 回 值: RETURN_OK: 成功
+           RETURN_ERROR: 失败
+ 其    它: 
 **************************************************************************/
 int32_t hdmDebugSSDSetDiagSwitch(int32_t argc, char *argv[])
 {
@@ -5049,7 +5049,7 @@
 
     diagSwitch = (uint32_t)LVOS_StrToS64(argv[2]);
     /*Begin Modified by y00406735 DTS2017041305135   20170413*/
-    /*жЧ*/
+    /*判断输入参数的有效性*/
     if ((0 != diagSwitch) && (1 != diagSwitch))
     {
         DBG_Print("Input invalid diagnose switch param: %u.\n", diagSwitch);
@@ -5206,13 +5206,13 @@
     return RETURN_OK;
 }
 /*End Modified by j90006936 DTS2014091110014  20141020*/
-
+extern HDM_DEBUG_CMD_S g_hdmDebugCmd_sph50[];
 /**************************************************************************
-     : HDMĵִк
- : argc: 
-           argv: Ĳ
- : 
- ֵ  :
+ 功    能: HDM的调试命令的执行函数
+ 输入参数: argc: 输入参数个数
+           argv: 输入的参数
+ 输出参数: 无
+ 返回值  :
 **************************************************************************/
 static void hdmDebugDoHdmCmd(int32_t argc, char *argv[])
 {
@@ -5225,15 +5225,15 @@
         return;
     }
 
-    while (NULL != g_hdmDebugCmd[index].cmd)
+    while (NULL != g_hdmDebugCmd_sph50[index].cmd)
     {
-        if (0 == strcmp(argv[1], g_hdmDebugCmd[index].cmd))
+        if (0 == strcmp(argv[1], g_hdmDebugCmd_sph50[index].cmd))
         {
-            ret = g_hdmDebugCmd[index].procFunc(argc, argv);
+            ret = g_hdmDebugCmd_sph50[index].procFunc(argc, argv);
             if (RETURN_OK != ret)
             {
                 DBG_Print("error usage: ");
-                DBG_Print(g_hdmDebugCmd[index].cmdHelp);
+                DBG_Print(g_hdmDebugCmd_sph50[index].cmdHelp);
                 DBG_Print("\n");
             }
 
@@ -5247,11 +5247,11 @@
 }
 
 /**************************************************************************
-     :  ӡʹð
- :  command 
+ 功    能:  打印调试命令的使用帮助
+ 输入参数:  command 
             showDetail
- : 
- ֵ  :
+ 输出参数: 无
+ 返回值  :
 **************************************************************************/
 static void hdmDebugDoHdmHelp(char *command, int32_t showDetail)
 {
@@ -5260,9 +5260,9 @@
     UNREFERENCE_PARAM(command);
     UNREFERENCE_PARAM(showDetail);
     DBG_Print("\n");
-    while (NULL != g_hdmDebugCmd[infoIndex].cmd)
+    while (NULL != g_hdmDebugCmd_sph50[infoIndex].cmd)
     {
-        DBG_Print("%s\n",g_hdmDebugCmd[infoIndex].cmdHelp);
+        DBG_Print("%s\n",g_hdmDebugCmd_sph50[infoIndex].cmdHelp);
         infoIndex++;
     }
 }
@@ -5401,7 +5401,7 @@
     }
     /* End   Modified by d00282183 DTS2014111810841  20141119 */
 
-    /* ЧΪ2*/
+    /* 有效参数个数必须为2*/
     if (2 != validParamNum)
     {
         DBG_Print("The number of parameters is incorrect.\n");
@@ -5668,25 +5668,25 @@
 
 /*Begin Modified by t00352166 DTS2016111904167  20161119*/
 /**************************************************************************
-     : HDMѯӲдŴͳݵķֵ
- : data: ѯص 
+ 功    能: HDM查询硬盘写放大相关统计数据的返回值解析函数
+ 输入参数: data: 查询返回的 数据
                          
- : 
- ֵ  :
+ 输出参数: 无
+ 返回值  :
 **************************************************************************/
 void hdmDebugParsedataInfo(uint8_t *data)
 {
-    uint64_t hostWriteData = 0;             /*д*/
-    uint64_t nmWriteData = 0;               /*  nm     д*/
-    uint64_t gcWriteData = 0;               /*  gc      д*/
-    uint64_t bsWriteData = 0;               /*  bs      д*/
-    uint8_t *hostWriteDataBuffer = NULL;    /*дbufferַ*/
-    uint8_t *nmWriteDataBuffer = NULL;      /*  nm     дbufferַ*/
-    uint8_t *gcWriteDataBuffer = NULL;      /*  gc      дbufferַ*/
-    uint8_t *bsWriteDataBuffer = NULL;      /*  bs      дbufferַ*/
+    uint64_t hostWriteData = 0;             /*主机写数据量*/
+    uint64_t nmWriteData = 0;               /*  nm     写数据量*/
+    uint64_t gcWriteData = 0;               /*  gc      写数据量*/
+    uint64_t bsWriteData = 0;               /*  bs      写数据量*/
+    uint8_t *hostWriteDataBuffer = NULL;    /*主机写数据量的buffer地址*/
+    uint8_t *nmWriteDataBuffer = NULL;      /*  nm     写数据量的buffer地址*/
+    uint8_t *gcWriteDataBuffer = NULL;      /*  gc      写数据量的buffer地址*/
+    uint8_t *bsWriteDataBuffer = NULL;      /*  bs      写数据量的buffer地址*/
 
-    /*SCSI64ֽݣÿͳ8ֽ*/
-    /*32,40,48,56ֱʾݵĵ5,6,7,8*/
+    /*该SCSI命令返回64字节数据，每项统计数据8字节*/
+    /*32,40,48,56分别表示返回数据的第5,6,7,8项*/
     hostWriteDataBuffer = (uint8_t *)&data[32];
     nmWriteDataBuffer = (uint8_t *)&data[40];
     gcWriteDataBuffer = (uint8_t *)&data[48];
@@ -5737,15 +5737,15 @@
 }
 
 /**************************************************************************
-   : hdmDebugGetDiskDataStatDone
-     : HDMѯӲдŴͳ״̬ص
- : void *context :  
-                         char *buf       :ѯҳַ
-                         uint32_t len   :ѯҳ泤
-                         bool state    : 첽ִн(ɹ/ʧ) 
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugGetDiskDataStatDone
+ 功    能: HDM查询硬盘写放大相关统计数据状态回调函数
+ 输入参数: void *context : 上下文 
+                         char *buf       :查询结果的页面地址
+                         uint32_t len   :查询结果的页面长度
+                         bool state    : 异步函数执行结果(成功/失败) 
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugGetDiskDataStatDone(void *context, uint8_t *buf, uint32_t len, bool state)
 {
@@ -5764,11 +5764,11 @@
 }
 
 /**************************************************************************
-     : HDMѯӲдŴͳݵִк
- : argc: 
-                         argv: Ĳ
- : 
- ֵ  :
+ 功    能: HDM查询硬盘写放大相关统计数据的执行函数
+ 输入参数: argc: 输入参数个数
+                         argv: 输入的参数
+ 输出参数: 无
+ 返回值  :
 **************************************************************************/
 int32_t hdmDebugGetDiskDataStat(int32_t argc, char *argv[])
 {
@@ -5779,13 +5779,13 @@
     bool isNvmeDevice = FALSE;
     /* Dorado 5000 modified end */
 
-    /*3ʾħ*/
+    /*3表示参数个数，非魔鬼数字*/
     if (3 != argc)
     {
         return RETURN_ERROR;
     }
 
-    /*2ʾ2ħ*/
+    /*2表示第2个参数，非魔鬼数字*/
     sdevId = (uint32_t)LVOS_StrToU64(argv[2]);  
 
     /* Dorado 5000 modified begin */
@@ -5841,13 +5841,13 @@
 
 /*Modify by h00405124 DTS2017111300592 20171109*/
 /**************************************************************************
-  : hdmDebugDataDestroyCheckDone
-    : ѯƬٿصɺ
-: result: ѯĽ
-                        state: ״̬
-: 
-  ֵ: 
-    : 
+函 数 名: hdmDebugDataDestroyCheckDone
+功    能: 查询盘片的自销毁开关调试完成函数
+输入参数: result: 查询命令的结果
+                        state: 开关状态
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 void hdmDebugDataDestroyCheckDone(void *context, int32_t result, HDM_DATA_DESTROY_SWITCH state)
 {
@@ -5875,14 +5875,14 @@
 }
 
 /**************************************************************************
-  : hdmDebugCheckDataDestroy
-    : ѯƬٿ
-: argc: 
-          argv: Ĳ
-: 
-  ֵ: RETURN_OK: ִгɹ
-                     : ִʧ
-    : 
+函 数 名: hdmDebugCheckDataDestroy
+功    能: 查询盘片的自销毁开关
+输入参数: argc: 输入参数个数
+          argv: 输入的参数
+输出参数: 
+返 回 值: RETURN_OK: 执行成功
+                     其它: 执行失败
+其    它: 无
 **************************************************************************/
 int32_t hdmDebugCheckDataDestroy(int32_t argc, char *argv[])
 {
@@ -5907,12 +5907,12 @@
 /*End by h00405124 DTS2017111300592 20171109*/
 
 /**************************************************************************
-   : hdmDebugInit
-     : HDMԹܳʼ
- : void  
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugInit
+ 功    能: HDM调试功能初始化
+ 输入参数: void  
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugInit(void)
 {
@@ -5965,12 +5965,12 @@
 
 
 /**************************************************************************
-   : hdmDebugExit
-     : HDMԹ˳
- : void  
- : 
-   ֵ: 
-     : 
+ 函 数 名: hdmDebugExit
+ 功    能: HDM调试功能退出
+ 输入参数: void  
+ 输出参数: 无
+ 返 回 值: 无
+ 其    它: 无
 **************************************************************************/
 void hdmDebugExit(void)
 {
@@ -5988,7 +5988,73 @@
     {NULL, NULL, NULL}
 };
 
+uint32_t DpRtUpdateOneConfigDataSph050(char *itemName, uint32_t value)
+{
+    int32_t ret = RETURN_OK;
+    CST_ITEM_T item;
+    if (value == INVALID_VALUE32) {
+        return RETURN_OK;
+    }
+
+    (void)BDM_MEMSET_S(&item, sizeof(CST_ITEM_T), 0, sizeof(CST_ITEM_T));
+    (void)BDM_SNPRINTF_S(item.acValue, CST_MAX_ITEM_NAME_LEN - 1, "%u", value);
+    LVOS_strncpy(item.acName, itemName, CST_MAX_ITEM_NAME_LEN);
 
+    ret = CST_SetItem("BDM", &item);
+    if (ret != RETURN_OK) {
+        DBG_LogError(DBG_LOGID_NEW, "Set item %s value %u failed, ret %d.", itemName, value, ret);
+        return RETURN_ERROR;
+    }
 
+    ret = ECONF_ModifyConfig("BDM", item.acName, item.acValue);
+    DBG_LogInfo(DBG_LOGID_NEW, "Set item %s value %u ret %d.", itemName, value, ret);
+    return ret;
+}
 
+extern bool g_DpRtReportFaultSwitch;
 
+void HdmSetOrShowRootDiskFaultReportSwitch(int32_t argc, char *argv[])
+{
+   if (0 == strcmp(argv[2], "showreportswitch")) {
+       DBG_Print("The root disk report fault switch is:%s.\n", 
+           (true == g_DpRtReportFaultSwitch? "ON" : "OFF"));
+       return;
+   }
+   
+   if (0 == strcmp(argv[2], "setreportswitch")) {
+        if (argc != 4) {
+            DBG_ShowUsageAndErrMsg(NULL);
+            return;  
+        }
+        uint32_t tmpValue = LVOS_StrToU64(argv[3]);
+        if ((tmpValue != 0) && (tmpValue != 1)) {
+            DBG_Print("The value must be 0 or 1.");
+            return;        
+        }
+        
+        g_DpRtReportFaultSwitch = (bool)tmpValue;
+        if (DpRtUpdateOneConfigDataSph050("DpRtReportFaultSwitch", tmpValue) != RETURN_OK) {
+            DBG_LogError(0, "Save DpRtReportFaultSwitch failed!");
+            DBG_Print("Save DpRtReportFaultSwitch failed!\n");
+            return;
+        }
+        DBG_Print("Set the root disk report fault switch to %s successful.\n", 
+                (true == g_DpRtReportFaultSwitch? "ON" : "OFF"));
+
+        return;       
+   }
+}
+
+int32_t hdmDebugRootDiskReportSwitch(int32_t argc, char *argv[])
+{   
+    HdmSetOrShowRootDiskFaultReportSwitch(argc, argv);
+    return RETURN_OK;
+}
+
+HDM_DEBUG_CMD_S g_hdmDebugCmd_sph50[] =
+{
+    {"physwitch", hdmDebugPhySwitch, "hdm physwitch [frame id] [slot id] [0: off, 1: on]"},
+    {"powerctrl", hdmDebugPowerCtrl, "hdm powerctrl [frame id] [slot id] [0: auto, 1: reset, 2: on, 3: off]"},
+    {"rootdisk", hdmDebugRootDiskReportSwitch, "hdm rootdisk [showreportswitch/setreportswitch 'value[0/1]']"},
+    {NULL, NULL, NULL}  
+};
--- ./source/private_module/hdm/hdm_routine.c	2018-03-30 08:15:22.000000000 +0000
+++ ./source/private_module/hdm/hdm_routine.c.hotpatch	2023-01-13 03:15:33.000000000 +0000
@@ -1,15 +1,15 @@
 /**************************************************************************
-Ȩ (C) 2012 - 2012  Ϊּ(ɶ)޹˾
+版权所有 (C) 2012 - 2012  华为数字技术(成都)有限公司
 ***************************************************************************
-*   : 
-*     : l90006309
-* : 2012920
-* : HDM Ӳ
-*     ע: 
-* ޸ļ¼: 
-*        1.ʱ    : 
-*            : 
-*          ޸: 
+* 版 本 号: 初稿
+* 作    者: l90006309
+* 生成日期: 2012年9月20日
+* 功能描述: HDM 硬盘例测
+* 备    注: 
+* 修改记录: 
+*        1.时    间: 
+*          修 改 人: 
+*          修改内容: 
 **************************************************************************/
 #include "bdm_inc.h"
 #include "framework/cmm.h"
@@ -48,90 +48,90 @@
 /*End Modified by j90006936 DTS2014060500714 2014.6.5*/
 
 MODULE_ID(PID_BDM_HDM);
-
-/* Dorado 5000 modified begin */
-HDM_RT_FLOW_NODE g_nvmeFlow[HDM_RT_MAX_FLOW_CNT]; /* NVME̲ڵ */
+#include "customize.h"
+#include "econf.h"
+HDM_RT_FLOW_NODE g_nvmeFlow[HDM_RT_MAX_FLOW_CNT]; /* NVME例测流程步骤节点 */
 /* Dorado 5000 modified end */
 
 uint32_t g_tempInfoPoolId = 0;
 /*Modified by l00285244 for DTS2014072213296 end*/
 
-/*g_waitRtDiskg_waitSyncTimeDiskԤڴ ID*/
+/*g_waitRtDisk数组和g_waitSyncTimeDisk预留内存 的ID*/
 uint32_t g_waitRtDiskPoolId = 0;
 uint32_t g_waitRtProcHSSDPoolId[HDM_RT_SSD_BUTT];
 
 /**************************************************************************
-* ˼·:
-* 1.ͨIODѭʱжںͼͬһӲ̣ÿһΡ
-* 2.ӵIODִ߳С
-* 3.ͨg_routingOpeng_routingOne֤Ӳ̡
-* 4.⵽ӲԤʧЧ¶쳣ϱ
+* 设计思路:
+* 1.通过IOD循环定时器判断例测周期和间隔，对同一块硬盘，每个大周期最多例测一次。
+* 2.满足例测条件，将例测任务添加到IOD线程执行。
+* 3.通过对g_routingOpen和g_routingOne加锁，保证串行例测硬盘。
+* 4.例测到硬盘预失效和温度异常就上报。
 **************************************************************************/
 
-/* ̿ƽڵ */
-HDM_RT_FLOW_NODE g_flow[HDM_RT_MAX_FLOW_CNT];            /* ̲ڵ */
-uint32_t g_curStepId = HDM_RT_STEP_BUTT;                 /* ǰⲽID */
-int32_t g_curStepRet = RETURN_OK;                        /* ǰⲽ */
+/* 例测流程控制节点 */
+HDM_RT_FLOW_NODE g_flow[HDM_RT_MAX_FLOW_CNT];            /* 例测流程步骤节点 */
+uint32_t g_curStepId = HDM_RT_STEP_BUTT;                 /* 当前例测步骤ID */
+int32_t g_curStepRet = RETURN_OK;                        /* 当前例测步骤结果 */
 
-//static uint32_t g_waitRtDisk[HDM_MAX_WAIT_RT_NUM];              /* дӲ̵ID */
-uint32_t* g_waitRtDisk;                                 /* дӲ̵ID */
+//static uint32_t g_waitRtDisk[HDM_MAX_WAIT_RT_NUM];              /* 所有待例测硬盘的ID */
+uint32_t* g_waitRtDisk;                                 /* 所有待例测硬盘的ID */
 
 /*Modified by l00285244 for DTS2014072213296 begin*/
 DMI_DISK_TEMP_INFO_S* g_DmiTmpBuf;   
 /*Modified by l00285244 for DTS2014072213296 end*/
 
-uint32_t g_diskNum = 0;                                  /* Ӳ̸ */
-uint32_t g_index = 0;                                    /* ӲţСg_diskNum */
-int32_t g_rtTimerId = 0;                                 /* ⶨʱID */
+uint32_t g_diskNum = 0;                                  /* 本轮例测的硬盘个数 */
+uint32_t g_index = 0;                                    /* 正在例测的硬盘索引号，小于g_diskNum */
+int32_t g_rtTimerId = 0;                                 /* 例测定时器ID */
 
 
 /*Begin Modified by j90006936 DTS2014061905977  20140623*/
-uint32_t g_hddRtCycleSec = (12 * 3600);                  /* еΪ12Сʱ*/
+uint32_t g_hddRtCycleSec = (12 * 3600);                  /* 机械盘例测周期设置为12小时*/
 /*End Modified by j90006936 DTS2014061905977  20140623*/
-atomic_t g_cycleSec = ATOMIC_INIT(0);                    /* Ӳڣļж룬޸ */
-uint64_t g_cycleStartJiff = 0;                           /* Ӳڿʼʱ */
-uint32_t g_selfIntvSec = 0;                              /* Ӳ */
-int32_t g_alarmTemperatureHigh = 0;                          /* Ӳ¶ȸ澯ֵ */
-int32_t g_alarmTemperatureLow = 0;                       /* Ӳ¶ȸ澯ֵ*/
-int32_t g_resumeTemperatureHigh = 0;                         /* Ӳ̸澯»ֵָ */
-int32_t g_resumeTemperatureLow = 0;                      /* Ӳ̸澯»ֵָ*/
-int32_t g_curDiskTemperature = HDM_INVALID_TEMPERATURE;  /* ǰ̵¶ */
+atomic_t g_cycleSec = ATOMIC_INIT(0);                    /* 硬盘例测大周期，从配置文件中读入，调试命令可修改 */
+uint64_t g_cycleStartJiff = 0;                           /* 硬盘例测大周期开始时间 */
+uint32_t g_selfIntvSec = 0;                              /* 硬盘自身例测间隔 */
+int32_t g_alarmTemperatureHigh = 0;                          /* 硬盘温度告警值上限 */
+int32_t g_alarmTemperatureLow = 0;                       /* 硬盘温度告警值下限*/
+int32_t g_resumeTemperatureHigh = 0;                         /* 硬盘告警高温恢复值 */
+int32_t g_resumeTemperatureLow = 0;                      /* 硬盘告警低温恢复值*/
+int32_t g_curDiskTemperature = HDM_INVALID_TEMPERATURE;  /* 当前例测盘的温度 */
 /*Begin Modified by j90006936 DTS2014092800705 20141023*/
-uint32_t g_curDiskPowerOnTime = INVALID_VALUE32;          /* ǰ̵ϵʱ*/
+uint32_t g_curDiskPowerOnTime = INVALID_VALUE32;          /* 当前例测盘的上电时间*/
 /*End Modified by j90006936 DTS2014092800705 20141023*/
-bool g_currDiskPreFail = FALSE;                          /* ǰǷԤʧЧ */
+bool g_currDiskPreFail = FALSE;                          /* 当前例测盘是否预失效 */
 bool g_hssdHighTemperatureAlarmFlag = FALSE;
 
-uint64_t g_twoDiskIntvStartJiff = 0;                     /* Ӳʼʱ */
-uint64_t g_twoDiskIntvSec = 0;                           /* Ӳʱ */             
+uint64_t g_twoDiskIntvStartJiff = 0;                     /* 两块硬盘例测间隔开始时间 */
+uint64_t g_twoDiskIntvSec = 0;                           /* 两块硬盘例测间隔总时间 */             
 
-bool g_routingOpen = FALSE;                              /* ̱־ */
-bool g_routingOne = FALSE;                               /* ⵥ̱־ */
-bool g_updateDiskRtRecord = FALSE;                       /* ǷҪӲ̱¼ */
-bool g_gettingDiskList = FALSE;                          /* ڻȡӲб־ */
-bool g_updatingIntvTime = FALSE;                         /* ڸ־:ڡ */
+bool g_routingOpen = FALSE;                              /* 正在例测所有盘标志 */
+bool g_routingOne = FALSE;                               /* 正在例测单个盘标志 */
+bool g_updateDiskRtRecord = FALSE;                       /* 是否需要更新硬盘本次例测记录 */
+bool g_gettingDiskList = FALSE;                          /* 正在获取硬盘列表标志 */
+bool g_updatingIntvTime = FALSE;                         /* 正在更新例测间隔标志:包括例测周期、自身例测间隔、两盘例测间隔 */
 /*Modified by l00285244 for DTS2014072213296 begin*/
-int32_t g_notfTempToDmi = 0;                              /* DMI¶*/
+int32_t g_notfTempToDmi = 0;                              /* 正在向DMI发送温度数据*/
 /*Modified by l00285244 for DTS2014072213296 end*/
 int32_t g_reportDiskFinish = 0;
 
 //static uint32_t g_waitSyncTimeDisk[HDM_MAX_WAIT_RT_NUM];
 
-int32_t g_isProcOneSSD[HDM_RT_SSD_BUTT];           /*ڴ̱־*/
-int32_t g_isGettingSSDList[HDM_RT_SSD_BUTT];       /*ڻȡSSDб*/
-int32_t g_procSSDIndex[HDM_RT_SSD_BUTT];           /*ڴĵ̵index*/
-int32_t g_needProcSSDNum[HDM_RT_SSD_BUTT];         /*ҪӲ*/
-uint32_t *g_waitProcSSDDisk[HDM_RT_SSD_BUTT];      /*ҪӲ*/
-uint64_t g_procSSDStartTime[HDM_RT_SSD_BUTT];      /*ִĿʼʱ*/
-atomic_t g_rtSSDProcCycle[HDM_RT_SSD_BUTT];        /*Ӳ̴, λ*/
-int32_t g_procSSDTimerId[HDM_RT_SSD_BUTT];     /* ͬSSDʱڶʱID*/  
+int32_t g_isProcOneSSD[HDM_RT_SSD_BUTT];           /*正在处理单个盘标志*/
+int32_t g_isGettingSSDList[HDM_RT_SSD_BUTT];       /*正在获取SSD列表*/
+int32_t g_procSSDIndex[HDM_RT_SSD_BUTT];           /*正在处理的单盘的index*/
+int32_t g_needProcSSDNum[HDM_RT_SSD_BUTT];         /*需要处理的硬盘总数*/
+uint32_t *g_waitProcSSDDisk[HDM_RT_SSD_BUTT];      /*需要处理的所有硬盘*/
+uint64_t g_procSSDStartTime[HDM_RT_SSD_BUTT];      /*本轮处理的开始时间*/
+atomic_t g_rtSSDProcCycle[HDM_RT_SSD_BUTT];        /*硬盘处理周期, 单位秒*/
+int32_t g_procSSDTimerId[HDM_RT_SSD_BUTT];     /* 同步SSD时钟周期定时器ID*/  
 HDM_RT_SSD_PROC_TYPE_E g_ssdProcType[HDM_RT_SSD_BUTT];
 
-uint32_t g_diskPowerOnTime = 0;   /*ѯӲϵʱ(Сʱ)*/
-uint8_t g_usedLife1 = 0;         /*ѯӲĥ*/
-uint8_t g_usedLife2 = 0;         /*ѯӲĥС*/
+uint32_t g_diskPowerOnTime = 0;   /*例测查询的硬盘上电时间(小时)*/
+uint8_t g_usedLife1 = 0;         /*查询到的硬盘磨损度整数部分*/
+uint8_t g_usedLife2 = 0;         /*查询到的硬盘磨损度小数部分*/
 
-atomic_t g_isRtSSD = ATOMIC_INIT(0);                     /* ǷSSD־ */
+atomic_t g_isRtSSD = ATOMIC_INIT(0);                     /* 是否例测SSD标志 */
 
 /* Begin Modified by d00282183 DTS2014091702559 20141017 */
 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(3, 4, 0) )
@@ -148,15 +148,15 @@
     {NULL, NULL, NULL}
 };
 
+typedef struct {
+    uint8_t peLifeId;
+    uint8_t spareLifeId;
+    uint8_t peId;
+    uint8_t offlineUncId;
+    uint8_t onlineUncId;
+} DpRtSpecSmartId;
+
 
-/**************************************************************************
-  : hdmRtTwoCycleIntvOver
-    : Ƿڵļ
-: 
-: 
-  ֵ: TRUE: 㣬 FALSE: 
-    : 
-**************************************************************************/
 static bool hdmRtTwoCycleIntvOver(void)
 {
     uint64_t cycleSec = (uint32_t)atomic_read(&g_cycleSec);
@@ -164,12 +164,12 @@
 }
 
 /**************************************************************************
-  : hdmRtTwoDiskIntvOver
-    : Ƿ֮
-: 
-: 
-  ֵ: TRUE: 㣬 FALSE: 
-    : :ǰһʱ䵽һ⿪ʼʱ
+函 数 名: hdmRtTwoDiskIntvOver
+功    能: 检查是否满足两个盘之间例测间隔
+输入参数: 无
+输出参数: 无
+返 回 值: TRUE: 满足， FALSE: 不满足
+其    它: 例测间隔:前一个盘例测结束的时间到下一个盘例测开始的时间
 **************************************************************************/
 static bool hdmRtTwoDiskIntvOver(void)
 {
@@ -177,12 +177,12 @@
 }
 
 /**************************************************************************
-  : hdmRtTwiceIntvOver
-    : Ƿͬһ֮
-: sdevId: 豸ID
-: 
-  ֵ: TRUE: 㣬 FALSE: 
-    : :ǰһʱ䵽һ⿪ʼʱ
+函 数 名: hdmRtTwiceIntvOver
+功    能: 检查是否满足同一个盘两次之间例测间隔
+输入参数: sdevId: 设备ID
+输出参数: 无
+返 回 值: TRUE: 满足， FALSE: 不满足
+其    它: 例测间隔:前一次例测结束的时间到下一次例测开始的时间
 **************************************************************************/
 bool hdmRtTwiceIntvOver(uint32_t sdevId)
 {
@@ -202,16 +202,16 @@
     lastFinJiff = hdmDiskPriv->routineInfo.lastFinJiff;
     HDM_PUT_SD_DEV(sdDev);    
 
-    /* ⿪ʼһ */
+    /* 例测开始后第一次例测 */
     if (0 == lastFinJiff)
     {
         return TRUE;
     }
 
-    /* Ӳ */
+    /* 硬盘自身两次例测间隔 */
     intvSec = g_selfIntvSec;
 
-    /* ע룬Ӳ̵ûм */
+    /* 调试注入，硬盘的两次例测没有间隔 */
     HDM_RT_NO_INTV_TRACE_POINT_TEST(&lastFinJiff, &intvSec);
 
     DBG_LogDebug(LOG_ID_HDM_0240, "BDM_RT:Disk SdevId(%u) lastfinFiss(%llu), selfintvJiff(%u), currJiff(%lld).",
@@ -223,12 +223,12 @@
 void stub_hdmRtOneDiskEnd(void);
 
 /**************************************************************************
-  : hdmRtOneDiskEnd
-    : 
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtOneDiskEnd
+功    能: 单盘例测完成
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 void hdmRtOneDiskEnd(void)
 {
@@ -239,12 +239,12 @@
 
 
 /**************************************************************************
-  : hdmRtToNextStep
-    : ̵ִһ
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtToNextStep
+功    能: 执行例测流程的下一步
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 void hdmRtToNextStep(void)
 {
@@ -265,7 +265,7 @@
 
     if (isNvmeDevice)
     {
-        /* ݵǰȡһID */
+        /* 根据当前例测结果，取出下一步骤ID */
         if (RETURN_OK == g_curStepRet)
         {
             nextStepId = g_nvmeFlow[g_curStepId].retOkBranch;
@@ -279,7 +279,7 @@
     }
     else
     {
-        /* ݵǰȡһID */
+        /* 根据当前例测结果，取出下一步骤ID */
         if (RETURN_OK == g_curStepRet)
         {
             nextStepId = g_flow[g_curStepId].retOkBranch;
@@ -297,7 +297,7 @@
         "BDM_RT:Disk SdevId(%u) cur step id(%u), cur step ret(%d), next step id(%u).",
         g_waitRtDisk[g_index], g_curStepId, g_curStepRet, nextStepId);
 
-    /* ȡһ */
+    /* 获取下一步的例测入口 */
     if (NULL == nextStepEntrance)
     {
         DBG_LogError(LOG_ID_HDM_0244,
@@ -359,12 +359,12 @@
 void stub_hdmRtOneDiskBegin(void);
 
 /**************************************************************************
-  : hdmRtOneDiskBegin
-    : ⿪ʼ
-: 
-: 
-  ֵ: 
-    : Ӳ̴⣬
+函 数 名: hdmRtOneDiskBegin
+功    能: 单盘例测开始
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 硬盘串行例测，函数不能重入
 **************************************************************************/
 static void hdmRtOneDiskBegin(void)
 {
@@ -372,48 +372,47 @@
     stub_hdmRtOneDiskBegin();
     return;
 }
-
+int32_t DpRtQuerySpecSmartId(uint32_t sdevId, DpRtSpecSmartId *smartIds);
+void DpRtParseScsiAtaSmartPrefailSph(uint32_t sdevId, HDM_ATA_SMART_DATA_S *smart, HDM_SMART_THRESHOLD_VALUE_S *threshs);
+void DpRtUpdateUncRecordHandle(uint32_t sdevId, HDM_ATA_SMART_DATA_S *smart, HDM_SMART_THRESHOLD_VALUE_S *threshs);
 /*****************************************************************************
-  : hdmRtDoComAtaDiskPreFail
-    : ѯͨõATAԤʧЧϢ
-: sdevId: 豸ID
-smart: smartϢ
-threshs: ֵ
-: 
-  ֵ: 0 , 0 ʧЧ, ֵʾʧЧsmart attribute id
-    : 
+函 数 名: hdmRtDoComAtaDiskPreFail
+功    能: 查询通用的ATA盘预失效信息
+输入参数: sdevId: 设备ID
+smart: smart信息
+threshs: 门限值
+返 回 值: 0 正常, 非0 失效, 值表示失效的smart attribute id
 *****************************************************************************/
 static uint8_t hdmRtDoComAtaDiskPreFail(uint32_t sdevId, 
                                         HDM_ATA_SMART_DATA_S *smart,
                                         HDM_SMART_THRESHOLD_VALUE_S *threshs)
 {
     uint32_t i = 0;
-
-    /* ԱȵǰֵֵֵжӲǷԤʧЧ */
+    DpRtSpecSmartId smartIds = {0, 0, 0, 0, 0};
+    (void)DpRtQuerySpecSmartId(sdevId, &smartIds);
     for (i=0; i<HDM_SMART_ATTR_NUMBER; i++)
     {
-        /* trace point עsmartʧЧ */
         HDM_RT_ATA_DISK_PRE_FAIL_TRACE_POINT_TEST(smart, threshs, i);
-
         if ((0 == smart->attrEntries[i].id) || (0 == threshs[i].id))
         {
             continue;
         }
-
-        /* ¶190194ΪԤʧЧж,Tϵбһ */
-        if ((HDM_SMART_TEMPERATURE == threshs[i].id) 
-            || (HDM_SMART_AIRFLOW_TEMPERATURE == threshs[i].id))
+        if ((HDM_SMART_TEMPERATURE == threshs[i].id) ||
+            (HDM_SMART_AIRFLOW_TEMPERATURE == threshs[i].id))
         {
             continue;
         }
-
-        /* ֵΪ0ԤʧЧж */
-        /*Begin Modified by l00245290 DTS2015050503673 20150507*/
+        if (hdmIsRootDisk(sdevId)) { // 系统盘pe和空白块走新逻辑，此处屏蔽
+            if ((threshs[i].id == smartIds.peLifeId) ||
+ 	 	        (threshs[i].id == smartIds.peId) ||
+ 	 	        (threshs[i].id == smartIds.spareLifeId)) {
+                    continue;
+                }
+        }
         if (0 == threshs[i].threshold)
         {
             continue;
         }
-        /*End Modified by l00245290 DTS2015050503673 20150507*/
         if ((smart->attrEntries[i].curValue <= threshs[i].threshold)
             || (smart->attrEntries[i].worst <= threshs[i].threshold))
         {
@@ -429,21 +428,22 @@
             return smart->attrEntries[i].id;
         }            
     }
-
+    DpRtParseScsiAtaSmartPrefailSph(sdevId, smart, threshs);
+    DpRtUpdateUncRecordHandle(sdevId, smart, threshs); /* 更新unc信息 */    
     return 0;
 }
 
 /*****************************************************************************
-  : hdmRtAdjustAtaDiskPreFail
-    : ֵжԤʧЧ
-: sdevId: 豸ID
-smart: smartϢ
-threshs: ֵ
-adjustId: ID
-adjustValue: ֵ
-: 
-  ֵ: 0 0 smartʧЧֵݼHDM_BUILD_PRE_FAIL_CODE
-    : 
+函 数 名: hdmRtAdjustAtaDiskPreFail
+功    能: 调整门限值后再判断预失效情况
+输入参数: sdevId: 设备ID
+smart: smart信息
+threshs: 门限值
+adjustId: 待调整的门限ID
+adjustValue: 待调整的门限值
+输出参数: 无
+返 回 值: 0 正常，非0 smart失效，值内容见HDM_BUILD_PRE_FAIL_CODE
+其    他: 无
 *****************************************************************************/
 static uint32_t hdmRtAdjustAtaDiskPreFail(uint32_t sdevId, 
                                           HDM_ATA_SMART_DATA_S *smart,
@@ -455,7 +455,7 @@
     uint8_t oldThreshold = 0;
     uint8_t itemId = 0;
 
-    /* ָIDֵ */
+    /* 调整指定ID的门限值 */
     for (i=0; i<HDM_SMART_ATTR_NUMBER; i++)
     {
         if (adjustId != threshs[i].id)
@@ -482,15 +482,15 @@
 }
 
 /*****************************************************************************
-  : hdmRtHuaSyAtaDiskPreFail
-    : ѯ̵ͬATAԤʧЧϢ
-: sdevId: 豸ID
-smart: smartϢ
-threshs: ֵ
-: 
-  ֵ: 0 0 smartʧЧֵݼHDM_BUILD_PRE_FAIL_CODE
-    :  ID = 251
- ID = 242
+函 数 名: hdmRtHuaSyAtaDiskPreFail
+功    能: 查询不同厂商的ATA盘预失效信息
+输入参数: sdevId: 设备ID
+smart: smart信息
+threshs: 门限值
+输出参数: 无
+返 回 值: 0 正常，非0 smart失效，值内容见HDM_BUILD_PRE_FAIL_CODE
+其    他: 擦除寿命 ID = 251
+超级电容 ID = 242
 *****************************************************************************/
 static uint32_t hdmRtHuaSyAtaDiskPreFail(uint32_t sdevId, 
                                          HDM_ATA_SMART_DATA_S *smart,
@@ -500,7 +500,7 @@
 
     for (i = 0; i < HDM_SMART_ATTR_NUMBER; i++)
     {
-        /* trace point עsmartʧЧ */
+        /* trace point 注入smart项失效调试 */
         HDM_RT_ATA_DISK_PRE_FAIL_TRACE_POINT_TEST(smart, threshs, i);
 
         if ((0 == smart->attrEntries[i].id) || (0 == threshs[i].id))
@@ -515,7 +515,7 @@
         }
 
 
-        /* ʧЧ */
+        /* 超级电容失效 */
         if ((HDM_SMART_HSSD_CAPACITOR_STATUS == smart->attrEntries[i].id))
         {
             if (0 == smart->attrEntries[i].curValue)
@@ -534,7 +534,7 @@
 
         }
 
-        /* ֻԱȵǰֵֵԱֵֵTϵбһ */
+        /* 只对比当前值与门限值，不对比最差值与门限值，与T系列保持一致 */
         if (smart->attrEntries[i].curValue <= threshs[i].threshold)
         {
             DBG_LogError(LOG_ID_HDM_024C, 
@@ -555,14 +555,14 @@
 
 
 /*****************************************************************************
-  : hdmRtVendorAtaDiskPreFail
-    : ѯ̵ͬATAԤʧЧϢ
-: sdevId: 豸ID
-smart: smartϢ
-threshs: ֵ
-: 
-  ֵ: 0 0 smartʧЧֵݼHDM_BUILD_PRE_FAIL_CODE
-    : 
+函 数 名: hdmRtVendorAtaDiskPreFail
+功    能: 查询不同厂商的ATA盘预失效信息
+输入参数: sdevId: 设备ID
+smart: smart信息
+threshs: 门限值
+输出参数: 无
+返 回 值: 0 正常，非0 smart失效，值内容见HDM_BUILD_PRE_FAIL_CODE
+其    他: 无
 *****************************************************************************/
 uint32_t hdmRtDoVendorAtaDiskPreFail(uint32_t sdevId, 
                                      HDM_ATA_SMART_DATA_S *smart,
@@ -598,7 +598,7 @@
     case HDM_VENDOR_BUTT:
         itemId = hdmRtDoComAtaDiskPreFail(sdevId, smart, threshs);
         /*Begin Modified by z90005565 DTS2018032714258 20180328*/
-        /* ģϵͳ̳SMARTʧ */
+        /* 模拟系统盘厂商SMART检查失败 */
         SMART_TP_CALL(HDM_RT_ROOT_SMART_FAIL, &itemId);
         /*End Modified by z90005565 DTS2018032714258 20180328*/
         return (0 == itemId) ? 0 : HDM_ATA_PRE_FAIL(itemId);
@@ -615,12 +615,12 @@
 void stub_hdmRtGetAtaDiskPreFailInfoDone(REQ_S * smartReq);
 
 /*****************************************************************************
-  : hdmRtGetAtaDiskPreFailInfoDone
-    : ѯATA̵SMART ֵص
-: threshReq: ѯSMARTREQ
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtGetAtaDiskPreFailInfoDone
+功    能: 查询ATA盘的SMART 门限值回调函数
+输入参数: threshReq: 查询SMART的REQ
+输出参数: 无
+返 回 值: 无
+其    他: 无
 *****************************************************************************/
 void hdmRtGetAtaDiskPreFailInfoDone(REQ_S * smartReq)
 {
@@ -632,12 +632,12 @@
 void stub_hdmRtGetAtaDiskSmartThreshDone(REQ_S * threshReq);
 
 /*****************************************************************************
-  : hdmRtGetAtaDiskSmartThreshDone
-    : ѯATA̵SMART ֵص
-: threshReq: ѯSMARTֵREQ
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtGetAtaDiskSmartThreshDone
+功    能: 查询ATA盘的SMART 门限值回调函数
+输入参数: threshReq: 查询SMART门限值的REQ
+输出参数: 无
+返 回 值: 无
+其    他: 无
 *****************************************************************************/
 void hdmRtGetAtaDiskSmartThreshDone(REQ_S * threshReq)
 {
@@ -651,15 +651,15 @@
                                         HDM_GET_PRE_FAIL_DONE done);
 
 /*****************************************************************************
-  : hdmRtGetAtaDiskPreFailInfo
-    : ȡScsiӲԤʧЧϢ
-: sdevId: 豸id
-context: ߵ
-done: ߵĻص
-: 
-  ֵ: RETURN_OK: ɹ
-RETURN_ERROR: ʧ
-    : Ȼȡֵ ٻȡsmartϢ, жԱж
+函 数 名: hdmRtGetAtaDiskPreFailInfo
+功    能: 获取Scsi硬盘预失效信息
+输入参数: sdevId: 设备id
+context: 调用者的上下文
+done: 调用者的回调函数
+输出参数: 
+返 回 值: RETURN_OK: 成功
+RETURN_ERROR: 失败
+其    他: 先获取门限值 再获取smart信息, 最后进行对比判断
 *****************************************************************************/
 static int32_t hdmRtGetAtaDiskPreFailInfo(uint32_t sdevId, 
                                           void *context, 
@@ -670,12 +670,12 @@
 }
 
 /*****************************************************************************
-  : hdmRtSupportIELog
-    : жӲǷ֧IE Log
-: sdevId: 豸id
-: 
-  ֵ: TRUE: ֧ FALSE: ֧
-    : 
+函 数 名: hdmRtSupportIELog
+功    能: 判断硬盘是否支持IE Log
+输入参数: sdevId: 设备id
+输出参数: 
+返 回 值: TRUE: 支持 FALSE: 不支持
+其    他: 无
 *****************************************************************************/
 static bool hdmRtSupportIELog(uint32_t sdevId)
 {
@@ -704,12 +704,12 @@
 void stub_hdmRtGetIELogPreFailDone(REQ_S *req);
 
 /*****************************************************************************
-  : hdmRtGetIELogPreFailDone
-    : ѯIE LOGĻص
-: req: ·IE LOGREQ
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtGetIELogPreFailDone
+功    能: 查询IE LOG命令的回调函数
+输入参数: req: 下发IE LOG命令的REQ
+输出参数: 无
+返 回 值: 无
+其    他: 无
 *****************************************************************************/
 static void hdmRtGetIELogPreFailDone(REQ_S *req)
 {
@@ -721,12 +721,12 @@
 void stub_hdmRtGetReqSensePreFailDone(REQ_S *req);
 
 /*****************************************************************************
-  : hdmRtGetReqSensePreFailDone
-    : ѯrequeset senseĻص
-: req: ·IE LOGREQ
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtGetReqSensePreFailDone
+功    能: 查询requeset sense命令的回调函数
+输入参数: req: 下发IE LOG命令的REQ
+输出参数: 无
+返 回 值: 无
+其    他: 无
 *****************************************************************************/
 static void hdmRtGetReqSensePreFailDone(REQ_S *req)
 {
@@ -737,15 +737,15 @@
 
 
 /*****************************************************************************
-  : hdmRtGetScsiDiskComPreFailInfo
-    : ȡScsiӲ̹ԤʧЧϢ
-: sdevId: 豸id
-context: ߵ
-done: ߵĻص
-: 
-  ֵ: RETURN_OK: ɹ
-RETURN_ERROR: ʧ
-    : 
+函 数 名: hdmRtGetScsiDiskComPreFailInfo
+功    能: 获取Scsi硬盘公共预失效信息
+输入参数: sdevId: 设备id
+context: 调用者的上下文
+done: 调用者的回调函数
+输出参数: 
+返 回 值: RETURN_OK: 成功
+RETURN_ERROR: 失败
+其    他: 无
 *****************************************************************************/
 static int32_t hdmRtGetScsiDiskComPreFailInfo(uint32_t sdevId, 
                                               void *context, 
@@ -759,7 +759,7 @@
 
     DBG_LogDebug(LOG_ID_HDM_0259, "BDM_RT:Disk SdevId(%u) start to get half life info.", sdevId);
 
-    /* ֧IE LogѯԤʧЧϢ */
+    /* 支持IE Log查询预失效信息 */
     if (hdmRtSupportIELog(sdevId))
     {
         hdmReqPriv.fnFillCdb = hdmScsiFillLogSenseCdbOp;
@@ -767,7 +767,7 @@
         logPageCode = (uint8_t *)HDM_PRIVATE_TO_RESERVE(&hdmReqPriv);
         *logPageCode = HDM_IE_LOG_PG_CODE;
     }
-    else /* ֧Requeset sense ѯԤʧЧϢ */
+    else /* 支持Requeset sense 查询预失效信息 */
     {
         hdmReqPriv.fnFillCdb = hdmScsiFillRequestSenseCdbOp;
         hdmReqPriv.fnTaskDone = hdmRtGetReqSensePreFailDone;
@@ -791,12 +791,12 @@
 
 /* BDM R1 T11A-922 added by l90006309 2012-10-17 begin */
 /*****************************************************************************
-  : hdmRtGetScsiHSSDPreFailInfoDone
-    : SASӿHSSSDԤʧЧĻص
-: req: ·IE LOGREQ
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtGetScsiHSSDPreFailInfoDone
+功    能: SAS接口HSSSD检查预失效的回调函数
+输入参数: req: 下发IE LOG命令的REQ
+输出参数: 无
+返 回 值: 无
+其    他: 无
 *****************************************************************************/
 static void hdmRtGetScsiHSSDPreFailInfoDone(REQ_S *req)
 {
@@ -820,20 +820,20 @@
             break;
         }
 
-        /* ʧЧ trace point ע */
+        /* 超级电容失效 trace point 调试注入 */
         HDM_RT_HSSD_CAPACITOR_FAIL_TRACE_POINT_TEST(req);
 
         logData = (uint8_t *)req->sgl->entrys[0].buf;
 
-        /* SAS HSSDϢ35h log pageĵ160163ֽڴ
-        οHSSD Diamond3 SAS SLC SSDӦЭӿ˵ */  
+        /* SAS HSSD超级电容信息在35h log page的第160至163字节处，
+        参考HSSD Diamond3 SAS SLC SSD应用协议接口说明书 */  
         if (HDM_SMART_HSSD_CAPACITOR_STATUS != logData[160])
         {
             DBG_LogError(LOG_ID_HDM_025C, "BDM_RT:Disk SdevId(%u) smart id:%u, which is supposed to be 242.", sdDev->sdevId, logData[160]);
             break;
         }
 
-        /* 0ʾnot ready 171ֽ*/
+        /* 0表示超级电容not ready 第171字节*/
         if (0 == logData[171])
         {
             done(context, RETURN_OK, HDM_HSSD_SCSI_PRE_FAIL(HDM_SMART_HSSD_CAPACITOR_STATUS));
@@ -843,7 +843,7 @@
     }while(0);
 
 
-    /* HS SSD ̵ͨԤʧЧϢ */
+    /* HS SSD 超级电容正常，继续检查该盘的通用预失效信息 */
     /*Begin Modified by j90006936 DTS2014061905977  20140623*/
     DBG_LogDebug(LOG_ID_HDM_025E, 
         "BDM_RT:After check super capacitor, disk SdevId(%u) continue to get pre invalid info by com fun.", sdDev->sdevId);
@@ -859,15 +859,15 @@
 
 /* BDM R1 T11A-922 added by l90006309 2012-10-17 begin */
 /*****************************************************************************
-  : hdmRtGetIELogPreFailDone
-    : SASӿHSSSDԤʧЧ
-: sdevId: 豸id
-context: ߵ
-done: ߵĻص
-: 
-  ֵ: RETURN_OK: ɹ
-RETURN_ERROR: ʧ
-    : 
+函 数 名: hdmRtGetIELogPreFailDone
+功    能: SAS接口HSSSD检查预失效
+输入参数: sdevId: 设备id
+context: 调用者的上下文
+done: 调用者的回调函数
+输出参数: 
+返 回 值: RETURN_OK: 成功
+RETURN_ERROR: 失败
+其    他: 无
 *****************************************************************************/
 static int32_t hdmRtGetScsiHSSDPreFailInfo(uint32_t sdevId, 
                                            void *context, 
@@ -907,15 +907,15 @@
 
 /* BDM R1 T11A-922 added by l90006309 2012-10-17 begin */
 /*****************************************************************************
-  : hdmRtGetScsiDiskPreFailInfo
-    : ȡScsiӲԤʧЧϢ
-: sdevId: 豸id
-context: ߵ
-done: ߵĻص
-: 
-  ֵ: RETURN_OK: ɹ
-RETURN_ERROR: ʧ
-    : 
+函 数 名: hdmRtGetScsiDiskPreFailInfo
+功    能: 获取Scsi硬盘预失效信息
+输入参数: sdevId: 设备id
+context: 调用者的上下文
+done: 调用者的回调函数
+输出参数: 
+返 回 值: RETURN_OK: 成功
+RETURN_ERROR: 失败
+其    他: 无
 *****************************************************************************/
 static int32_t hdmRtGetScsiDiskPreFailInfo(uint32_t sdevId, 
                                            void *context, 
@@ -927,7 +927,7 @@
     }
     else
     {
-        /* ǻSASӿڵSSD,ֱӻȡͨԤʧЧϢ */
+        /* 非华赛SAS接口的SSD盘,直接获取通用预失效信息 */
         if (!hdmHuaSySSD(sdevId))
         {   
             DBG_LogDebug(LOG_ID_HDM_0261,
@@ -936,7 +936,7 @@
             return hdmRtGetScsiDiskComPreFailInfo(sdevId, context, done);
         }
 
-        /* SASӿڵSSḌжϳݣжͨԤʧЧϢ */
+        /* 华赛SAS接口的SSD盘，先判断超级电容，再判断通用预失效信息 */
         if (RETURN_OK != hdmRtGetScsiHSSDPreFailInfo(sdevId, context, done)) 
         {
             return hdmRtGetScsiDiskComPreFailInfo(sdevId, context, done);
@@ -952,15 +952,15 @@
 /* BDM R1 T11A-922 added by l90006309 2012-10-17 end */
 
 /*****************************************************************************
-  : hdmRtGetPreFailInfo
-    : ȡӲԤʧЧϢ
-: sdevId: 豸id
-context: ߵ
-done: ߵĻص
-: 
-  ֵ: RETURN_OK: ɹ
-RETURN_ERROR: ʧ
-    : 
+函 数 名: hdmRtGetPreFailInfo
+功    能: 获取硬盘预失效信息
+输入参数: sdevId: 设备id
+context: 调用者的上下文
+done: 调用者的回调函数
+输出参数: 
+返 回 值: RETURN_OK: 成功
+RETURN_ERROR: 失败
+其    他: 无
 *****************************************************************************/
 int32_t hdmRtGetPreFailInfo(uint32_t sdevId, void *context, HDM_GET_PRE_FAIL_DONE done)
 {
@@ -999,12 +999,12 @@
 
 
 /**************************************************************************
-  : hdmRtGetScsiDiskTemperatureDone
-    : ȡSCSIӲ¶Ȼص
-: req : ѯ¶ȵREQ
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtGetScsiDiskTemperatureDone
+功    能: 获取SCSI硬盘温度回调函数
+输入参数: req : 查询温度的REQ
+输出参数: 无
+返 回 值: 无
+其    他: 无
 **************************************************************************/
 void hdmRtGetScsiDiskTemperatureDone(REQ_S *req)
 {
@@ -1029,7 +1029,7 @@
 
     buf = (uint8_t *)req->sgl->entrys[0].buf;
 
-    /* Temperature page, οspc4r17 table-326 byte-9Ϊǰ¶ */
+    /* 解析Temperature page, 参考spc4r17 table-326 byte-9为当前温度 */
     temperature = (int32_t)buf[9];
     DBG_LogDebug(LOG_ID_HDM_0267, "BDM_RT:Disk SdevId(%u) temperature %d.", sdDev->sdevId, temperature);
     saveDone(saveContext, RETURN_OK, temperature);
@@ -1038,12 +1038,12 @@
 }
 
 /*****************************************************************************
-  : hdmRtGetAtaDiskTemperatureDone
-    : ȡATAӲ¶Ȼص
-: req : ѯ¶ȵREQ
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtGetAtaDiskTemperatureDone
+功    能: 获取ATA硬盘温度回调函数
+输入参数: req : 查询温度的REQ
+输出参数: 无
+返 回 值: 无
+其    他: 无
 *****************************************************************************/
 void hdmRtGetAtaDiskTemperatureDone(REQ_S *req)
 {
@@ -1076,7 +1076,7 @@
 
     smartInfo = (HDM_ATA_SMART_DATA_S *)(void *)req->sgl->entrys[0].buf;
 
-    /* ȡSATA̵¶*/
+    /* 获取SATA盘的温度*/
     for (i = 0; i < HDM_SMART_ATTR_NUMBER; i++)
     {
         diskAttr = smartInfo->attrEntries + i;
@@ -1085,11 +1085,11 @@
             continue;
         }
 
-        /*һ,temp[0]ʾӲ̵ĵǰ¶,temp[1]
-        ʾӲ̵С¶,temp[2]ʾӲ̵¶*/
+        /*一般地,temp[0]表示硬盘的当前温度,temp[1]
+        表示硬盘的最小温度,temp[2]表示硬盘的最高温度*/
         if (!strncmp(sdDisk->vendor, HDM_DISK_VENDOR_STEC, strlen(HDM_DISK_VENDOR_STEC)))
         {
-            /* ֽ0ΪС¶ȣֽ1Ϊǰ¶ȣֽ2Ϊ¶*/
+            /* 字节0为最小温度，字节1为当前温度，字节2为最大温度*/
             temperature = (int32_t)diskAttr->raw[1];
             break;
         }
@@ -1107,7 +1107,7 @@
         break;
     }
 
-    /* SMARTпû¶ */
+    /* SMART中可能没有温度数据 */
     if (HDM_SMART_ATTR_NUMBER == i)
     {
         DBG_LogError(LOG_ID_HDM_0269, 
@@ -1125,15 +1125,15 @@
 int32_t stub_hdmRtGetTemperature(uint32_t sdevId, void *context, HDM_GET_TMP_DONE done);
 
 /*****************************************************************************
-  : hdmRtGetTemperature
-    : ȡӲ¶
-: sdevId: 豸id
-context: ߵ
-done: ߵĻص
-: 
-  ֵ: RETURN_OK: ɹ
-RETURN_ERROR: ʧ
-    : 
+函 数 名: hdmRtGetTemperature
+功    能: 获取硬盘温度
+输入参数: sdevId: 设备id
+context: 调用者的上下文
+done: 调用者的回调函数
+输出参数: 
+返 回 值: RETURN_OK: 成功
+RETURN_ERROR: 失败
+其    他: 无
 *****************************************************************************/
 int32_t hdmRtGetTemperature(uint32_t sdevId, void *context, HDM_GET_TMP_DONE done)
 {
@@ -1142,12 +1142,12 @@
 }
 
 /**************************************************************************
-  : hdmRtSetTwodDiskIntvTime
-    : Ӳ
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtSetTwodDiskIntvTime
+功    能: 设置两个硬盘例测间隔
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 
 **************************************************************************/
 void hdmRtSetTwodDiskIntvTime(void)
 {   
@@ -1164,10 +1164,10 @@
         return;
     }
 
-    /*  */
+    /* 计算例测间隔 */
     g_twoDiskIntvSec = (uint32_t)atomic_read(&g_cycleSec) / g_diskNum;
 
-    /* С(ǰһʱ䵽һ⿪ʼʱ)Ϊ1, 1Ӱ */
+    /* 最小例测间隔(前一块盘例测结束的时间到下一块盘例测开始时间)为1秒, 低于1秒会影响性能 */
     if (1 > g_twoDiskIntvSec)
     {
         g_twoDiskIntvSec = 1;
@@ -1180,12 +1180,12 @@
 
 
 /**************************************************************************
-  : hdmRtGetDiskListStart
-    : SDģȡӲбִк
-: arg : 
-: 
-  ֵ: 
-    : ͨIDжӲǷ. 
+函 数 名: hdmRtGetDiskListStart
+功    能: 从SD模块获取硬盘列表执行函数
+输入参数: arg : 工作队列上下文
+输出参数: 无
+返 回 值: 无
+其    它: 通过ID判断硬盘是否存在. 
 **************************************************************************/
 static void hdmRtGetDiskListStart(void *arg)
 {
@@ -1214,7 +1214,7 @@
         }   
 
         /* BDM R1 T11A-931 modified by l90006309 2012-10-31 begin */
-        /* ֻӲ */
+        /* 只例测正常接入的硬盘 */
         if ((SCSI_DEVICE_TYPE_DISK != sdDev->type) || (0 != sdDev->problem))
         {
             SD_PUT_DEVICE(sdDev);
@@ -1222,23 +1222,23 @@
         }
         /* BDM R1 T11A-931 modified by l90006309 2012-10-31 end */        
 
-        /* ¼ӲIDб */
+        /* 记录硬盘ID到待例测列表中 */
         g_waitRtDisk[g_diskNum++] = sdevId;  
         SD_PUT_DEVICE(sdDev);
     }
 
-    /* ҲӲ̣һٲ */
+    /* 查找不到硬盘，下一个大周期再查找 */
     if (0 == g_diskNum)
     {
-        DBG_LogDebug(LOG_ID_HDM_0277, "BDM_RT:No disk need to routinecheck disk list in next big cycle.");
+        DBG_LogDebug(LOG_ID_HDM_0277, "BDM_RT:No disk need to routine，check disk list in next big cycle.");
         g_cycleStartJiff = jiffies;                     
     }
     else
     {
-        /* DTע룬ÿֻ3 */
+        /* DT调试注入，每个周期只例测3块盘 */
         HDM_RT_THREE_DISK_PER_CYCLE_TRACE_POINT_TEST(&g_diskNum); 
 
-        /* ֮ */
+        /* 设置两个盘之间例测间隔 */
         hdmRtSetTwodDiskIntvTime();
         g_twoDiskIntvStartJiff = 0; 
     }       
@@ -1255,12 +1255,12 @@
 }
 
 /**************************************************************************
-  : hdmRtGetDiskList
-    : SDģȡӲб
-: 
-: 
-  ֵ: 
-    : лִлȡӲб
+函 数 名: hdmRtGetDiskList
+功    能: 从SD模块获取硬盘列表
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 切换到工作队列执行获取硬盘列表
 **************************************************************************/
 static void hdmRtGetDiskList(void)
 {
@@ -1291,12 +1291,12 @@
 
 /*Modified by l00285244 for DTS2014072213296 begin*/
 /**************************************************************************
-*   : hdmAllocDmiTmpBuf
-*    :Ϊg_DmiTmpBufռ
-* : num: buf
-* : 
-*   ֵ: bool
-*     : 
+* 函 数 名: hdmAllocDmiTmpBuf
+*功    能:为g_DmiTmpBuf分配空间
+* 输入参数: num: 分配buf数
+* 输出参数: 无
+* 返 回 值: bool
+* 其    他: 无
 **************************************************************************/
 
 bool hdmAllocDmiTmpBuf(uint32_t num)
@@ -1320,13 +1320,13 @@
 }
 
 /**************************************************************************
-  : hdmRtFillTemperatureByFrame
-    : Ӳ¶Ϣ
-: frameWWN: wwnframeId: 
-slotID:ۺţindex:λñ
-: 
-  ֵ: FALSE/TRUE
-    : 
+函 数 名: hdmRtFillTemperatureByFrame
+功    能: 填充硬盘温度信息
+输入参数: frameWWN: 框wwn，frameId: 框号
+slotID:槽号，index:填充位置编号
+输出参数: 无
+返 回 值: FALSE/TRUE
+其    它: 
 **************************************************************************/
 /* Dorado 5000 modified begin */
 bool hdmRtFillTemperatureByFrame(uint64_t enclosureWWN, 
@@ -1373,7 +1373,7 @@
     if ((sdDisk->frameId == frameId) && (sdDisk->slotId == slotId))
     {
         /* Dorado 5000 modified begin */
-        /*disktypeתΪʷ룬ѾDMI,BMCȷDiskTypeֶδʹãԴ˴תʽ */
+        /*这里的disktype转化为历史代码，已经与DMI,BMC确认DiskType字段未使用，请忽略此处的转化方式 */
         diskTempInfo->DiskType = (DMI_DISK_TYPE_E)(int32_t)sdDisk->type;
         diskTempInfo->DiskSlot = sdDisk->slotId;
         diskTempInfo->DiskSmartTemp = (OSP_S16)hdmDiskPriv->routineInfo.temperature;
@@ -1394,12 +1394,12 @@
 void stub_hdmRtNtfTempForInch25Dsk(uint64_t *frameWwn, uint32_t frameId);
 
 /**************************************************************************
-  : hdmRtNtfTempForInch25
-    : 2.5¶Ϣ
-: frameWWN: wwn  frameId: 
-: 
-  ֵ: 
-    : ϱڸ̵¶
+函 数 名: hdmRtNtfTempForInch25
+功    能: 发送2.5寸盘温度信息
+输入参数: frameWWN: 框wwn  ，frameId: 框号
+输出参数: 无
+返 回 值: 无
+其    它: 上报框内各盘的温度
 **************************************************************************/
 static void hdmRtNtfTempForInch25Dsk(uint64_t *frameWwn, uint32_t frameId)
 {
@@ -1411,15 +1411,15 @@
 void stub_hdmRtNtfTempForInch35Dsk(uint64_t *frameWwn, uint32_t frameId, uint32_t maxDisk);
 
 /**************************************************************************
-  : hdmRtNtfTempForInch35
-    : 3.5¶Ϣ
-6һη
-˳ 048/159/2610/....
-: frameWWN: wwn          
-frameId: 
-: 
-  ֵ: 
-    : ϱڸ̵¶
+函 数 名: hdmRtNtfTempForInch35
+功    能: 发送3.5寸盘温度信息
+按6个盘一批次发送
+发送顺序 0、4、8/1、5、9/2、6、10/....
+输入参数: frameWWN: 框wwn          
+frameId: 框号
+输出参数: 无
+返 回 值: 无
+其    它: 上报框内各盘的温度
 **************************************************************************/
 static void hdmRtNtfTempForInch35Dsk(uint64_t *frameWwn, uint32_t frameId, uint32_t maxDisk)
 {
@@ -1429,11 +1429,11 @@
 }
 
 /**************************************************************************
-*     :տ֪ͨ¶
-* : 
-* : 
-*   ֵ: 
-*     : 
+* 功    能:按照框向驱动通知温度
+* 输入参数: 无
+* 输出参数: 无
+* 返 回 值: 无
+* 其    他: 无
 **************************************************************************/
 static void hdmRtNotifyTemperatureByFrameStart(void *arg)
 {
@@ -1454,7 +1454,7 @@
 
     for(frameId = 0; frameId < SD_MAX_FRAME_NUMBER; frameId++)
     {
-        /*ȡWWN*/
+        /*获取框的WWN号*/
         if (RETURN_ERROR == hdmGetFramWwn(frameId, frameWwn))
         {
             DBG_LogDebug(LOG_ID_HDM_031E,
@@ -1462,7 +1462,7 @@
             continue;
         }
 
-        /*ȡڲλ*/    
+        /*获取框内槽位数*/    
         if(RETURN_OK != OperateEnclosure(GET_DISK_MAX, frameWwn[0], &maxDisk, sizeof(uint32_t)))
         {
             if (RETURN_OK != OperateEnclosure(GET_DISK_MAX, frameWwn[1], &maxDisk, sizeof(uint32_t)))
@@ -1472,12 +1472,12 @@
             }
         }
 
-        /*3.5ÿ24λ̿һÿ12λ*/
+        /*3.5寸盘每框24个槽位，盘控一体每框12槽位*/
         if ((HDM_35DSK_NUM_ONE_FRAME == maxDisk) || (HDM_DISK_NUM_UNIBODY == maxDisk))
         {    
             hdmRtNtfTempForInch35Dsk(frameWwn, frameId, maxDisk);   
         }
-        /*2.5ÿ25λ*/    
+        /*2.5寸盘每框25槽位*/    
         else if (HDM_25DSK_NUM_ONE_FRAME == maxDisk)
         {    
             hdmRtNtfTempForInch25Dsk(frameWwn, frameId);
@@ -1496,12 +1496,12 @@
 }
 
 /**************************************************************************
-  : hdmRtNotifyTemperatureByFrame
-    : ֪ͨDMIǰ¶Ⱥ͵
-: 
-: 
-  ֵ: 
-    : ϱڸ̵¶
+函 数 名: hdmRtNotifyTemperatureByFrame
+功    能: 通知DMI当前盘温度和调整门限
+输入参数: 
+输出参数: 无
+返 回 值: 无
+其    它: 上报框内各盘的温度
 **************************************************************************/
 /* Dorado 5000 modified begin */
 void hdmRtNotifyTemperatureByFrame(void)
@@ -1527,11 +1527,11 @@
 
 /*Begin Modified by j90006936 DTS2015012800381 2015.1.27*/
 /**************************************************************************
-*     :֪ͨDMI
-* : 
-* : 
-*   ֵ: 
-*     : 
+* 功    能:通知DMI调整高温门限
+* 输入参数: 无
+* 输出参数: 无
+* 返 回 值: 无
+* 其    他: 无
 **************************************************************************/
 static void hdmRtNotifyDmiChangeTemperature(void)
 {
@@ -1546,7 +1546,7 @@
     uint32_t firstFrameId = 0;
     uint32_t innerFrameId = 0;
 
-    /* bayIDpairId6U Ŀس*/
+    /* 区分bayID和pairId在6U 四控场景*/
     bayId = GET_CUR_BAY_ID();
     pairId = ((getLocalNid()) / 2);
     firstFrameId = sdGetFirstFrameIdByEngineId(pairId);
@@ -1560,7 +1560,7 @@
             continue;
         }
 
-        /*ȡWWN*/
+        /*获取框的WWN号*/
         enclosureWWN = BDM_EAM_GET_WWN_FROM_INNER_FRAME_ID(innerFrameId);
         if ((INVALID_VALUE64 == enclosureWWN)
             || ((enclosureWWN == fEnclosureWWN) && (firstFrameId != innerFrameId)))
@@ -1571,9 +1571,9 @@
             continue;
         }
 
-        /*ȡSSD̸*/
+        /*获取框的SSD盘个数*/
         //diskCnt = hdmGetSSDNumOneFrame(frameId);
-        /* ֪ͨDMISES*/
+        /* 通知DMI向SES调整高温门限*/
         //hdmRtNotifyDmi(enclosureWWN, diskCnt);        
     }
 
@@ -1582,54 +1582,54 @@
 /*End Modified by j90006936 DTS2015012800381 2015.1.27*/
 
 void hdmRtRecoverCycle(void);
-
+void DpRtRecoverData(void);
 /**************************************************************************
-  : hdmRtTimerOutFunc
-    : ѭʱʱ
-: context: ʱ
-: 
-  ֵ: 
-    : IODʱҪΣﲻҪʹ
+函 数 名: hdmRtTimerOutFunc
+功    能: 循环定时器超时函数
+输入参数: context: 定时器上下文
+输出参数: 无
+返 回 值: 无
+其    它: IOD定时器要求有入参，这里不需要使用入参
 **************************************************************************/
 void hdmRtTimerOutFunc(void *context)
 {
     UNREFERENCE_PARAM(context);
-
-    /* Ѿֹͣ */
+    DpRtRecoverData();
+    /* 例测已经停止 */
     if (0 == BDM_TEST_BIT(HDM_ROUTING_OPEN_BIT, (void *)&g_routingOpen))
     {
         ANY_TRACE_CALL(HDM_ANY_TRACE, 0, "BDM_RT:hdm route has stopped, func %s.", __FUNCTION__);
         return;
     }
 
-    /* Ӳ̵ */
+    /* 正在例测硬盘单个盘 */
     if (0 != BDM_TEST_BIT(HDM_ROUTING_ONE_BIT, (void *)&g_routingOne))
     {
         ANY_TRACE_CALL(HDM_ANY_TRACE, 0, "BDM_RT:hdm is routing one disk, func %s.", __FUNCTION__);
         return;
     }
 
-    /* ڸ */    
+    /* 正在更新例测间隔 */    
     if (0 != BDM_TEST_BIT(HDM_RT_UPDATE_INTV_TIME_BIT, (void *)&g_updatingIntvTime))
     {
         ANY_TRACE_CALL(HDM_ANY_TRACE, 0, "BDM_RT:hdm is updating disk route interval time, func %s.", __FUNCTION__);
         return;
     }
 
-    /*  ڻȡӲб */    
+    /*  正在获取硬盘列表 */    
     if (0 != BDM_TEST_BIT(HDM_GETTING_DISK_LIST_BIT, (void *)&g_gettingDiskList))
     {
         ANY_TRACE_CALL(HDM_ANY_TRACE, 0, "BDM_RT:hdm is getting disk list, func %s.", __FUNCTION__);
         return;
     }
 
-    /*  */
+    /* 本轮例测完成 */
     if (g_index >= g_diskNum)
     {
         /*Modified by l00285244 for DTS2014072213296 begin*/    
         if (0 != BDM_TEST_BIT(HDM_RT_NTF_TEMP_DMI_BIT, (void *)&g_notfTempToDmi))
         {
-            /*֪ͨӲ¶ȵDMI*/
+            /*通知硬盘温度到DMI*/
             BDM_CLEAR_BIT(HDM_RT_NTF_TEMP_DMI_BIT, (void *)&g_notfTempToDmi);                   
             hdmRtNotifyTemperatureByFrame();
 
@@ -1637,7 +1637,7 @@
         /*Modified by l00285244 for DTS2014072213296 end*/        
 
 
-        /* δڼ */
+        /* 未满足例测大周期间隔 */
         if (!hdmRtTwoCycleIntvOver())
         {
             ANY_TRACE_CALL(HDM_ANY_TRACE, 0, "BDM_RT:hdm disk route two cycle intv is not ok, func %s.", __FUNCTION__);
@@ -1652,26 +1652,26 @@
         }    
         /*Modified by l00285244 for DTS2014072213296 end*/        
 
-        /* ллȡӲб */
+        /* 切换到工作队列获取硬盘列表，并更新例测间隔 */
         hdmRtGetDiskList();
 
-        /*֪ͨDMI*/
+        /*通知DMI调整高温门限*/
         hdmRtNotifyDmiChangeTemperature();
 
-        /* һں󣬻ָ */
+        /* 例测完一个周期后，恢复例测周期 */
         hdmRtRecoverCycle();
 
         return;  
     }
 
-    /* ֮ */
+    /* 不满足两个盘之间的例测间隔 */
     if (!hdmRtTwoDiskIntvOver())
     {
         ANY_TRACE_CALL(HDM_ANY_TRACE, 0, "BDM_RT:hdm two disk route intv is not ok, func %s.", __FUNCTION__);
         return;
     }
 
-    /* ʼ */
+    /* 开始例测 */
     hdmRtOneDiskBegin();
     return;
 }
@@ -1713,7 +1713,7 @@
     {
         hdmDiskPriv->routineInfo.almHighStatus = HDM_TEMPERATURE_ALARM;
         hdmRtSendTemperatureAlarm(sdevId, BDM_ALM_DISK_TEMPERATURE_TOO_HIGH, BDM_ALM_TYPE_FAULT);
-        //LOG_MODIFY  Ƶ
+        //LOG_MODIFY  频率限制
         DBG_LogInfo(LOG_ID_HDM_0308, 
             "BDM_RT:Disk SdevId(%u) high temperature alarm flag is set. Send a temperature high alarm.",
             sdDev->sdevId);
@@ -1723,7 +1723,7 @@
     {
         hdmDiskPriv->routineInfo.almHighStatus = HDM_TEMPERATURE_RESUME;
         hdmRtSendTemperatureAlarm(sdevId, BDM_ALM_DISK_TEMPERATURE_TOO_HIGH, BDM_ALM_TYPE_RESUME);
-        //LOG_MODIFY  Ƶ
+        //LOG_MODIFY  频率限制
         DBG_LogInfo(LOG_ID_HDM_030A, 
             "BDM_RT:Disk SdevId(%u) high temperature flag is not set. Cancel the tempperature high alarm.",
             sdDev->sdevId);
@@ -1735,7 +1735,7 @@
         hdmDiskPriv->routineInfo.almLowStatus = HDM_TEMPERATURE_ALARM;
         /*Begin Modified by l90005948 DTS2016051202777 20160512*/ 
         //hdmRtSendTemperatureAlarm(sdevId, BDM_ALM_DISK_TEMPERATURE_TOO_LOW, BDM_ALM_TYPE_FAULT);
-        //LOG_MODIFY  Ƶ
+        //LOG_MODIFY  频率限制
         DBG_LogInfo(LOG_ID_HDM_0309, 
             "BDM_RT:Disk SdevId(%u) temperature(%d) is lower the alarm value(%d). Send a temperature low alarm.",
             sdDev->sdevId, temperature, g_alarmTemperatureLow);
@@ -1747,7 +1747,7 @@
         //---------------------->almLowStatus
         //hdmRtSendTemperatureAlarm(sdevId, BDM_ALM_DISK_TEMPERATURE_TOO_LOW, BDM_ALM_TYPE_RESUME);
         /*End Modified by l90005948 DTS2016051202777 20160512*/ 
-        //LOG_MODIFY  Ƶ
+        //LOG_MODIFY  频率限制
         DBG_LogInfo(LOG_ID_HDM_030B, 
             "BDM_RT:Disk SdevId(%u) temperature(%d) is higger than low resume value(%d). Cancel the tempperature low alarm.",
             sdDev->sdevId, temperature, g_resumeTemperatureLow);
@@ -1765,11 +1765,11 @@
 }
 
 /**
-* @brief    Ƿﵽ5¶쳣澯
+* @brief    检查盘是否达到连续5次例测温度异常后告警
 * @param    sdevId     
 * @param    hdmDiskPriv
 * @param    temperature
-* @return   FALSE:Ҫ澯 TRUE:Ҫ澯
+* @return   FALSE:不需要告警 TRUE:需要告警
 
 * @exception    None
 
@@ -1792,7 +1792,7 @@
 
     if (unlikely(abnormalTempCnt >= HDM_RT_ABNORMAL_TEMPERATURE_CNT_ALARM))
     {        
-        /*¼*/            
+        /*清零重新计数*/            
         DBG_LogInfo(LOG_ID_HDM_0281, "BDM_RT:Disk SdevId(%u) abnormal temperature"
             " cnt(%d) is more than alarm value(%d).",
             sdevId, abnormalTempCnt, HDM_RT_ABNORMAL_TEMPERATURE_CNT_ALARM);
@@ -1801,7 +1801,7 @@
 
     if (unlikely(HDM_RT_ABNORMAL_TEMPERATURE_VALUE == (uint32_t)(*temperature)))
     {
-        /*Ӳϵ⵽¶һֱ쳣ֹ澯¶ʱΪָ澯¶ֵ*/
+        /*硬盘上电后例测到温度一直异常，这里防止误告警，将温度临时改为恢复告警温度阈值*/
         *temperature = g_resumeTemperatureHigh;
     }
 
@@ -1810,12 +1810,12 @@
 
 
 /**************************************************************************
-  : hdmRtCheckTemperatureAlarm
-    : Ӳ¶ȸ澯ָ
-: sdevId: 豸ID
-: 
-  ֵ: 
-    : οTϵDEV_DiskTemperatureAlarm
+函 数 名: hdmRtCheckTemperatureAlarm
+功    能: 硬盘温度告警与恢复
+输入参数: sdevId: 设备ID
+输出参数: 无
+返 回 值: 无
+其    它: 参考T系列DEV_DiskTemperatureAlarm
 **************************************************************************/
 static void hdmRtCheckTemperatureAlarm(uint32_t sdevId)
 {
@@ -1858,7 +1858,7 @@
         return;
     }
      /*Begin modify by h00405124 DTS2017122804183  20171228*/
-    /* 澯ֵ */
+    /* 超过告警阈值 */
     SMART_TP_CALL(HDM_TP_SET_COM_RET, HDM_TP_COM_RET_SEND_HIGH_TEMPERATURE, &dbgResult, sdevId);
     if ((RETURN_OK == dbgResult) || ((temperature >= g_alarmTemperatureHigh) 
         && ( HDM_TEMPERATURE_ALARM != hdmDiskPriv->routineInfo.almHighStatus)))
@@ -1866,7 +1866,7 @@
         /*End modify by h00405124 DTS2017122804183  20171228*/
         hdmDiskPriv->routineInfo.almHighStatus = HDM_TEMPERATURE_ALARM;
         hdmRtSendTemperatureAlarm(sdevId, BDM_ALM_DISK_TEMPERATURE_TOO_HIGH, BDM_ALM_TYPE_FAULT);
-        //LOG_MODIFY  Ƶ
+        //LOG_MODIFY  频率限制
         DBG_LogInfo(LOG_ID_HDM_0281, 
             "BDM_RT:Disk SdevId(%u) temperature(%d) is over the alarm value(%d). Send a high temperature alarm.",
             sdDev->sdevId, temperature, g_alarmTemperatureHigh);
@@ -1876,7 +1876,7 @@
     {
         hdmDiskPriv->routineInfo.almHighStatus = HDM_TEMPERATURE_RESUME;
         hdmRtSendTemperatureAlarm(sdevId, BDM_ALM_DISK_TEMPERATURE_TOO_HIGH, BDM_ALM_TYPE_RESUME);
-        //LOG_MODIFY  Ƶ
+        //LOG_MODIFY  频率限制
         DBG_LogInfo(LOG_ID_HDM_0283, 
             "BDM_RT:Disk SdevId(%u) temperature(%d) is lower than high resume value(%d), higger than low resume value(%d). Cancel the tempperature high alarm.",
             sdDev->sdevId, temperature, g_resumeTemperatureHigh, g_resumeTemperatureLow);
@@ -1888,7 +1888,7 @@
         hdmDiskPriv->routineInfo.almLowStatus = HDM_TEMPERATURE_ALARM;
         /*Begin Modified by l90005948 DTS2016051202777 20160512*/ 
         //hdmRtSendTemperatureAlarm(sdevId, BDM_ALM_DISK_TEMPERATURE_TOO_LOW, BDM_ALM_TYPE_FAULT);
-        //LOG_MODIFY  Ƶ
+        //LOG_MODIFY  频率限制
         DBG_LogInfo(LOG_ID_HDM_0282, 
             "BDM_RT:Disk SdevId(%u) temperature(%d) is lower the alarm value(%d). Send a low temperature alarm.",
             sdDev->sdevId, temperature, g_alarmTemperatureLow);
@@ -1899,7 +1899,7 @@
         hdmDiskPriv->routineInfo.almLowStatus = HDM_TEMPERATURE_RESUME;
         //hdmRtSendTemperatureAlarm(sdevId, BDM_ALM_DISK_TEMPERATURE_TOO_LOW, BDM_ALM_TYPE_RESUME);
         /*End Modified by l90005948 DTS2016051202777 20160512*/ 
-        //LOG_MODIFY  Ƶ
+        //LOG_MODIFY  频率限制
         DBG_LogInfo(LOG_ID_HDM_0284, 
             "BDM_RT:Disk SdevId(%u) temperature(%d) is lower than high resume value(%d), higger than low resume value(%d). Cancel the tempperature low alarm.",
             sdDev->sdevId, temperature, g_resumeTemperatureHigh, g_resumeTemperatureLow);
@@ -1915,9 +1915,9 @@
 }
 
 /**
-* @brief    ˽нṹе¶ֵ쳣¶ȼ
-* @param    diskRouteInfo   ˽нṹ
-* @param    curTemperature  ⵽¶ֵ
+* @brief    更新例测私有结构体中的温度值和异常温度计数
+* @param    diskRouteInfo   例测私有结构体
+* @param    curTemperature  例测到的温度值
 * @return   none    
 
 * @exception    None
@@ -1933,7 +1933,7 @@
 
     if (likely(HDM_RT_TEMPERATURE_IS_IN_RANGE(curTemperature)))
     {
-        /*¶ֵ*/
+        /*温度值正常计数清零*/
         diskRoutineInfo->abnormalTempCnt = (TRUE == updateAbnormalCnt) ? 
             0 : diskRoutineInfo->abnormalTempCnt;
         diskRoutineInfo->temperature = curTemperature;
@@ -1951,12 +1951,12 @@
     }
     else
     {
-        /*תˣֱӴӸ澯ֵʼѸ¸澯ָ
-        *ֻг¶쳣һֱ¶쳣һᵼ¼ת*/
+        /*计数翻转了，直接从告警阈值开始计数；避免后面把高温告警恢复
+        *只有出现温度异常后，盘一直温度异常这一种情况会导致计数翻转*/
         diskRoutineInfo->abnormalTempCnt = HDM_RT_ABNORMAL_TEMPERATURE_CNT_ALARM;
     }
 
-    /*澯ˣ¶ֱΪȫF*/
+    /*计数超过告警次数了，温度直接设置为全F*/
     if (likely(diskRoutineInfo->abnormalTempCnt >= HDM_RT_ABNORMAL_TEMPERATURE_CNT_ALARM))
     {
         diskRoutineInfo->temperature = (int32_t)HDM_RT_ABNORMAL_TEMPERATURE_VALUE;
@@ -1967,12 +1967,12 @@
 }
 
 /**************************************************************************
-  : hdmRtDealTemperature
-    : Ӳ¶쳣
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtDealTemperature
+功    能: 处理硬盘温度异常
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 /* Begin Modified by d00282183 DTS2014101802919 20141018 */
 void hdmRtDealTemperature(void)
@@ -1982,10 +1982,10 @@
     HDM_DISK_PRIVATE_S *hdmDiskPriv = NULL;
     bool isSSDDisk = FALSE;
 
-    /* עӲ¶ȸ澯 */
+    /* 调试注入硬盘温度告警 */
     HDM_RT_TEMPERATURE_HIGH_ALARM_TRACE_POINT_TEST(&g_curDiskTemperature);
     HDM_RT_TEMPERATURE_LOW_ALARM_TRACE_POINT_TEST(&g_curDiskTemperature);
-    /*ע¶쳣*/
+    /*注入温度异常*/
     SMART_TP_CALL(HDM_HDD_DISK_TEMP_RT_SET_TEMP, 
         g_waitRtDisk[g_index], 
         &g_curDiskTemperature);
@@ -2001,7 +2001,7 @@
     sdDisk = SD_GENERIC_TO_DISK(sdDev);
     hdmDiskPriv = HDM_DISK_TO_PRIV(sdDisk);
     isSSDDisk = hdmHuaSySSD(g_waitRtDisk[g_index]) || hdmDiskIsExternalDiskSSD(g_waitRtDisk[g_index]);
-    /* Ӳ¶ȵ˽пռ */
+    /* 更新硬盘温度到私有空间 */
     if (isSSDDisk)
     {
         hdmDiskPriv->routineInfo.temperature = g_curDiskTemperature;
@@ -2015,7 +2015,7 @@
 
     /* BDM R1 T11A-915 modified by l90006309 2012-10-16 begin */
     /* Begin Modified by j90006936 CR-01519185 2015.01.13 */
-    /* ¶ȣ澯ָ */
+    /* 检查温度，告警或恢复 */
     /*Begin Modified by l00245290 DTS2015091506573 2015.08.13*/
     if (isSSDDisk)
         /*End Modified by l00245290 DTS2015091506573 2015.08.13*/
@@ -2036,14 +2036,14 @@
 }
 /* End   Modified by d00282183 DTS2014101802919 20141018 */
 /**************************************************************************
-  : hdmRtCheckTemperatureDone
-    : Ӳ¶Ȼص
-: context: 
-result: 
-temperature: Ӳ¶
-: 
-  ֵ: 
-    : contextڴ˴û
+函 数 名: hdmRtCheckTemperatureDone
+功    能: 检查硬盘温度回调函数
+输入参数: context: 上下文
+result: 检查结果
+temperature: 硬盘温度
+输出参数: 无
+返 回 值: 无
+其    他: context在此处没有用
 **************************************************************************/
 void hdmRtCheckTemperatureDone(void *context, int32_t result, int32_t temperature)
 {
@@ -2076,12 +2076,12 @@
 void stub_hdmRtCheckTemperature(void);
 
 /**************************************************************************
-  : hdmRtCheckTemperature
-    : Ӳ¶
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtCheckTemperature
+功    能: 检查硬盘温度
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 void hdmRtCheckTemperature(void)
 {
@@ -2099,12 +2099,12 @@
 void stub_hdmRtDealPreFail(void);
 
 /**************************************************************************
-  : hdmRtDealPreFail
-    : ϱӲԤʧЧ¼SDģ鴦
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtDealPreFail
+功    能: 上报硬盘预失效事件给SD模块处理
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 void hdmRtDealPreFail(void)
 {
@@ -2117,12 +2117,12 @@
 
 /*Begin Added by y00352978 DTS2016092705873 20160927*/
 /**************************************************************************
-  : hdmRtHSSDDealPreFail
-    : ϱHSSDӲԤʧЧ¼SDģ鴦
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtHSSDDealPreFail
+功    能: 上报HSSD硬盘预失效事件给SD模块处理
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 void hdmRtHSSDDealPreFail(uint32_t sdevId)
 {
@@ -2134,12 +2134,12 @@
 void stub_hdmRtHSSDLifeToBeUsedUp(uint32_t sdevId);
 
 /**************************************************************************
-  : hdmRtHSSDLifeToBeUsedUp
-    : HSSDӲԤʹʱ伴ľ¼
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtHSSDLifeToBeUsedUp
+功    能: 发送HSSD硬盘预计使用时间即将耗尽事件
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 void hdmRtHSSDLifeToBeUsedUp(uint32_t sdevId)
 {
@@ -2152,14 +2152,14 @@
 void stub_hdmRtCheckPreFailDone(void *context, int32_t result, uint32_t halfLife);
 
 /**************************************************************************
-  : hdmRtCheckPreFailDone
-    : ȡATAӲ¶Ȼص
-: context: 
-result: 
-halfLife: ӲǷԤʧЧ
-: 
-  ֵ: 
-    : contextڴ˴û
+函 数 名: hdmRtCheckPreFailDone
+功    能: 获取ATA硬盘温度回调函数
+输入参数: context: 上下文
+result: 检查结果
+halfLife: 硬盘是否预失效
+输出参数: 无
+返 回 值: 无
+其    他: context在此处没有用
 **************************************************************************/
 static void hdmRtCheckPreFailDone(void *context, int32_t result, uint32_t halfLife)
 {
@@ -2170,12 +2170,12 @@
 
 
 /**************************************************************************
-  : hdmRtCheckPreFail
-    : ӲԤʧЧ
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtCheckPreFail
+功    能: 检查硬盘预失效情况
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 void hdmRtCheckPreFail(void)
 {
@@ -2196,7 +2196,7 @@
 
     DBG_LogDebug(LOG_ID_HDM_0311, "BDM_RT:Start routine disk(SdevId(%u)) pre fail info.", g_waitRtDisk[g_index]);
 
-    /* ӲԤʧЧϢ */
+    /* 检查硬盘预失效信息 */
     ret = hdmRtGetPreFailInfo(g_waitRtDisk[g_index], NULL, hdmRtCheckPreFailDone); 
     if (RETURN_OK != ret)
     {
@@ -2249,7 +2249,7 @@
     sdDisk = SD_GENERIC_TO_DISK(sdDev);
     hdmDiskPriv = HDM_DISK_TO_PRIV(sdDisk);
 
-    /* Ӳϵʱ䵽˽пռ */
+    /* 更新硬盘上电时间到私有空间 */
     hdmDiskPriv->routineInfo.powerOnTime = g_curDiskPowerOnTime;
     HDM_PUT_SD_DEV(sdDev);
 
@@ -2278,13 +2278,13 @@
 
 /*Begin Modified by y00352978 DTS2016092705873 20160927*/
 /**************************************************************************
-  : hdmRtDealDiskLife
-    : Ϣд
-: usedLife1: ĥ
-usedLife2: ĥС
-powerOnTime: Ӳϵʱ
-: 
-  ֵ: 
+函 数 名: hdmRtDealDiskLife
+功    能: 对寿命信息进行处理
+输入参数: usedLife1: 磨损度整数部分
+usedLife2: 磨损度小数部分
+powerOnTime: 硬盘上电时间
+输出参数: 无
+返 回 值: 无
 **************************************************************************/
 void hdmRtDealDiskLife(uint32_t sdevId, uint8_t usedLife1, uint8_t usedLife2, 
                        uint32_t powerOnTime, void *context, HDM_GENERAL_DONE done)
@@ -2317,15 +2317,15 @@
 
 /*Begin Modified by l00245290 DTS2015091506573 2015.08.13*/
 /**************************************************************************
-  : hdmRtParseExternalSSDLife
-    : ⹺ SSDЭ
-: 
-buffer:Ӵ̶buffer
-bufferLen:ݳ
-: 
-usedLife:ĥ
-  ֵ: 
-    : 
+函 数 名: hdmRtParseExternalSSDLife
+功    能: 外购 SSD寿命协议解析
+输入参数: 
+buffer:从磁盘读回来的数据buffer
+bufferLen:数据长度
+输出参数: 
+usedLife:磨损度
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 int32_t hdmRtParseExternalSSDLife(uint8_t *buffer, uint32_t bufferLen, uint8_t *usedLife)
 {
@@ -2342,7 +2342,7 @@
         return RETURN_ERROR;
     }
 
-    /*Э涨23ֽΪpage*/
+    /*协议规定第2、3字节为page长度*/
     lifePageLen = (tmpBuf[2] << 8) | tmpBuf[3];
     mediaParaCnt = lifePageLen / HDM_EXTERNAL_MEDIA_PARAM_LEN;
 
@@ -2369,7 +2369,7 @@
         return RETURN_ERROR;
     }
 
-    /*ûֲ涨߸ֽΪĥ*/
+    /*用户手册规定第七个字节为磨损度*/
     *usedLife = tmpBuf[7];
 
     return RETURN_OK;
@@ -2394,7 +2394,7 @@
         return;
     }
 
-    /*Э涨ֽڣħ*/
+    /*协议规定字节，非魔术字*/
     /* Begin Modified by j90006936 CR-01519185 2015.01.13 */    
     if (hdmHuaSySSD(sdevId))
     {
@@ -2476,7 +2476,7 @@
     }    
     /* End   Modified by j90006936 CR-01519185 2015.01.13 */
 
-    /* ֻSASϢ*/
+    /* 只有SAS盘有寿命信息*/
     ret = hdmLogPage(sdevId,
         pageCode,
         context,
@@ -2490,15 +2490,15 @@
 }
 
 /*****************************************************************************
-  : hdmRtGetScsiDiskPowerOnTimeDone
-    : ȡSCSIӲϵʱ
-: sdevId: 豸id
-context: ߵ
-done: ߵĻص
-: 
-  ֵ: RETURN_OK: ɹ
-RETURN_ERROR: ʧ
-    : 
+函 数 名: hdmRtGetScsiDiskPowerOnTimeDone
+功    能: 获取SCSI硬盘上电时间
+输入参数: sdevId: 设备id
+context: 调用者的上下文
+done: 调用者的回调函数
+输出参数: 
+返 回 值: RETURN_OK: 成功
+RETURN_ERROR: 失败
+其    他: 无
 *****************************************************************************/
 void hdmRtGetScsiDiskPowerOnTimeDone(REQ_S *req)
 {
@@ -2527,14 +2527,14 @@
 
     buf = (uint8_t *)req->sgl->entrys[0].buf;    
 
-    /* background scan pageοsbc3r14 table-104 */
-    /* ȡ */
+    /* 解析background scan page，参考sbc3r14 table-104 */
+    /* 获取分钟数 */
     powerOnTime += ((uint32_t)buf[HDM_LOG_SENSE_PG_HDR_LEN + 4] << 24);
     powerOnTime += ((uint32_t)buf[HDM_LOG_SENSE_PG_HDR_LEN + 5] << 16);
     powerOnTime += ((uint32_t)buf[HDM_LOG_SENSE_PG_HDR_LEN + 6] << 8);
     powerOnTime += ((uint32_t)buf[HDM_LOG_SENSE_PG_HDR_LEN + 7]);
 
-    /* תΪСʱ */
+    /* 分钟数转换为小时 */
     powerOnTime /= 60;
     DBG_LogDebug(LOG_ID_HDM_026F,"BDM_RT:Disk SdevId(%u) power on time %u (hour).", sdDev->sdevId, powerOnTime);
     saveDone(saveContext, RETURN_OK, powerOnTime);
@@ -2543,15 +2543,15 @@
 }
 
 /*****************************************************************************
-  : hdmRtGetAtaDiskPowerOnTimeDone
-    : ȡATAӲϵʱ
-: sdevId: 豸id
-context: ߵ
-done: ߵĻص
-: 
-  ֵ: RETURN_OK: ɹ
-RETURN_ERROR: ʧ
-    : 
+函 数 名: hdmRtGetAtaDiskPowerOnTimeDone
+功    能: 获取ATA硬盘上电时间
+输入参数: sdevId: 设备id
+context: 调用者的上下文
+done: 调用者的回调函数
+输出参数: 
+返 回 值: RETURN_OK: 成功
+RETURN_ERROR: 失败
+其    他: 无
 *****************************************************************************/
 void hdmRtGetAtaDiskPowerOnTimeDone(REQ_S *req)
 {
@@ -2582,7 +2582,7 @@
 
     smartInfo = (HDM_ATA_SMART_DATA_S *)(void *)req->sgl->entrys[0].buf;;
 
-    /* ȡSATA̵ϵʱ */
+    /* 获取SATA盘的上电时间 */
     for (i = 0; i < HDM_SMART_ATTR_NUMBER; i++)
     {
         diskAttr = smartInfo->attrEntries + i;
@@ -2592,7 +2592,7 @@
             continue;
         }
 
-        /* ̵ǰϵʱ4ֽڱ*/
+        /* 磁盘当前上电时间用4个保留字节保存*/
         for (j = 0; j < 4; j++)
         {
             tempTime = diskAttr->raw[j];
@@ -2612,15 +2612,15 @@
 int32_t stub_hdmRtGetPowerOnTime(uint32_t sdevId, void *context, HDM_GET_POWERON_TIME_DONE done);
 
 /*****************************************************************************
-  : hdmRtGetPowerOnTime
-    : ȡӲϵʱ
-: sdevId: 豸id
-context: ߵ
-done: ߵĻص
-: 
-  ֵ: RETURN_OK: ɹ
-RETURN_ERROR: ʧ
-    : 
+函 数 名: hdmRtGetPowerOnTime
+功    能: 获取硬盘上电时间
+输入参数: sdevId: 设备id
+context: 调用者的上下文
+done: 调用者的回调函数
+输出参数: 
+返 回 值: RETURN_OK: 成功
+RETURN_ERROR: 失败
+其    他: 无
 *****************************************************************************/
 int32_t hdmRtGetPowerOnTime(uint32_t sdevId, void *context, HDM_GET_POWERON_TIME_DONE done)
 {
@@ -2662,7 +2662,7 @@
     sdevId = g_waitProcSSDDisk[procType][g_procSSDIndex[procType]];
 
     /* Begin Modified by j90006936 CR-01519185 2015.01.13 */
-    /* ΪSSD⹺SSD*/
+    /* 华为SSD和外购SSD，做寿命管理*/
     /*Begin Modified by l00245290 DTS2015091506573 2015.08.13*/
     if (!hdmHuaSySSD(sdevId) && !hdmDiskIsExternalDiskSSD(sdevId))
         /*End Modified by l00245290 DTS2015091506573 2015.08.13*/
@@ -2721,7 +2721,7 @@
     uint8_t *timeBuf = NULL;
 
     curTime = (uint32_t)LVOS_GetTime(NULL);
-    /*תɺ*/
+    /*转换成毫秒*/
     curTime = HDM_SEC_TO_MILLSEC * curTime;
 
     if (req->sgl->entrys[0].len < HDM_SSD_TIME_DATE_LEN)
@@ -2889,7 +2889,7 @@
         return;        
     }
 
-    /* ֻrunning״̬Ӳ */ 
+    /* 只例测running状态的硬盘 */ 
     if (SCSI_DEVICE_STATE_RUNNING != sdDev->state)
     {
         /* Dorado 5000 modified begin */
@@ -2944,7 +2944,7 @@
             continue;
         }   
 
-        /* ֻӲ */
+        /* 只例测正常接入的硬盘 */
         if ((SCSI_DEVICE_TYPE_DISK != sdDev->type) 
             || (0 != sdDev->problem))
         {
@@ -2966,7 +2966,7 @@
         }
         /* End   Modified by j90006936 CR-01519185 2015.01.13 */
 
-        /* nvmeϵͳ */
+        /* 增加nvme系统盘例测 */
         if ((!sdIsNvmeDev(sdDev)) && (sdDisk->isRootDisk))
         {
             SD_PUT_DEVICE(sdDev);
@@ -2974,18 +2974,18 @@
         }
         /* NVME Root Disk modified end */
 
-        /* ¼ӲIDб */
+        /* 记录硬盘ID到待例测列表中 */
         ssdDiskListBuf[tempDiskNum++] = sdevId;  
         SD_PUT_DEVICE(sdDev);
     }
 
     *ssdDiskNum = tempDiskNum;
 
-    /* ҲӲ̣һٲ */
+    /* 查找不到硬盘，下一个大周期再查找 */
     if (0 == tempDiskNum)
     {
         DBG_LogDebug(LOG_ID_HDM_028A, 
-            "BDM_RT:No disk need to proccheck disk list in next big cycle.");
+            "BDM_RT:No disk need to proc，check disk list in next big cycle.");
         *nextCycleStartTime = jiffies;                     
     }  
 
@@ -3052,7 +3052,7 @@
 
     procType = *((HDM_RT_SSD_PROC_TYPE_E *)context);
 
-    /* ϵͳ̽Ѿֹͣ */
+    /* 系统报盘结束已经停止 */
     if (0 == BDM_TEST_BIT(HDM_REPORT_DISK_FINISH_BIT, (void*)&g_reportDiskFinish))
     {
         ANY_TRACE_CALL(HDM_ANY_TRACE, 3, 
@@ -3062,7 +3062,7 @@
     }
 
     /* Begin Modified by d00282183 DTS2014101802919 20141018 */
-    /* ڴ */
+    /* 正在处理单个盘 */
     if (0 != BDM_TEST_BIT(HDM_IS_PROC_SINGLE_SSD_DISK, (void*)&g_isProcOneSSD[procType]))
     {
         ANY_TRACE_CALL(HDM_ANY_TRACE, 3, 
@@ -3072,7 +3072,7 @@
     }
     /* End   Modified by d00282183 DTS2014101802919 20141018 */
 
-    /*  ڻȡSSDӲб */    
+    /*  正在获取SSD硬盘列表 */    
     if (0 != BDM_TEST_BIT(HDM_GETTING_DISK_LIST_BIT, (void *)&g_isGettingSSDList[procType]))
     {
         ANY_TRACE_CALL(HDM_ANY_TRACE, 3, 
@@ -3081,32 +3081,32 @@
         return;
     }
 
-    /*  */
+    /* 本轮例测完成 */
     if (g_procSSDIndex[procType] >= g_needProcSSDNum[procType])
     {
-        /* δڼ */
+        /* 未满足例测大周期间隔 */
         if (!hdmRtIsTwoCycleIntvTimeOver(procType))
         {
             ANY_TRACE_CALL(HDM_ANY_TRACE, 3, "BDM_RT:Sync big cycle not ok, func %s.", __FUNCTION__);
             return;
         }   
 
-        /* ллȡӲб */
+        /* 切换到工作队列获取硬盘列表，并更新例测间隔 */
         hdmRtHSSDGetDiskList(procType);
         return;  
     }
 
-    /* ʼ */
+    /* 开始例测 */
     hdmRtProcOneHSSDDisk(procType);
 }
 
 /**************************************************************************
-  : hdmRtGetTemperatureConf
-    : ʼ:¶ȸ澯ֵ¶Ȼֵָ
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtGetTemperatureConf
+功    能: 初始化配置项:温度告警阈值、温度恢复阈值
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 static void hdmRtGetTemperatureConf(void)
 {
@@ -3115,7 +3115,7 @@
 
     memset(&stItem, 0, sizeof(CST_ITEM_T));
 
-    /* ȡļе¶ȸ澯ֵ */
+    /* 读取配置文件中的温度告警阈值 */
     readConfSucceed = CST_GetItem("BDM_ROUTINE", "AlarmTemperature", &stItem);
     if (!readConfSucceed)
     {
@@ -3133,7 +3133,7 @@
             g_alarmTemperatureHigh);        
     }
 
-    /* ȡļе¶Ȼֵָ */
+    /* 读取配置文件中的温度恢复阈值 */
     readConfSucceed = CST_GetItem("BDM_ROUTINE", "ResumTemperature", &stItem);
     if (!readConfSucceed)
     {
@@ -3162,12 +3162,12 @@
 
 
 /**************************************************************************
-  : hdmRtGetSelfIntvConf
-    : ʼ:Ӳ(s)
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtGetSelfIntvConf
+功    能: 初始化配置项:硬盘自身例测间隔(s)
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 static void hdmRtGetSelfIntvConf(void)
 {
@@ -3176,11 +3176,11 @@
 
     memset(&stItem, 0, sizeof(CST_ITEM_T));
 
-    /* ȡ */
+    /* 读取自身例测间隔 */
     readConfSucceed = CST_GetItem("BDM_ROUTINE", "DiskSelf", &stItem);
     if (!readConfSucceed)
     {
-        /* TϵжȡʧܣΪ0οT V1R5 DEV_ParseRoutineData() */
+        /* T系列读取配置失败，设置为0。参考T V1R5 DEV_ParseRoutineData() */
         g_selfIntvSec = HDM_DEFAULT_SELF_INTV_SEC;
         DBG_LogError(LOG_ID_HDM_029D, 
             "BDM_RT:Get disk self intv time form product conf fail. Set default value(%u).", 
@@ -3197,12 +3197,12 @@
 }
 
 /**************************************************************************
-  : hdmRtSetDefaultCycle
-    : ʼ:(s)
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtSetDefaultCycle
+功    能: 初始化配置项:例测周期(s)
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 static void hdmRtSetDefaultCycle(void)
 {
@@ -3225,36 +3225,36 @@
 
 
 /**************************************************************************
-  : hdmRtInitConf
-    : ʼ:ڡ¶ȸ澯ֵ¶Ȼֵָ
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtInitConf
+功    能: 初始化配置项:例测周期、温度告警阈值、温度恢复阈值
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 void hdmRtInitConf(void)
 {
-    /* Ӳ */
+    /* 硬盘例测周期 */
     hdmRtSetDefaultCycle();
 
-    /* ¶ȸ澯ֵͻֵָ */
+    /* 温度告警阈值和恢复阈值 */
     hdmRtGetTemperatureConf();
 
-    /* Ӳ */
+    /* 硬盘自身例测间隔 */
     hdmRtGetSelfIntvConf();
 }
 
 /**************************************************************************
-  : hdmRtStop
-    : ֹͣ
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtStop
+功    能: 停止例测
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 void hdmRtStop(void)
 {
-    /* Ѿֹͣ */
+    /* 例测已经停止 */
     if (0 == BDM_TEST_AND_CLEAR_BIT(HDM_ROUTING_OPEN_BIT, (void *)&g_routingOpen))
     {
         DBG_LogInfo(LOG_ID_HDM_02A0, "BDM_RT:Routine task is already stop.");
@@ -3267,16 +3267,16 @@
 
 
 /**************************************************************************
-  : hdmRtStart
-    : ʼ
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtStart
+功    能: 开始例测
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 void hdmRtStart(void)
 {    
-    /* Ѿڽ */
+    /* 例测已经在进行 */
     if (0 != BDM_TEST_AND_SET_BIT(HDM_ROUTING_OPEN_BIT, (void *)&g_routingOpen))
     {
         //LOG_MODIFY
@@ -3295,12 +3295,12 @@
 }
 
 /**************************************************************************
-  : hdmRtSetSSDSwitch
-    : SSDӲ⿪
-: ssdSwitchFlag ѡ
-: 
-  ֵ: RETURN_OK : ɹ RETURN_ERROR : ʧ
-    : 
+函 数 名: hdmRtSetSSDSwitch
+功    能: 设置SSD硬盘例测开关
+输入参数: ssdSwitchFlag 开关选项
+输出参数: 无
+返 回 值: RETURN_OK : 成功， RETURN_ERROR : 失败
+其    它: 无
 **************************************************************************/
 int32_t hdmRtSetSSDSwitch(HDM_ROUTINE_SSD_SWITCH_E ssdSwitchFlag)
 {
@@ -3318,12 +3318,12 @@
 }
 
 /**************************************************************************
-  : hdmRtGetSSDSwitch
-    : ѯSSDӲ⿪
-: 
-: 
-  ֵ: HDM_ROUTINE_SSD_OPEN : 򿪣 HDM_ROUTINE_SSD_CLOSE : ر
-    : 
+函 数 名: hdmRtGetSSDSwitch
+功    能: 查询SSD硬盘例测开关
+输入参数: 无
+输出参数: 无
+返 回 值: HDM_ROUTINE_SSD_OPEN : 打开， HDM_ROUTINE_SSD_CLOSE : 关闭
+其    它: 无
 **************************************************************************/
 HDM_ROUTINE_SSD_SWITCH_E hdmRtGetSSDSwitch(void)
 {
@@ -3331,12 +3331,12 @@
 }
 
 /**************************************************************************
-  : hdmRtSetSwitch
-    : Ӳ⿪
-: 
-: 
-  ֵ: RETURN_OK : ɹ RETURN_ERROR : ʧ
-    : 
+函 数 名: hdmRtSetSwitch
+功    能: 设置硬盘例测开关
+输入参数: 无
+输出参数: 无
+返 回 值: RETURN_OK : 成功， RETURN_ERROR : 失败
+其    它: 无
 **************************************************************************/
 int32_t hdmRtSetSwitch(HDM_ROUTINE_SWITCH_E switchFlag)
 {
@@ -3358,12 +3358,12 @@
 }
 
 /**************************************************************************
-  : hdmRtGetSwitch
-    : ȡӲ⿪
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtGetSwitch
+功    能: 获取硬盘例测开关
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 HDM_ROUTINE_SWITCH_E hdmRtGetSwitch(void)
 {
@@ -3371,13 +3371,13 @@
 }
 
 /**************************************************************************
-  : hdmRtSetCycle
-    : Ӳ
-: cycleSec : ()
-force : ǿ
-: 
-  ֵ: RETURN_OK : ɹ RETURN_ERROR : ʧ
-    : 
+函 数 名: hdmRtSetCycle
+功    能: 设置硬盘例测周期
+输入参数: cycleSec : 例测周期(秒)
+force : 强制设置例测
+输出参数: 无
+返 回 值: RETURN_OK : 成功， RETURN_ERROR : 失败
+其    它: 无
 **************************************************************************/
 int32_t hdmRtSetCycle(uint32_t cycleSec, bool force)
 {
@@ -3393,7 +3393,7 @@
         return RETURN_OK;
     }
 
-    /* ӲڱڰСʱ */
+    /* 硬盘例测周期必须大于半小时 */
     if (HDM_HOUR_TO_SECOND / 2 <= cycleSec)
     {
         atomic_set(&g_cycleSec, (int32_t)cycleSec);
@@ -3412,12 +3412,12 @@
 }
 
 /**************************************************************************
-  : hdmRtGetCycle
-    : ȡӲ
-: 
-: ()
-  ֵ: 
-    : 
+函 数 名: hdmRtGetCycle
+功    能: 获取硬盘例测周期
+输入参数: 无
+输出参数: 例测周期(秒)
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 uint32_t hdmRtGetCycle(void)
 {
@@ -3463,12 +3463,12 @@
 /*End Modified by j90006936 DTS2014061905977  20140623*/
 
 /**************************************************************************
-  : hdmRtGetSelfIntv
-    : ȡӲ
-: 
-: ()
-  ֵ: 
-    : 
+函 数 名: hdmRtGetSelfIntv
+功    能: 获取硬盘自身例测间隔
+输入参数: 无
+输出参数: 自身例测间隔(秒)
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 uint32_t hdmRtGetSelfIntv(void)
 {
@@ -3477,12 +3477,12 @@
 
 
 /**************************************************************************
-  : hdmRtGetDiskNum
-    : ȡӲ
-: 
-: Ӳ
-  ֵ: 
-    : 
+函 数 名: hdmRtGetDiskNum
+功    能: 获取硬盘例测数量
+输入参数: 无
+输出参数: 硬盘数量
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 uint32_t hdmRtGetDiskNum(void)
 {
@@ -3490,12 +3490,12 @@
 }
 
 /**************************************************************************
-  : hdmRtGetFinishDiskNum
-    : ȡӲ
-: 
-: Ӳ
-  ֵ: 
-    : 
+函 数 名: hdmRtGetFinishDiskNum
+功    能: 获取已完成硬盘例测数量
+输入参数: 无
+输出参数: 硬盘数量
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 uint32_t hdmRtGetFinishDiskNum(void)
 {
@@ -3503,12 +3503,12 @@
 }
 
 /**************************************************************************
-  : hdmRtGetAlarmTemperature
-    : ȡӲ¶ȸ澯ֵ
-: 
-: ¶ȸ澯ֵ
-  ֵ: 
-    : 
+函 数 名: hdmRtGetAlarmTemperature
+功    能: 获取硬盘温度告警阈值
+输入参数: 无
+输出参数: 温度告警阈值
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 void hdmRtGetAlarmTemperature(int32_t *alarmTemHigh, int32_t *alarmTemLow)
 {
@@ -3519,12 +3519,12 @@
 }
 
 /**************************************************************************
-  : hdmRtGetResumeTemperature
-    : ȡӲ¶Ȼֵָ
-: 
-: ¶ȸ澯ֵָ
-  ֵ: 
-    : 
+函 数 名: hdmRtGetResumeTemperature
+功    能: 获取硬盘温度恢复阈值
+输入参数: 无
+输出参数: 温度告警恢复阈值
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 void hdmRtGetResumeTemperature(int32_t *resumeTemHigh, int32_t *resumeTemLow)
 {
@@ -3535,12 +3535,12 @@
 }
 
 /**************************************************************************
-  : hdmRtGetTwoDiskIntvTime
-    : ȡ̵
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtGetTwoDiskIntvTime
+功    能: 获取两块盘的例测间隔
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 uint64_t hdmRtGetTwoDiskIntvTime(void)
 {
@@ -3548,12 +3548,12 @@
 }
 
 /**************************************************************************
-  : hdmRtGetTwoDiskIntvTime
-    : ȡ̵Ŀʼʱ
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRtGetTwoDiskIntvTime
+功    能: 获取两块盘的例测间隔的开始时间
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 uint64_t hdmRtGetTwoDiskIntvTimeStart(void)
 {
@@ -3562,12 +3562,12 @@
 
 
 /**************************************************************************
-  : hdmRtGetDiskId
-    : ȡָӲId
-: 
-: ӲId
-  ֵ: 
-    : 
+函 数 名: hdmRtGetDiskId
+功    能: 获取指定索引的硬盘Id
+输入参数: 无
+输出参数: 硬盘Id
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 uint32_t hdmRtGetDiskId(uint32_t index)
 {
@@ -3576,12 +3576,12 @@
 
 
 /**************************************************************************
-  : hdmAllDiskInFinsh
-    : ϵͳSD֪ͨHDMӲѾϵͳ 
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmAllDiskInFinsh
+功    能: 系统开工后SD通知HDM所有硬盘已经接入系统 
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 void hdmRtDiskInFinshNotify(void)
 {
@@ -3598,12 +3598,12 @@
 int32_t stub_hdmRtCreateTimer(void);
 
 /**************************************************************************
-  : hdmRtCreateTimer
-    : ⿪ʼǰĳʼ
-: 
-: 
-  ֵ: RETURN_OK : ɹ  RETURN_ERROR : ʧ
-    : 
+函 数 名: hdmRtCreateTimer
+功    能: 例测开始前的初始化工作
+输入参数: 无
+输出参数: 无
+返 回 值: RETURN_OK : 成功  RETURN_ERROR : 失败
+其    它: 无
 **************************************************************************/
 int32_t hdmRtCreateTimer(void)
 {
@@ -3612,12 +3612,12 @@
 }
 
 /**************************************************************************
-*   : hdmFreeWaitDiskArray
-*    :ͷԤڴռ
-* : 
-* : 
-*   ֵ: 
-*     : 
+* 函 数 名: hdmFreeWaitDiskArray
+*功    能:释放预留的内存空间
+* 输入参数: 无
+* 输出参数: 无
+* 返 回 值: 无
+* 其    他: 无
 **************************************************************************/
 void hdmFreeWaitDiskArray(void)
 {   
@@ -3638,12 +3638,12 @@
 
 /*Begin Modified by j90006936 DTS2014070402027 2014.7.18*/
 /**************************************************************************
-*   : hdmAllocWaitDiskArray
-*    :Ϊg_waitRtDiskg_waitSyncTimeDiskռ
-* : uint32_t size
-* : 
-*   ֵ: bool
-*     : 
+* 函 数 名: hdmAllocWaitDiskArray
+*功    能:为g_waitRtDisk数组和g_waitSyncTimeDisk数组分配空间
+* 输入参数: uint32_t size
+* 输出参数: 无
+* 返 回 值: bool
+* 其    他: 无
 **************************************************************************/
 
 bool hdmAllocWaitDiskArray(uint32_t size)
@@ -3688,12 +3688,12 @@
 
 /*Begin Modified by y00355707 DTS2017011103141 20170112*/
 /**************************************************************************
-  : hdmRoutineExit
-    : ȡӲ̸µֵ
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRoutineExit
+功    能: 获取硬盘高温的门限值
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 int32_t hdmGetAlarmHighTemperature(void)
 {
@@ -3704,12 +3704,12 @@
 void stub_hdmRtExit(void);
 
 /**************************************************************************
-  : hdmRoutineExit
-    : Ӳģ˳ʱͷԴ
-: 
-: 
-  ֵ: 
-    : 
+函 数 名: hdmRoutineExit
+功    能: 硬盘例测模块退出时，释放相关资源
+输入参数: 无
+输出参数: 无
+返 回 值: 无
+其    它: 无
 **************************************************************************/
 void hdmRtExit(void)
 {
@@ -3722,12 +3722,12 @@
 int32_t stub_hdmRtInit(void);
 
 /**************************************************************************
-  : hdmRtInit
-    : Ӳģʼ
-: 
-: 
-  ֵ: RETURN_OK : ɹ  RETURN_ERROR : ʧ
-    : 
+函 数 名: hdmRtInit
+功    能: 硬盘例测模块初始化
+输入参数: 无
+输出参数: 无
+返 回 值: RETURN_OK : 成功  RETURN_ERROR : 失败
+其    它: 无
 **************************************************************************/
 int32_t hdmRtInit(void)
 {
@@ -3735,5 +3735,435 @@
     return stub_hdmRtInit();
 }
 
-HDM_USE_TRACE_POINT /* PC-Lint */
+HDM_USE_TRACE_POINT /* 清除PC-Lint警告 */
+
+#define INVALID_SMART_ID 0
+
+#define DPRT_REPORT_SLOW_TIME_INTERVAL 8 /* 上报事件与上报告警的时间间隔 8天 */
+
+#define MS_TO_DAY(x) ((x) / (24 * 60 * 60 * 1000))
+
+#define DP_RT_UNC_INTVAL_JIFF (24 * 3600 * HZ) // 24个小时
+#define DP_RT_UNC_REPORT_FAULT_THLD 3 // 3天
+#define REMAIN_LIFE_PERCENT_THLD 60 /* 剩余寿命60%报告警 */
+#define REMAIN_LIFE_PERCENT_STRICT_THLD 10 /* 剩余寿命10%报告警和系统盘慢事件 */
+
+typedef struct {
+    char diskModel[DISK_MODEL_LEN];
+    uint8_t lifeOnPeId;
+    uint8_t lifeOnSpareId;
+    uint8_t peId;
+    uint8_t offlineUncId;
+    uint8_t onlineUncId;
+} DpRtSmartIdMap;
+
+typedef struct {
+    char sn[DISK_SN_LEN];
+    uint64_t dayUnc;
+    uint32_t uncIncCount; /* 1天周期UNC有增量，累积计数加1 */
+} DpRtUncDayRecord;
+
+DpRtSmartIdMap g_modelSmartIdMapTable[18] = {
+    {"ME619GXCFCD4T", 231, 232, 167, INVALID_SMART_ID, 160},
+    {"M.2 (S80) 3IE4", 231, 170, INVALID_SMART_ID, INVALID_SMART_ID, INVALID_SMART_ID},
+    {"RTITJ064VGD2EQX", 231, 232, INVALID_SMART_ID, 1, 187}, // PE可能不准 故ID取无效值
+    {"MC619GXAFCC3", 231, 232, 167, INVALID_SMART_ID, 160},
+    {"MC619GXAFCD4T", 231, 232, 167, INVALID_SMART_ID,160},
+    {"RTMMB016VBV4BWXY", 231, 235, INVALID_SMART_ID, 198, 187}, // PE可能不准
+    {"MC659GXAECC3", 231, 232, INVALID_SMART_ID, INVALID_SMART_ID, 160}, // PE额定次数为2w 不检测PE次数
+    {"MC659GXAFCD4T", 231, 232, INVALID_SMART_ID, INVALID_SMART_ID, 160},
+    {"MC659GXBFCD3T", 231, 232, INVALID_SMART_ID, INVALID_SMART_ID, 160},
+    {"MC659GXBFCD4T", 231, 232, INVALID_SMART_ID, INVALID_SMART_ID, 160},
+    {"RTMMA064JHV4EWY", 231, 232, 173, INVALID_SMART_ID, INVALID_SMART_ID},
+    {"RTMMB064VBM3EWXY", 231, 235, 173, 187, 198},
+    {"MC619GXCECC", 231, 232, 167, INVALID_SMART_ID, 160},
+    {"MC619GXCFCD3S", 231, 232, 167, INVALID_SMART_ID, 160},
+    {"MC619GXCFCD4S", 231, 232, 167, INVALID_SMART_ID, 160},
+    {"INTEL SSDSC2BA200G3", 233, 232, INVALID_SMART_ID, INVALID_SMART_ID, 187},
+    {"INTEL SSDSC2BA200G4", 233, 232, INVALID_SMART_ID, INVALID_SMART_ID, 187},
+    {"SAMSUNG MZ7KM240HMHQ-00005", 177, 180, INVALID_SMART_ID, INVALID_SMART_ID, 187}
+};
+
+DpRtUncDayRecord g_uncRecord[HDM_MAX_ROOT_DISK_NUM_IN_ONE_CTRL] = {{"", INVALID_VALUE64, 0}, {"", INVALID_VALUE64, 0}};
+                                                      
+uint64_t g_dpRtUncStartJiff[HDM_MAX_ROOT_DISK_NUM_IN_ONE_CTRL] = {INVALID_VALUE64, INVALID_VALUE64};
+bool g_hasRecoverConf = false;
+uint32_t g_reportAlmTimeStamp = 0; /* 按上电时间作为起始的时间戳 单位天 */
+bool g_DpRtReportFaultSwitch = true;
+uint64_t g_dpRtUncPeriodJiff = DP_RT_UNC_INTVAL_JIFF;
+EXPORT_SYMBOL(g_dpRtUncPeriodJiff);
+uint64_t g_dpRtSpareDelayPeriod = DPRT_REPORT_SLOW_TIME_INTERVAL;
+EXPORT_SYMBOL(g_dpRtSpareDelayPeriod);
+
+extern SD_SCSI_DEVICE_S** g_sdIdToDeviceMap;
+SCSI_DISK_DEVICE_S* SdGetDiskByIdSph050(uint32_t sdId)
+{
+    SD_SCSI_DEVICE_S* dev = NULL;
+    SCSI_DISK_DEVICE_S *disk = NULL;
+    
+    if (unlikely(sdId >= SD_MAX_DEVICE_NUM))
+    {
+        return NULL;
+    }
+    
+    if (g_sdIdToDeviceMap[sdId] == NULL) {
+        return NULL;
+    }
+    dev = g_sdIdToDeviceMap[sdId];
+    disk = SD_GENERIC_TO_DISK(dev);
+    return disk;
+}
+
+/* 解析SMART数据--------------------------------------------------------------------------------------------------------------------------- */
+int32_t DpRtQuerySpecSmartId(uint32_t sdevId, DpRtSpecSmartId *smartIds)
+{
+    uint32_t i;
+    SCSI_DISK_DEVICE_S* disk = SdGetDiskByIdSph050(sdevId);
+    if (disk == NULL) {
+        DBG_LogError(0, "Get disk by id(%u) failed.", sdevId);
+        return RETURN_ERROR;
+    }
+    for (i = 0; i < ARRAY_LEN(g_modelSmartIdMapTable); i++) {
+        if (strcmp(g_modelSmartIdMapTable[i].diskModel, disk->model) == 0) {
+            smartIds->peLifeId = g_modelSmartIdMapTable[i].lifeOnPeId;
+            smartIds->spareLifeId = g_modelSmartIdMapTable[i].lifeOnSpareId;
+            smartIds->peId = g_modelSmartIdMapTable[i].peId;
+            smartIds->offlineUncId = g_modelSmartIdMapTable[i].offlineUncId;
+            smartIds->onlineUncId = g_modelSmartIdMapTable[i].onlineUncId;
+            return RETURN_OK;
+        }
+    }
+    return RETURN_ERROR;
+}
+
+uint64_t DpRtParsePeValue(SCSI_DISK_DEVICE_S* disk, HDM_ATA_SMART_ATTR_ENTRY_S attr)
+{
+    uint64_t value = 0;
+    uint32_t i;
+
+    if (strcmp("RTMMB016VBV4BWXY", disk->model) == 0 ||
+        strcmp("RTMMA064JHV4EWY", disk->model) == 0 ||
+        strcmp("RTMMB064VBM3EWXY", disk->model) == 0) {
+        return (((uint64_t)attr.raw[4]) | ((uint64_t)attr.raw[5] << 8)); // 小端存储？取第5、6字节16位的数据
+    }
+
+    for (i = 0; i < 6; i++) {
+        value = value | ((uint64_t)attr.raw[i] << (8 * i));
+    }
+
+    return value;
+}
+
+uint64_t DpRtParseRawValue(HDM_ATA_SMART_ATTR_ENTRY_S attr)
+{
+    uint64_t value = 0;
+    uint32_t i;
+
+    for (i = 0; i < 6; i++) {
+        value = value | ((uint64_t)attr.raw[i] << (8 * i));
+    }
+
+    return value;
+}
+
+uint64_t DpRtParseSpareValue(SCSI_DISK_DEVICE_S* disk, HDM_ATA_SMART_ATTR_ENTRY_S attr)
+{
+    uint64_t value = 0;
+    uint32_t i;
+
+    if (strcmp("RTITJ064VGD2EQX", disk->model) != 0 && 
+        strcmp("RTMRJ016VGM1BWX", disk->model) != 0 &&
+        strcmp("RTMRJ064VGM2KWX", disk->model) != 0) {
+        return attr.curValue; 
+    }
+
+    for (i = 0; i < 6; i++) {
+        value = value | ((uint64_t)attr.raw[i] << (8 * i));
+    }
+
+    return value;
+}
+
+void HdmNotifyCtrlBoardStatusSph050(DMI_CTRL_STATUS_E bootDiskStatus)
+{    
+    uint64_t frameWwn = INVALID_VALUE64;
+    int32_t ret = RETURN_ERROR;
+
+    frameWwn = BDM_EAM_GET_WWN_FROM_INNER_FRAME_ID(0);
+    if (INVALID_VALUE64 == frameWwn)
+    {
+        DBG_LogError(0, "SYS_RAID:Fail to get frameWwn by frame id(0).");
+        return;
+    }
+
+    ret = OperateCtrlBoard(NOTIFY_CTRL_STATUS, frameWwn, INVALID_VALUE32, (void *)&bootDiskStatus, sizeof(bootDiskStatus));
+    if (ret != RETURN_OK)
+    {
+        DBG_LogError(0, "hdm report rootdisk ctrlBoard failed, frameWwn(%llu), ret(%d).", frameWwn, ret);
+        return;
+    } 
+    /**通知DMI做控制器故障的告警*/
+    DBG_LogInfo(0, "hdm report rootdisk ctrlBoard status successful, bootDiskStatus(%u).", bootDiskStatus);    
+    return;
+}
+
+// 检查是否满足8天的间隔，满足的话再上报系统盘慢事件
+bool DpRtIsMeetPrefailReportAlmInterval(void)
+{
+    uint64_t dayTime;
+    if (g_reportAlmTimeStamp == 0) {
+        return false;
+    }
+
+    dayTime = MS_TO_DAY(LVOS_GetMilliSecond()) + 1 - g_reportAlmTimeStamp;
+    if (dayTime >= g_dpRtSpareDelayPeriod) {
+        return true;
+    }
+
+    BDM_LOG_INFO_CAN_PRINT(DBG_LOGID_NEW, HZ * 3600 * 24, 1ULL,
+        "DP_RT: This ctrl has root disk prefail but ignore event, interval threshhold(%u), alarmtime(%u), current interval(%lu).",
+        g_dpRtSpareDelayPeriod, g_reportAlmTimeStamp, dayTime);
+    return false;
+}
+
+bool DpRtIsScsiAtaSmartPePrefail(SCSI_DISK_DEVICE_S* disk, uint64_t pe, uint64_t spareLife)
+{
+    uint32_t index = disk->slotId % HDM_MAX_ROOT_DISK_NUM_IN_ONE_CTRL;
+    uint32_t uncIncCount = g_uncRecord[index].uncIncCount;
+    uint32_t sdevId = disk->device.sdevId;   
+    
+    if (strcmp(g_uncRecord[index].sn, disk->sn) != 0) {
+        uncIncCount = 0;
+    }
+    
+    if (uncIncCount >= DP_RT_UNC_REPORT_FAULT_THLD) {
+        BDM_LOG_WARN_CAN_PRINT(0, 24 * 3600 * HZ, (uint64_t)sdevId,
+            "The root disk(%u) need reoprt slow because of uncIncCount(%u).", sdevId, uncIncCount);
+        return true;    
+    }
+    
+    if (spareLife < REMAIN_LIFE_PERCENT_STRICT_THLD) {
+        BDM_LOG_WARN_CAN_PRINT(0, 24 * 3600 * HZ, (uint64_t)sdevId,
+            "The root disk(%u) need reoprt slow because of spareLife(%llu).", sdevId, spareLife);
+        return true;
+    }
+    
+    if (DpRtIsMeetPrefailReportAlmInterval()) {
+        BDM_LOG_WARN_CAN_PRINT(0, 24 * 3600 * HZ, (uint64_t)sdevId,
+            "The root disk(%u) need reoprt slow because of spare delay.", sdevId);
+        return true;
+    }
+    
+    if (spareLife < REMAIN_LIFE_PERCENT_THLD) {
+        BDM_LOG_WARN_CAN_PRINT(0, 24 * 3600 * HZ, (uint64_t)sdevId,
+            "The root disk(%u) need reoprt prefail alarm because of sparelife(%u).", sdevId, spareLife);
+        if (g_reportAlmTimeStamp == 0) {
+            HdmNotifyCtrlBoardStatusSph050(DMI_BOOT_DISK_IS_FAILING);
+            g_reportAlmTimeStamp = (uint32_t)MS_TO_DAY(LVOS_GetMilliSecond()) + 1; /* 不满一天，按一天算 */            
+        }
+        return false;
+    }
+    
+    if (pe > 5000) {
+        BDM_LOG_WARN_CAN_PRINT(0, 24 * 3600 * HZ, (uint64_t)sdevId,
+            "The root disk(%u) need reoprt prefail alarm because of pe(%llu).", sdevId, pe);
+        HdmNotifyCtrlBoardStatusSph050(DMI_BOOT_DISK_IS_FAILING);
+    }
+    return false;
+}
+
+void DpRtParseScsiAtaSmartPrefailSph(uint32_t sdevId, HDM_ATA_SMART_DATA_S *smart, HDM_SMART_THRESHOLD_VALUE_S *threshs)
+{
+    int32_t ret;
+    uint32_t i;
+    uint64_t pe = 0;
+    uint64_t spareLife = INVALID_VALUE64;
+    DpRtSpecSmartId smartIds = {0, 0, 0, 0, 0};
+    
+    SCSI_DISK_DEVICE_S* disk = SdGetDiskByIdSph050(sdevId);
+    if (disk == NULL) {
+        DBG_LogError(0, "Get disk by id(%u) failed.", sdevId);
+        return;
+    }
+    
+    if (!disk->isRootDisk) { // 只处理系统盘
+        return;
+    }
+    
+    if (!g_DpRtReportFaultSwitch) {
+        return;
+    }
+
+    ret = DpRtQuerySpecSmartId(sdevId, &smartIds);
+    if (ret != RETURN_OK) {
+        return; // 此处说明系统盘model号不匹配  不用解析了
+    }
+
+    /* 对比当前值、最坏值和门限值，判断硬盘是否预失效 */
+    for (i = 0; i < HDM_SMART_ATTR_NUMBER; i++) {
+        if ((smart->attrEntries[i].id == 0) || (threshs[i].id == 0)) {
+            continue;
+        }
+
+        if (smart->attrEntries[i].id == smartIds.peId) {
+            pe = DpRtParsePeValue(disk, smart->attrEntries[i]);
+        } else if (smart->attrEntries[i].id == smartIds.spareLifeId) {
+            spareLife = DpRtParseSpareValue(disk, smart->attrEntries[i]);
+        }
+    }
+
+    if (DpRtIsScsiAtaSmartPePrefail(disk, pe, spareLife)) {
+        BDM_LOG_WARN_CAN_PRINT(0, 24 * 3600 * HZ, (uint64_t)sdevId,
+                "DP_RT: pe(%lu) spareLife(%lu) uncIncCount(%u).",
+                pe, spareLife, g_uncRecord[(disk->slotId % HDM_MAX_ROOT_DISK_NUM_IN_ONE_CTRL)].uncIncCount);
+        sdReportDeviceCommonEvent(sdevId, SCSI_DISK_EVENT_SLOW, SINGLE_CTRL_EVENT, DISK_IMPENDING_FAILURE_RT); // 上报系统盘慢
+
+    }
+    return;
+}
+
+/* UNC记录-------------------------------------------------------------------------------------------------- */
+int32_t DpRtUpdateUncRecord(SCSI_DISK_DEVICE_S *disk, uint64_t offlineUnc, uint64_t onlineUnc)
+{
+    uint32_t index = disk->slotId % HDM_MAX_ROOT_DISK_NUM_IN_ONE_CTRL;
+    DpRtUncDayRecord uncRecordTmp;
+
+    uncRecordTmp = g_uncRecord[index];
+    if (strcmp(uncRecordTmp.sn, disk->sn) != 0) { // 首次更新
+        (void)BDM_MEMCPY_S(uncRecordTmp.sn, DISK_SN_LEN, disk->sn, DISK_SN_LEN);
+        uncRecordTmp.dayUnc = offlineUnc + onlineUnc;
+        uncRecordTmp.uncIncCount = 0;
+        g_uncRecord[index] = uncRecordTmp;
+        return RETURN_OK;
+    }
+    
+    if (uncRecordTmp.dayUnc >= offlineUnc + onlineUnc) { /* 计数翻转或者UNC无新增 IncCount计数清零 */
+        uncRecordTmp.dayUnc = offlineUnc + onlineUnc;
+        uncRecordTmp.uncIncCount = 0;
+        g_uncRecord[index] = uncRecordTmp;
+        DBG_LogInfo(0, "The root disk(%s) uncCnt is no more than last cycle, dayUnc(%llu), uncIncCount(%u).", 
+            g_uncRecord[index].sn, g_uncRecord[index].dayUnc, g_uncRecord[index].uncIncCount);     
+        return RETURN_OK;
+    }
+
+    if (offlineUnc + onlineUnc > uncRecordTmp.dayUnc) {
+        uncRecordTmp.dayUnc = offlineUnc + onlineUnc;
+        uncRecordTmp.uncIncCount++;
+        g_uncRecord[index] = uncRecordTmp;
+        DBG_LogInfo(0, "Update root disk(%s) unc record, dayUnc(%llu), uncIncCount(%u)."
+            , g_uncRecord[index].sn, g_uncRecord[index].dayUnc, g_uncRecord[index].uncIncCount);
+        return RETURN_OK;
+    }
+
+    return RETURN_OK;
+}
+
+int32_t DpRtParseUnc(SCSI_DISK_DEVICE_S *disk, HDM_ATA_SMART_DATA_S *smart, HDM_SMART_THRESHOLD_VALUE_S *threshs)
+{
+    int32_t ret;
+    uint32_t i;
+    uint64_t offlineUnc = 0;
+    uint64_t onlineUnc = 0;
+    
+    DpRtSpecSmartId smartIds = {0, 0, 0, 0, 0};
+    ret = DpRtQuerySpecSmartId(disk->device.sdevId, &smartIds);
+    if (ret != RETURN_OK) {
+        return RETURN_OK;
+    }
+
+    /* 对比当前值、最坏值和门限值，判断硬盘是否预失效 */
+    for (i = 0; i < HDM_SMART_ATTR_NUMBER; i++) {
+        if ((smart->attrEntries[i].id == 0) || (threshs[i].id == 0)) {
+            continue;
+        }
 
+        if (smart->attrEntries[i].id == smartIds.offlineUncId) {
+            offlineUnc = DpRtParseRawValue(smart->attrEntries[i]);
+        } else if (smart->attrEntries[i].id == smartIds.onlineUncId) {
+            onlineUnc = DpRtParseRawValue(smart->attrEntries[i]);
+        }
+    }
+
+    return DpRtUpdateUncRecord(disk, offlineUnc, onlineUnc);
+}
+
+// 判断UNC更新是否满足时间间隔 一天
+bool DpRtIsNeedUpdateUncRecord(SCSI_DISK_DEVICE_S *disk)
+{
+    uint32_t index = disk->slotId % HDM_MAX_ROOT_DISK_NUM_IN_ONE_CTRL;
+
+    if ((jiffies < g_dpRtUncStartJiff[index]) ||  /* 首次更新或计数翻转 */
+        (jiffies - g_dpRtUncStartJiff[index] >= g_dpRtUncPeriodJiff)) {
+        return true;
+    }
+
+    return false;
+}
+
+void DpRtUpdateUncRecordHandle(uint32_t sdevId, HDM_ATA_SMART_DATA_S *smart, HDM_SMART_THRESHOLD_VALUE_S *threshs)
+{
+    SCSI_DISK_DEVICE_S* disk = SdGetDiskByIdSph050(sdevId);
+    int32_t ret;
+    uint32_t index;
+    if (disk == NULL) {
+        DBG_LogError(0, "Get disk by id(%u) failed.", sdevId);
+        return;
+    }
+    
+    if (!disk->isRootDisk) { // 非系统盘则不处理
+        return;    
+    }
+    
+    if (disk->portType != DISK_TYPE_SATA) {
+        return;
+    }
+
+    if (!DpRtIsNeedUpdateUncRecord(disk)) {
+        return;
+    }
+    
+    ret = DpRtParseUnc(disk, smart, threshs);
+    if (ret == RETURN_OK) {
+        index = disk->slotId % HDM_MAX_ROOT_DISK_NUM_IN_ONE_CTRL;
+        g_dpRtUncStartJiff[index] = jiffies;
+    }
+}
+
+/* 参数持久化实现------------------------------------------------------------------------------------------- */
+
+void DprtRecoverOneConfParamSph050(const char *itemName, uint32_t *data)
+{
+    CST_ITEM_T item;
+    uint32_t value = INVALID_VALUE32;
+
+    (void)BDM_MEMSET_S(&item, sizeof(item), 0, sizeof(item));
+    if (CST_GetItem("BDM", itemName, &item)) {
+        value = (uint32_t)LVOS_StrToU64(item.acValue);
+    }
+
+    if (value != INVALID_VALUE32) {
+        *data = value;
+    }
+    return;
+}
+
+void DprtReadReportFaultSwitch(void)
+{
+    uint32_t tmpSwitch = INVALID_VALUE32;
+    DprtRecoverOneConfParamSph050("DpRtReportFaultSwitch", &tmpSwitch);
+    if (tmpSwitch != INVALID_VALUE32) {
+        g_DpRtReportFaultSwitch = (bool)tmpSwitch;
+        DBG_LogInfo(DBG_LOGID_NEW, "Get DpRtReportFaultSwitch from conf, value(%u).", tmpSwitch);       
+    } else {
+        DBG_LogInfo(DBG_LOGID_NEW, "DpRtReportFaultSwitch is not in conf file, use default value(%u).", 
+            g_DpRtReportFaultSwitch);        
+    }
+}
+
+void DpRtRecoverData(void)
+{
+    if (!g_hasRecoverConf){ // 只更新一次
+        DprtReadReportFaultSwitch();
+        g_hasRecoverConf = true;
+    }
+}
