--- ./source/private_module/sd/adapter/sd_adapter_device.c	2018-02-09 07:36:26.000000000 +0000
+++ ./source/private_module/sd/adapter/sd_adapter_device.c.hotpatch	2020-09-22 09:28:44.000000000 +0000
@@ -2218,11 +2218,11 @@
     }
     spin_unlock(&adpDev->lock);
 }
-
+void sdCheckAllDiskBurstSizePatch(void);
 STATIC void sdAdapterHangIOTimeout(void *param)
 {
     UNREFERENCE_PARAM(param);
-    DBG_LogDebug(LOG_ID_SD_0049, "Check device hang IO timer.");
+    sdCheckAllDiskBurstSizePatch();
     (void)sdListForEachAdapterDevice(sdAdapterDeviceHangIOTimeout, NULL);
 }
 
--- ./source/private_module/sd/sd_devin.c	2018-04-20 08:27:24.000000000 +0000
+++ ./source/private_module/sd/sd_devin.c.hotpatch	2020-09-22 09:28:44.000000000 +0000
@@ -2420,7 +2420,7 @@
     techInfo = (SD_DISK_TECH_PARAM_S*)(void*)sgl->entrys[0].buf;
     memcpy(param, techInfo, sizeof(SD_DISK_TECH_PARAM_S));
 }
-
+int sdSetDiskBurstDonePatch(void *context, int32_t result);
 /*Modify by h00405124 DTS2017111300592 20171110*/
 /**************************************************************************
 *     : ƬٿصĽ
@@ -2433,15 +2433,16 @@
 void sdSetDataDestroyDevIn(void *context, int32_t result)
 {
     REQ_S *req = NULL;
-
+    if (RETURN_OK == sdSetDiskBurstDonePatch(context, result))
+    {
+        return;
+    }
     if (NULL == context)
     {
         SYS_BUG(SYS_BUG_NORM, MODULE_FUNC_HANG, " context should not be NULL in action callback.");
         return;
     }
-
     req = (REQ_S*)context;
-
     if (RETURN_OK != result)
     {
         DBG_LogError(DBG_LOGID_BUTT, 
@@ -2451,7 +2452,6 @@
         sdDevInProcessReqChildDone(req->parent, req);
         return;
     }
-
     sdUpdateDiskSettingOneStepDone(req);
 }
 
@@ -2506,3 +2506,72 @@
 /* PC-Lint */
 SD_USE_TRACE_POINT
 
+
+/**************************************************************************
+*     :ָӲ̷ƬС
+*     : лصsdSetDataDestroyDevInжس
+                    #define DISCONT_RECONT_PAGE_CODE         0x02
+                    #define DISCONT_RECONT_SUB_PAGE_CODE     0x00
+                    #define BURST_SIZE                       0x80    //<64KС
+                    #define BURST_SIZE_MASK                  0xFF
+                    #define BURST_SIZE_OFFSET                10 
+                    #define BURST_LEN                        2
+**************************************************************************/
+void sdSendDiskBurstSizePatch(uint32_t sdId, void *context)
+{
+    uint8_t burstBytes[2] = {0x00, 0x80}; /*Disconnect-Reconnect mode page set 64KB*/
+    if (RETURN_OK != HDM_MODE_SELECT_BY_BUFFER(sdId, 0x02, 0x00, 10, burstBytes, 2, context, sdSetDataDestroyDevIn))
+    {
+        DBG_LogError(LOG_ID_SD_00B9, "BURST: send mode select cmd failed, sdid %u.", sdId); 
+
+        /*УcontextΪREQΪգʧʱҪִлص*/
+        if (NULL != context)
+        {
+            DBG_LogError(LOG_ID_SD_00B9, "BURST: will do sdSetDataDestroyDevIn, sdid %u.", sdId);
+            sdSetDataDestroyDevIn(context, RETURN_ERROR);
+        }
+    }
+    DBG_LogDebug(LOG_ID_SD_00B9, "BURST: set disk burst size, sdid %u.", sdId);
+    return;
+}
+EXPORT_SYMBOL(sdSendDiskBurstSizePatch);
+
+/**************************************************************************
+*     :ƬСĻص
+*     :кsdSetDataDestroyDevInе
+**************************************************************************/
+int sdSetDiskBurstDonePatch(void *context, int32_t result)
+{
+    SD_DEV_IN_PROCESS_DATA_S *data = NULL;
+    SD_DEV_IN_PHASE_S *phase = NULL;
+    REQ_S* req = NULL;
+
+    /*ӦЧ󣬱contextΪNULL*/
+    if (NULL == context)
+    {
+        if(RETURN_OK != result)
+        {
+            DBG_LogError(LOG_ID_SD_00B9, "BURST: set disk burst size failed, result %d.", result); 
+        }
+        DBG_LogDebug(LOG_ID_SD_00B9, "BURST: set disk burst size, result %d.", result);
+        return RETURN_OK;
+    }
+    req = (REQ_S*)context;
+    data = (SD_DEV_IN_PROCESS_DATA_S*)(void*)(req->parent->producerPrivate);
+    phase = &data->phases[data->currentPhase];
+    /*УǰΪcase 6ӦƬС*/
+    if (6 == phase->phaseData)
+    {
+        if (RETURN_OK != result)
+        {
+            DBG_LogError(DBG_LOGID_BUTT, "BURST: set disk burst size failed, sdid %llu, result %d.", req->objectId, result);
+        }
+        DBG_LogDebug(LOG_ID_SD_00B9, "BURST: set disk burst size, sdid %llu, result %d.", req->objectId, result);
+        sdUpdateDiskSettingOneStepDone(req);
+        return RETURN_OK;
+    }
+    /*ERRORԭ̣ѿǲжسӰ*/
+    return RETURN_ERROR;
+}
+
+
--- ./source/private_module/sd/stub_v3/stub_sd_devin.c	2018-04-20 08:27:24.000000000 +0000
+++ ./source/private_module/sd/stub_v3/stub_sd_devin.c.hotpatch	2020-09-22 09:28:44.000000000 +0000
@@ -209,8 +209,8 @@
 
     return RETURN_ERROR;
 }
-
-
+void sdUpdateDiskDestoryStatePatch(SCSI_DISK_DEVICE_S *disk, REQ_S *req);
+void sdCheckOneDiskBurstSizePatch(uint32_t sdId, REQ_S *req);
 /**************************************************************************
 *     : ӲϢ״̬ĿǽȦӶ
 * : phase ׶ṹ
@@ -228,14 +228,14 @@
     switch ( phase->phaseData )
     {
         case 5:
-            if (RETURN_OK == sdDiskDestoryPreContion(disk)) 
-            { 
-                if (RETURN_OK != HDM_CHECK_DISK_DATA_DESTORY((uint32_t)req->objectId, req, sdCheckDataDestroyDevIn))
-                { 
-                    sdCheckDataDestroyDevIn(req, RETURN_ERROR, HDM_DISK_DESTROY_SWITCH_BUTT);
-                }   
-                break; 
-            }       /*lint -fallthrough */  
+            /* Ϊ֤кŶ룬 */
+            sdUpdateDiskDestoryStatePatch(disk, req);          
+            break;
+            
+        case 6:
+             /* ƬС */
+            sdCheckOneDiskBurstSizePatch((uint32_t)req->objectId, req);                     
+            break;
   
         default:
             req->result = RETURN_OK;
@@ -1269,3 +1269,168 @@
 /*End Modified by w90005722 SR-0000268771 20140513*/
 
 
+extern void *g_pSdFrameTPool;
+extern uint32_t g_sdFrameCmdPoolId;
+
+/* ȫֱĵ0λ֤޸Ĳͬһʱֻһʵ */
+/* ȫֱĵ1λ֤޸ĲֻҪɹִһ */
+uint32_t g_sdFunctionActivePatch = 0;
+#define SD_EXEC_ONLY_ONE_PATCH_FLAG  (0)
+#define SD_EXEC_SUCCESS_PATCH_FLAG   (1)
+
+/* 3޸model */
+#define SD_PATCH_BURST_DISK_NUM      (3) 
+char *g_SdNeedSetBurstSum[SD_PATCH_BURST_DISK_NUM] = {
+    "HUC109030CSS600",
+    "HUC109060CSS600",
+    "HUC109090CSS600",
+};
+
+extern void sdSendDiskBurstSizePatch(uint32_t sdId, void *context);
+
+/**************************************************************************
+*     : 
+*     : ޸sdUpdateDiskSettingSecondStateMachineҪ
+**************************************************************************/
+void sdUpdateDiskDestoryStatePatch(SCSI_DISK_DEVICE_S *disk, REQ_S *req)
+{
+    if (RETURN_OK == sdDiskDestoryPreContion(disk)) 
+    { 
+        if (RETURN_OK != HDM_CHECK_DISK_DATA_DESTORY((uint32_t)req->objectId, req, sdCheckDataDestroyDevIn))
+        { 
+            sdCheckDataDestroyDevIn(req, RETURN_ERROR, HDM_DISK_DESTROY_SWITCH_BUTT);
+        }   
+    }
+    else
+    {
+        sdUpdateDiskSettingOneStepDone(req);
+    }
+    return;
+}
+
+/**************************************************************************
+*     : ָsdidжϺ·ƬС
+*     : ̺Ͷʱֱ
+**************************************************************************/
+int32_t sdSetBurstSizePreConditionPatch(uint32_t sdId)
+{
+    SD_SCSI_DEVICE_S *dev = NULL;
+    SCSI_DISK_DEVICE_S *disk = NULL;
+    uint32_t i = 0;
+
+    dev = SD_DEVICE_LOOK_UP(sdId);
+    if (NULL == dev)
+    {
+        BDM_PRINT_LIMIT_PERIOD(BDM_LOG_INTERVAL_HALF_HOUR, 1, DBG_LOG_INFO, DBG_LOGID_BUTT, 
+                         "BURST: can not find sdid(%u).", sdId);
+        return RETURN_ERROR;
+    }
+
+    if (SCSI_DEVICE_TYPE_DISK != dev->type)
+    {   
+        BDM_PRINT_LIMIT_PERIOD(BDM_LOG_INTERVAL_HALF_HOUR, 1, DBG_LOG_INFO, DBG_LOGID_BUTT, 
+                             "BURST: dev type %d is not disk, sdid %u.", dev->type, sdId);
+        SD_PUT_DEVICE(dev);
+        return RETURN_ERROR;
+    }
+
+    disk = SD_GENERIC_TO_DISK(dev);
+    for (i = 0; i < SD_PATCH_BURST_DISK_NUM; i++)
+    {
+        if (0 == strcmp(disk->model, g_SdNeedSetBurstSum[i]))
+        { 
+            break;
+        }
+    }
+
+    if (SD_PATCH_BURST_DISK_NUM == i)
+    {
+        SD_PUT_DEVICE(dev);
+        return RETURN_ERROR;
+    }
+    
+    DBG_LogInfo(LOG_ID_SD_00B9, "BURST: will send burst cmd, sdid %u, mode %s.", sdId, disk->model); 
+    SD_PUT_DEVICE(dev);
+    return RETURN_OK;
+}
+
+/**************************************************************************
+*     : 鲢һ̵ƬС
+*     : sdUpdateDiskSettingSecondStateMachineԭк
+**************************************************************************/
+void sdCheckOneDiskBurstSizePatch(uint32_t sdId, REQ_S *req)
+{
+    if (RETURN_OK == sdSetBurstSizePreConditionPatch(sdId))
+    {
+        sdSendDiskBurstSizePatch(sdId, req);
+    }
+    else
+    {
+        sdUpdateDiskSettingOneStepDone(req);
+    }
+    
+    return;
+}
+
+/**************************************************************************
+*     : ̺߳Ӳ̲ƬС
+*     : Чжʱִ1
+**************************************************************************/
+void sdHandleCheckAllDiskBurstSizePatch(CMD_S *cmd)
+{
+    uint32_t sdId = 0;
+
+    /* ͷ߳Դ */
+    FREE_STRUCTURE(cmd, g_sdFrameCmdPoolId);
+ 	cmd = NULL;
+
+    /* sd޸ƬСֵ */
+    for (sdId = SD_DISK_LUN_MIN_ID; sdId < SD_DISK_LUN_MAX_ID; sdId++) {
+        if (sdSetBurstSizePreConditionPatch(sdId) == RETURN_OK) {
+            sdSendDiskBurstSizePatch(sdId, NULL);
+        }
+    }
+
+    BDM_SET_BIT(SD_EXEC_SUCCESS_PATCH_FLAG, (void *)&g_sdFunctionActivePatch);
+    BDM_CLEAR_BIT(SD_EXEC_ONLY_ONE_PATCH_FLAG, (void *)&g_sdFunctionActivePatch);   
+
+    DBG_LogInfo(LOG_ID_SD_00B9, "BURST: check and set all disk burst size success, g_sdFunctionActivePatch(%u).", g_sdFunctionActivePatch);
+    
+    return;
+}
+
+/**************************************************************************
+*     : ̺߳
+*     : Чжʱִ1
+**************************************************************************/
+void sdCheckAllDiskBurstSizePatch(void)
+{
+    int32_t ret = RETURN_ERROR;
+    CMD_S *cmd = NULL;
+
+    if ((BDM_TEST_AND_SET_BIT(SD_EXEC_ONLY_ONE_PATCH_FLAG, (void *)&g_sdFunctionActivePatch) == 0) &&
+        (BDM_TEST_BIT(SD_EXEC_SUCCESS_PATCH_FLAG, (void *)&g_sdFunctionActivePatch) == 0)) {
+        ALLOCATE_STRUCTURE(MY_PID, g_sdFrameCmdPoolId, (void *)&cmd);
+        if (cmd == NULL) {
+            BDM_CLEAR_BIT(SD_EXEC_ONLY_ONE_PATCH_FLAG, (void *)&g_sdFunctionActivePatch);
+            DBG_LogError(LOG_ID_SD_028A, "BURST: Alloc cmd node fail.");
+            return;
+        }
+
+        cmd->execute = sdHandleCheckAllDiskBurstSizePatch;
+        ret = IOD_ADD_T_POOL_CMD(g_pSdFrameTPool, cmd);
+        if (ret == RETURN_OK) {
+            return;
+        } else {
+            BDM_CLEAR_BIT(SD_EXEC_ONLY_ONE_PATCH_FLAG, (void *)&g_sdFunctionActivePatch);
+            FREE_STRUCTURE(cmd, g_sdFrameCmdPoolId);
+            cmd = NULL;
+            DBG_LogError(LOG_ID_SD_028A, "BURST: Add TPool fail.");
+        }
+    }
+
+    return;
+}
+EXPORT_SYMBOL(sdCheckAllDiskBurstSizePatch);
+
+
