diff --git a/framework/model/storage/src/mmc/mmc_core.c b/framework/model/storage/src/mmc/mmc_core.c
index 441cd5f144833e05a445a8b897efe1964c75655f..9c8c80917e1fd4d41531e9e6110f8ed81c29dd9a 100644
--- a/framework/model/storage/src/mmc/mmc_core.c
+++ b/framework/model/storage/src/mmc/mmc_core.c
@@ -71,8 +71,6 @@ static int32_t MmcCntlrExecRequest(struct MmcCntlr *cntlr, struct MmcCmd *cmd)
 
 static int32_t MmcCntlrPlug(struct MmcCntlr *cntlr)
 {
-    uint32_t i;
-
     if (cntlr == NULL) {
         HDF_LOGE("MmcCntlrPlug: cntlr is null!");
         return HDF_ERR_INVALID_OBJECT;
@@ -97,7 +95,7 @@ static int32_t MmcCntlrPlug(struct MmcCntlr *cntlr)
     }
 
     MmcCntlrLock(cntlr);
-    for (i = 0; i < MMC_DETECET_RETRY; i++) {
+    for (uint32_t i = 0; i < MMC_DETECET_RETRY; i++) {
         cntlr->detecting = true;
         if (MmcDoDetect(cntlr) == HDF_SUCCESS) {
             MmcDeviceAddOps(cntlr->curDev, NULL);
@@ -129,7 +127,6 @@ static int32_t MmcCntlrUnplug(struct MmcCntlr *cntlr)
 static int32_t MmcCntlrSdioRescanHandle(struct MmcCntlr *cntlr)
 {
     uint8_t val;
-    int32_t error;
 
     if (cntlr == NULL) {
         HDF_LOGE("MmcCntlrSdioRescanHandle: cntlr is null.");
@@ -138,7 +135,7 @@ static int32_t MmcCntlrSdioRescanHandle(struct MmcCntlr *cntlr)
 
     if (cntlr->curDev != NULL && cntlr->curDev->state.bits.present > 0) {
         if (cntlr->curDev->type == MMC_DEV_SDIO || cntlr->curDev->type == MMC_DEV_COMBO) {
-            error = SdioReadCccrIoEnable(cntlr, &val);
+            int32_t error = SdioReadCccrIoEnable(cntlr, &val);
             if (error != HDF_SUCCESS) {
                 HDF_LOGD("re-detect sdio.");
                 MmcCntlrPlug(cntlr);
@@ -207,7 +204,6 @@ static int32_t MmcMsgHandleDefault(struct PlatformQueue *queue, struct PlatformM
 
 static int32_t MmcCntlrQueueCreate(struct MmcCntlr *cntlr, bool needQueue)
 {
-    int32_t ret;
     const char *threadName = NULL;
 
     if (!needQueue) {
@@ -226,7 +222,7 @@ static int32_t MmcCntlrQueueCreate(struct MmcCntlr *cntlr, bool needQueue)
         HDF_LOGE("MmcCntlrQueueCreate: fail to create msg queue!");
         return HDF_PLT_ERR_OS_API;
     }
-    ret = PlatformQueueStart(cntlr->msgQueue);
+    int32_t ret = PlatformQueueStart(cntlr->msgQueue);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("MmcCntlrQueueCreate: fail to start msg queue!");
         PlatformQueueDestroy(cntlr->msgQueue);
@@ -236,8 +232,6 @@ static int32_t MmcCntlrQueueCreate(struct MmcCntlr *cntlr, bool needQueue)
 
 static int32_t MmcCntlrInit(struct MmcCntlr *cntlr, bool needQueue)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("MmcCntlrInit: cntlr is null!");
         return HDF_ERR_INVALID_OBJECT;
@@ -253,7 +247,7 @@ static int32_t MmcCntlrInit(struct MmcCntlr *cntlr, bool needQueue)
         return HDF_ERR_INVALID_OBJECT;
     }
 
-    ret = OsalMutexInit(&cntlr->mutex);
+    int32_t ret = OsalMutexInit(&cntlr->mutex);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("MmcCntlrInit: mutex init fail!");
         return ret;
@@ -282,14 +276,12 @@ static void MmcCntlrUninit(struct MmcCntlr *cntlr)
 
 int32_t MmcCntlrAdd(struct MmcCntlr *cntlr, bool needQueue)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("MmcCntlrAdd: cntlr is null!");
         return HDF_ERR_INVALID_OBJECT;
     }
 
-    ret = MmcCntlrInit(cntlr, needQueue);
+    int32_t ret = MmcCntlrInit(cntlr, needQueue);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("MmcCntlrAdd: cntlr init fail, ret: %d!", ret);
         return ret;
@@ -334,8 +326,6 @@ struct MmcDevice *MmcCntlrGetDevice(struct MmcCntlr *cntlr)
 
 static int32_t MmcCntlrPostMsg(struct MmcCntlr *cntlr, struct MmcMsg *mmcMsg)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("MmcCntlrPostMsg: cntlr is null!");
         return HDF_ERR_INVALID_OBJECT;
@@ -353,7 +343,7 @@ static int32_t MmcCntlrPostMsg(struct MmcCntlr *cntlr, struct MmcMsg *mmcMsg)
         return HDF_SUCCESS;
     }
 
-    ret = OsalSemWait(&mmcMsg->sem, HDF_WAIT_FOREVER);
+    int32_t ret = OsalSemWait(&mmcMsg->sem, HDF_WAIT_FOREVER);
     (void)OsalSemDestroy(&mmcMsg->sem);
     OsalMemFree(mmcMsg);
     if (ret != HDF_SUCCESS) {
@@ -453,7 +443,6 @@ int32_t MmcCntlrTune(struct MmcCntlr *cntlr, uint32_t cmdCode)
 
 void MmcCntlrSelectWorkVoltage(struct MmcCntlr *cntlr, union MmcOcr *ocr)
 {
-    uint32_t tmpOcr;
     uint32_t i;
 
     /* ignore reveserd. */
@@ -470,7 +459,7 @@ void MmcCntlrSelectWorkVoltage(struct MmcCntlr *cntlr, union MmcOcr *ocr)
      * obtain the voltage range supported by both the host and the OCR register,
      * and then select the minimum voltage value.
      */
-    tmpOcr = ((ocr->ocrData) & (cntlr->ocrDef.ocrData));
+    uint32_t tmpOcr = ((ocr->ocrData) & (cntlr->ocrDef.ocrData));
     for (i = 0; i <= MMC_OCR_MAX_VOLTAGE_BIT; i++) {
         if ((tmpOcr & (1 << i)) > 0) {
             break;
@@ -805,8 +794,6 @@ int32_t MmcCntlrAddSdioRescanMsgToQueue(struct MmcCntlr *cntlr)
 static void SdioHandlePendingIrq(struct MmcCntlr *cntlr, struct SdioDevice *dev)
 {
     uint8_t val;
-    int32_t ret;
-    uint32_t i;
     struct SdioFunction *func = dev->curFunction;
 
     if (func == NULL) {
@@ -818,13 +805,13 @@ static void SdioHandlePendingIrq(struct MmcCntlr *cntlr, struct SdioDevice *dev)
         return;
     }
 
-    ret = SdioReadCccrIntPending(cntlr, &val);
+    int32_t ret = SdioReadCccrIntPending(cntlr, &val);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("MmcCntlrHandleSdioPendingIrq: read cccr int pending fail! ret = %d.", ret);
         return;
     }
 
-    for (i = 0; i < SDIO_MAX_FUNCTION_NUMBER; i++) {
+    for (uint32_t i = 0; i < SDIO_MAX_FUNCTION_NUMBER; i++) {
         if ((val & (1 << (i + 1))) == 0) {
             continue;
         }
@@ -843,7 +830,6 @@ static void SdioHandlePendingIrq(struct MmcCntlr *cntlr, struct SdioDevice *dev)
 
 static int32_t SdioIrqThreadWorker(void *data)
 {
-    int32_t ret;
     struct SdioDevice *dev = (struct SdioDevice *)data;
     struct MmcCntlr *cntlr = NULL;
 
@@ -860,7 +846,7 @@ static int32_t SdioIrqThreadWorker(void *data)
 
     while (true) {
         /* wait envent */
-        ret = OsalSemWait(&dev->sem, HDF_WAIT_FOREVER);
+        int32_t ret = OsalSemWait(&dev->sem, HDF_WAIT_FOREVER);
         if (ret != HDF_SUCCESS) {
             continue;
         }
@@ -876,7 +862,6 @@ static int32_t SdioIrqThreadWorker(void *data)
 
 int32_t MmcCntlrCreatSdioIrqThread(struct MmcCntlr *cntlr)
 {
-    int32_t ret;
     struct OsalThreadParam config = {0};
     struct SdioDevice *dev = NULL;
 
@@ -886,7 +871,7 @@ int32_t MmcCntlrCreatSdioIrqThread(struct MmcCntlr *cntlr)
     }
 
     dev = (struct SdioDevice *)cntlr->curDev;
-    ret = OsalSemInit(&dev->sem, 0);
+    int32_t ret = OsalSemInit(&dev->sem, 0);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("MmcCntlrCreatSdioIrqThread: sem init fail, ret: %d!", ret);
         return ret;
@@ -1012,9 +997,7 @@ int32_t MmcCntlrParse(struct MmcCntlr *cntlr, struct HdfDeviceObject *obj)
 static void MmcCntlrParseCapability(const struct DeviceResourceNode *node,
     struct DeviceResourceIface *drsOps, struct MmcCntlr *cntlr)
 {
-    int32_t ret;
-
-    ret = drsOps->GetUint16(node, "voltDef", &(cntlr->voltDef), 0);
+    int32_t ret = drsOps->GetUint16(node, "voltDef", &(cntlr->voltDef), 0);
     if (ret != HDF_SUCCESS) {
         cntlr->voltDef = 0;
     }
@@ -1059,7 +1042,6 @@ int32_t MmcCntlrParse(struct MmcCntlr *cntlr, struct HdfDeviceObject *obj)
 {
     const struct DeviceResourceNode *node = NULL;
     struct DeviceResourceIface *drsOps = NULL;
-    int32_t ret;
 
     if (obj == NULL || cntlr == NULL) {
         HDF_LOGE("MmcCntlrParse: input param is null!");
@@ -1077,7 +1059,7 @@ int32_t MmcCntlrParse(struct MmcCntlr *cntlr, struct HdfDeviceObject *obj)
         return HDF_FAILURE;
     }
 
-    ret = drsOps->GetUint16(node, "hostId", &(cntlr->index), 0);
+    int32_t ret = drsOps->GetUint16(node, "hostId", &(cntlr->index), 0);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("MmcCntlrParse: read hostId fail, ret: %d", ret);
         return ret;
@@ -1098,8 +1080,6 @@ int32_t MmcCntlrParse(struct MmcCntlr *cntlr, struct HdfDeviceObject *obj)
 
 int32_t MmcDeviceAdd(struct MmcDevice *mmc)
 {
-    int32_t ret;
-
     if (mmc == NULL || mmc->cntlr == NULL) {
         HDF_LOGE("MmcDeviceAdd: mmc or cntlr is null!");
         return HDF_ERR_INVALID_OBJECT;
@@ -1129,7 +1109,7 @@ int32_t MmcDeviceAdd(struct MmcDevice *mmc)
     }
 
     mmc->device.manager = PlatformManagerGet(PLATFORM_MODULE_MMC);
-    ret = PlatformDeviceAdd(&mmc->device);
+    int32_t ret = PlatformDeviceAdd(&mmc->device);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("MmcDeviceAdd: mmc device add fail, ret: %d!", ret);
         MmcCntlrPut(mmc->cntlr);
@@ -1307,7 +1287,6 @@ ssize_t MmcDeviceErase(struct MmcDevice *mmc, size_t startSec, size_t nSec)
     size_t curSec = nSec;
     size_t curStartSec = startSec;
     size_t eraseSec;
-    ssize_t ret;
 
     if (mmc == NULL) {
         HDF_LOGE("MmcDeviceErase: mmc is null!");
@@ -1320,7 +1299,7 @@ ssize_t MmcDeviceErase(struct MmcDevice *mmc, size_t startSec, size_t nSec)
         } else {
             eraseSec = curSec;
         }
-        ret = MmcSendErase(mmc->cntlr, curStartSec, eraseSec);
+        ssize_t ret = MmcSendErase(mmc->cntlr, curStartSec, eraseSec);
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("MmcDeviceErase: fail!");
             return ret;
diff --git a/framework/model/storage/src/mmc/mmc_protocol.c b/framework/model/storage/src/mmc/mmc_protocol.c
index b890256cc130d346db812d3f915fffb7c89efe4d..3fb0a313c4d0f11a72b00a6b94e5dc2922db0e6c 100644
--- a/framework/model/storage/src/mmc/mmc_protocol.c
+++ b/framework/model/storage/src/mmc/mmc_protocol.c
@@ -48,10 +48,6 @@ static uint32_t MmcEndianConversion(uint32_t x)
 /* Decoding algorithm */
 static uint32_t MmcParseBits(const uint32_t *data, uint32_t bitsLen, uint32_t start, uint32_t size)
 {
-    uint32_t index;
-    uint32_t shift;
-    uint32_t ret;
-
     if (start >= bitsLen || size == 0) {
         HDF_LOGE("MmcParseBits: input invalid!");
         return 0;
@@ -61,9 +57,9 @@ static uint32_t MmcParseBits(const uint32_t *data, uint32_t bitsLen, uint32_t st
         return 0;
     }
 
-    index = (bitsLen / BITS_NUMBER_OF_4_BYTES) - (start / BITS_NUMBER_OF_4_BYTES) - 1;
-    shift = start & (BITS_NUMBER_OF_4_BYTES - 1);
-    ret = data[index] >> shift;
+    uint32_t index = (bitsLen / BITS_NUMBER_OF_4_BYTES) - (start / BITS_NUMBER_OF_4_BYTES) - 1;
+    uint32_t shift = start & (BITS_NUMBER_OF_4_BYTES - 1);
+    uint32_t ret = data[index] >> shift;
     if (size + shift > BITS_NUMBER_OF_4_BYTES) {
         ret |= data[index - 1] << (BITS_NUMBER_OF_4_BYTES - shift);
     }
@@ -76,9 +72,6 @@ static uint32_t MmcParseBits(const uint32_t *data, uint32_t bitsLen, uint32_t st
 
 static int32_t MmcSendCmd(struct MmcCntlr *cntlr, struct MmcCmd *cmd, struct MmcData *data, uint32_t retryTimes)
 {
-    uint32_t i;
-    int32_t ret;
-
     if (cntlr == NULL || cmd == NULL || retryTimes == 0) {
         HDF_LOGE("MmcSendCmd: cntlr or cmd or retryTimes is null!");
         return HDF_ERR_INVALID_PARAM;
@@ -89,8 +82,8 @@ static int32_t MmcSendCmd(struct MmcCntlr *cntlr, struct MmcCmd *cmd, struct Mmc
     }
 
     cmd->data = data;
-    for (i = 0; i < retryTimes; i++) {
-        ret = MmcCntlrDoRequest(cntlr, cmd);
+    for (uint32_t i = 0; i < retryTimes; i++) {
+        int32_t ret = MmcCntlrDoRequest(cntlr, cmd);
         if (ret != HDF_SUCCESS) {
             continue;
         }
@@ -170,7 +163,6 @@ static int32_t MmcAllSendCid(struct MmcCntlr *cntlr)
 {
     struct MmcCmd cmd = {0};
     uint32_t *cid = NULL;
-    int32_t err;
 
     if (cntlr == NULL || cntlr->curDev == NULL) {
         HDF_LOGE("MmcAllSendCid: cntlr or curDev is null!");
@@ -182,7 +174,7 @@ static int32_t MmcAllSendCid(struct MmcCntlr *cntlr)
     cmd.argument = 0;
     /* Broadcast Commands with Response(bcr). */
     cmd.respType = MMC_RESP_R2 | MMC_CMD_TYPE_BCR;
-    err = MmcSendCmd(cntlr, &cmd, NULL, MMC_CMD_DEFAULT_RETRY_TIMES);
+    int32_t err = MmcSendCmd(cntlr, &cmd, NULL, MMC_CMD_DEFAULT_RETRY_TIMES);
     if (err != HDF_SUCCESS) {
         HDF_LOGE("MmcAllSendCid: mmc send cmd fail!");
         return err;
@@ -249,7 +241,6 @@ static int32_t MmcSendCsd(struct MmcCntlr *cntlr)
 {
     struct MmcCmd cmd = {0};
     uint32_t *csd = NULL;
-    int32_t err;
 
     if (cntlr == NULL || cntlr->curDev == NULL) {
         HDF_LOGE("MmcSendCsd: cntlr or curDev is null!");
@@ -259,7 +250,7 @@ static int32_t MmcSendCsd(struct MmcCntlr *cntlr)
     cmd.cmdCode = SEND_CSD;
     cmd.argument = (cntlr->curDev->reg.rca << 16);
     cmd.respType = MMC_RESP_R2 | MMC_CMD_TYPE_AC;
-    err = MmcSendCmd(cntlr, &cmd, NULL, MMC_CMD_DEFAULT_RETRY_TIMES);
+    int32_t err = MmcSendCmd(cntlr, &cmd, NULL, MMC_CMD_DEFAULT_RETRY_TIMES);
     if (err != HDF_SUCCESS) {
         HDF_LOGE("MmcSendCsd: mmc send cmd fail!");
         return err;
@@ -275,7 +266,6 @@ static int32_t MmcSendCsd(struct MmcCntlr *cntlr)
 int32_t MmcSendStatus(struct MmcCntlr *cntlr, uint32_t *status)
 {
     struct MmcCmd cmd = {0};
-    int32_t error;
 
     if (cntlr == NULL || cntlr->curDev == NULL) {
         HDF_LOGE("MmcSendStatus: cntlr or curDev is null!");
@@ -286,7 +276,7 @@ int32_t MmcSendStatus(struct MmcCntlr *cntlr, uint32_t *status)
     /* [31:16] RCA, [15:0] stuff bits. */
     cmd.argument = (cntlr->curDev->reg.rca << 16);
     cmd.respType = MMC_RESP_SPI_R2 | MMC_RESP_R1 | MMC_CMD_TYPE_AC;
-    error = MmcSendCmd(cntlr, &cmd, NULL, MMC_CMD_DEFAULT_RETRY_TIMES);
+    int32_t error = MmcSendCmd(cntlr, &cmd, NULL, MMC_CMD_DEFAULT_RETRY_TIMES);
     if (error != HDF_SUCCESS) {
         return error;
     }
@@ -298,7 +288,6 @@ int32_t MmcSendStatus(struct MmcCntlr *cntlr, uint32_t *status)
 
 static int32_t MmcSwitch(struct MmcCntlr *cntlr, uint8_t set, uint8_t index, uint8_t value)
 {
-    int32_t error;
     struct MmcCmd cmd = {0};
     uint32_t status;
 
@@ -312,7 +301,7 @@ static int32_t MmcSwitch(struct MmcCntlr *cntlr, uint8_t set, uint8_t index, uin
             | (value << 8)
             | set;
     cmd.respType = MMC_RESP_SPI_R1B | MMC_RESP_R1B | MMC_CMD_TYPE_AC;
-    error = MmcSendCmd(cntlr, &cmd, NULL, MMC_CMD_DEFAULT_RETRY_TIMES);
+    int32_t error = MmcSendCmd(cntlr, &cmd, NULL, MMC_CMD_DEFAULT_RETRY_TIMES);
     if (error != HDF_SUCCESS) {
         HDF_LOGE("MmcSwitch: send cmd fail!");
         return error;
@@ -342,7 +331,6 @@ static int32_t MmcSwitch(struct MmcCntlr *cntlr, uint8_t set, uint8_t index, uin
 
 static int32_t MmcAppCmd(struct MmcCntlr *cntlr, uint32_t acmd)
 {
-    int32_t err;
     struct MmcCmd cmd = {0};
 
     if (cntlr == NULL || cntlr->curDev == NULL) {
@@ -363,7 +351,7 @@ static int32_t MmcAppCmd(struct MmcCntlr *cntlr, uint32_t acmd)
         cmd.argument = 0;
         cmd.respType = MMC_RESP_R1 | MMC_CMD_TYPE_BCR;
     }
-    err = MmcSendCmd(cntlr, &cmd, NULL, 1);
+    int32_t err = MmcSendCmd(cntlr, &cmd, NULL, 1);
     if (err != HDF_SUCCESS) {
         HDF_LOGE("MmcAppCmd: mmc send cmd fail!");
         return err;
@@ -399,7 +387,6 @@ static int32_t MmcWaitCardReady(struct MmcCntlr *cntlr)
 
 int32_t MmcStopTransmission(struct MmcCntlr *cntlr, bool writeFlag, uint32_t *stopStatus)
 {
-    int32_t err;
     struct MmcCmd cmd = {0};
     
     if (stopStatus == NULL) {
@@ -414,7 +401,7 @@ int32_t MmcStopTransmission(struct MmcCntlr *cntlr, bool writeFlag, uint32_t *st
     } else {
         cmd.respType = MMC_RESP_R1 | MMC_CMD_TYPE_AC;
     }
-    err = MmcSendCmd(cntlr, &cmd, NULL, STOP_TRANSMISSION_CMD_RETRY_TIMES);
+    int32_t err = MmcSendCmd(cntlr, &cmd, NULL, STOP_TRANSMISSION_CMD_RETRY_TIMES);
     if (err != HDF_SUCCESS) {
         return err;
     }
@@ -562,14 +549,13 @@ static int32_t MmcSendEraseCmd(struct MmcCntlr *cntlr, uint32_t arg)
 static int32_t MmcAlignEraseSize(struct MmcCntlr *cntlr, uint32_t *start, uint32_t *end, uint32_t size)
 {
     uint32_t curSize = size;
-    uint32_t tmp;
 
     if (cntlr->curDev->eraseSize == 0) {
         return HDF_ERR_NOT_SUPPORT;
     }
 
     /* align start. */
-    tmp = (*start) % cntlr->curDev->eraseSize;
+    uint32_t tmp = (*start) % cntlr->curDev->eraseSize;
     if (tmp > 0) {
         tmp = cntlr->curDev->eraseSize - tmp;
         (*start) += tmp;
@@ -595,7 +581,6 @@ static int32_t MmcAlignEraseSize(struct MmcCntlr *cntlr, uint32_t *start, uint32
 
 int32_t MmcSendErase(struct MmcCntlr *cntlr, uint32_t startSec, uint32_t nSec)
 {
-    int32_t ret;
     uint32_t start = startSec;
     uint32_t end = start + nSec;
 
@@ -609,7 +594,7 @@ int32_t MmcSendErase(struct MmcCntlr *cntlr, uint32_t startSec, uint32_t nSec)
         return HDF_ERR_NOT_SUPPORT;
     }
 
-    ret = MmcAlignEraseSize(cntlr, &start, &end, nSec);
+    int32_t ret = MmcAlignEraseSize(cntlr, &start, &end, nSec);
     if (ret != HDF_SUCCESS) {
         /* after align, no need to erase. */
         return HDF_SUCCESS;
@@ -696,8 +681,6 @@ int32_t MmcSendReadWriteBlocks(struct MmcCntlr *cntlr, struct MmcRwData *info)
 static int32_t EmmcDecodeCsd(struct MmcCntlr *cntlr)
 {
     struct MmcCsd *csd = NULL;
-    uint32_t unit;
-    uint32_t factor;
     uint32_t *rawCsd = NULL;
 
     if (cntlr == NULL || cntlr->curDev == NULL) {
@@ -718,8 +701,8 @@ static int32_t EmmcDecodeCsd(struct MmcCntlr *cntlr)
     /* SPEC_VERS: [125:122]. */
     csd->specVers = MmcParseBits(rawCsd, CSD_BITS, 122, 4);
     /* TAAC: [119:112]; TAAC bit position-->Time unit: [2:0], Multiplier factor: [6:3]. */
-    factor = MmcParseBits(rawCsd, CSD_BITS, 115, 4);
-    unit = MmcParseBits(rawCsd, CSD_BITS, 112, 3);
+    uint32_t factor = MmcParseBits(rawCsd, CSD_BITS, 115, 4);
+    uint32_t unit = MmcParseBits(rawCsd, CSD_BITS, 112, 3);
     csd->taccNs = (g_taccUnit[unit] * g_commFactor[factor] + 9) / 10;
     /* NSAC: [111:104] */
     csd->taccClks = MmcParseBits(rawCsd, CSD_BITS, 104, 8) * 100;
@@ -771,8 +754,6 @@ static int32_t EmmcDecodeCid(struct MmcCntlr *cntlr)
     uint32_t i;
     struct MmcCid *cid = NULL;
     uint32_t *rawCid = NULL;
-    uint8_t specVers;
-    uint8_t cbx;
 
     if (cntlr == NULL || cntlr->curDev == NULL) {
         HDF_LOGE("EmmcDecodeCid: cntlr or curDev is null!");
@@ -781,7 +762,7 @@ static int32_t EmmcDecodeCid(struct MmcCntlr *cntlr)
 
     rawCid = cntlr->curDev->reg.rawCid;
     cid = &(cntlr->curDev->reg.cid);
-    specVers = cntlr->curDev->reg.csd.specVers;
+    uint8_t specVers = cntlr->curDev->reg.csd.specVers;
     if (specVers > MMC_CSD_SPEC_VER_4) {
         HDF_LOGE("EmmcDecodeCid: specVers is invalid!");
         return HDF_ERR_NOT_SUPPORT;
@@ -820,7 +801,7 @@ static int32_t EmmcDecodeCid(struct MmcCntlr *cntlr)
          * Card or BGA(CBX): [113:112]
          * 00: Card (removable); 01: BGA (Discrete embedded); 10: POP; 11: Reserved.
          */
-        cbx = MmcParseBits(rawCid, CID_BITS, 112, 2);
+        uint8_t cbx = MmcParseBits(rawCid, CID_BITS, 112, 2);
         if (cbx == 0) {
             cntlr->curDev->state.bits.removable = 1;
             HDF_LOGD("EmmcDecodeCid: Emmc is removable!");
@@ -1038,8 +1019,6 @@ static int32_t EmmcDecodeExtCsd(struct MmcCntlr *cntlr, uint8_t *rawExtCsd, uint
 static void EmmcSetBlockCapacity(struct MmcCntlr *cntlr)
 {
     struct EmmcDevice *emmcDev = (struct EmmcDevice *)cntlr->curDev;
-    uint32_t gibVal;
-    uint32_t mibVal;
 
     /*
      * ERASE_GROUP_DEF  Bit0: ENABLE:
@@ -1060,8 +1039,8 @@ static void EmmcSetBlockCapacity(struct MmcCntlr *cntlr)
             (emmcDev->mmc.reg.csd.readBlkLen - MMC_MAX_BLOCKSIZE_SHIFT);
     }
 
-    gibVal = emmcDev->mmc.capacity >> 21;
-    mibVal = (emmcDev->mmc.capacity & ~(gibVal << 21)) >> 11;
+    uint32_t gibVal = emmcDev->mmc.capacity >> 21;
+    uint32_t mibVal = (emmcDev->mmc.capacity & ~(gibVal << 21)) >> 11;
     HDF_LOGD("EmmcSetBlockCapacity: Emmc dev capacity %u.%u Gib!", gibVal, mibVal);
 }
 
@@ -1122,10 +1101,9 @@ static int32_t EmmcSelectHighSpeedBusWidth(struct MmcCntlr *cntlr)
 
 static int32_t EmmcCheckSwitchStatus(struct MmcCntlr *cntlr)
 {
-    int err;
     uint32_t status;
 
-    err = MmcSendStatus(cntlr, &status);
+    int err = MmcSendStatus(cntlr, &status);
     if (err != HDF_SUCCESS) {
         HDF_LOGE("EmmcCheckSwitchStatus: send status cmd fail!");
         return err;
@@ -1138,13 +1116,11 @@ static int32_t EmmcCheckSwitchStatus(struct MmcCntlr *cntlr)
 
 static int32_t EmmcSwitchHighSpeed(struct MmcCntlr *cntlr)
 {
-    int err;
-
     /*
      * Switch dev to HS mode.
      * HS_TIMING must be set to "0x1" before setting BUS_WIDTH for dual data rate operation (values 5 or 6).
      */
-    err = MmcSwitch(cntlr, EMMC_EXT_CSD_CMD_SET_NORMAL, EMMC_EXT_CSD_HS_TIMING, EMMC_EXT_CSD_BUS_TIMING_HS);
+    int err = MmcSwitch(cntlr, EMMC_EXT_CSD_CMD_SET_NORMAL, EMMC_EXT_CSD_HS_TIMING, EMMC_EXT_CSD_BUS_TIMING_HS);
     if (err != HDF_SUCCESS) {
         HDF_LOGE("EmmcSwitchHighSpeed: switch hs fail!");
         return err;
@@ -1158,9 +1134,7 @@ static int32_t EmmcSwitchHighSpeed(struct MmcCntlr *cntlr)
 
 static int32_t EmmcSelectHs400(struct MmcCntlr *cntlr)
 {
-    int err;
-
-    err = EmmcSwitchHighSpeed(cntlr);
+    int err = EmmcSwitchHighSpeed(cntlr);
     if (err != HDF_SUCCESS) {
         HDF_LOGE("EmmcSelectHs400: switch hs fail!");
         return err;
@@ -1186,9 +1160,7 @@ static int32_t EmmcSelectHs400(struct MmcCntlr *cntlr)
 
 static int32_t EmmcSelectHs400es(struct MmcCntlr *cntlr, struct EmmcDevice *emmcDev)
 {
-    int err;
-
-    err = EmmcSwitchVoltage(cntlr, emmcDev);
+    int err = EmmcSwitchVoltage(cntlr, emmcDev);
     if (err != HDF_SUCCESS) {
         HDF_LOGE("EmmcSelectHs400es: emmc switch voltage fail!");
         return err;
@@ -1228,9 +1200,7 @@ static int32_t EmmcSelectHs400es(struct MmcCntlr *cntlr, struct EmmcDevice *emmc
 
 static int32_t EmmcSelectHs200(struct MmcCntlr *cntlr, struct EmmcDevice *emmcDev)
 {
-    int err;
-
-    err = EmmcSwitchVoltage(cntlr, emmcDev);
+    int err = EmmcSwitchVoltage(cntlr, emmcDev);
     if (err != HDF_SUCCESS) {
         HDF_LOGE("EmmcSelectHs200: emmc switch voltage fail!");
         return err;
@@ -1255,14 +1225,11 @@ static int32_t EmmcSelectHs200(struct MmcCntlr *cntlr, struct EmmcDevice *emmcDe
 static uint32_t EmmcGetPowerClassValue(struct MmcCntlr *cntlr, struct EmmcExtCsd *extCsd)
 {
     uint32_t val = 0;
-    uint32_t vdd;
-    uint32_t busWidthBit;
-    uint32_t clock;
 
-    busWidthBit = (cntlr->curDev->workPara.width == BUS_WIDTH8) ?
+    uint32_t busWidthBit = (cntlr->curDev->workPara.width == BUS_WIDTH8) ?
         EMMC_EXT_CSD_BUS_WIDTH_8 : EMMC_EXT_CSD_BUS_WIDTH_4;
-    vdd = 1 << (cntlr->vddBit);
-    clock = cntlr->curDev->workPara.clock;
+    uint32_t vdd = 1 << (cntlr->vddBit);
+    uint32_t clock = cntlr->curDev->workPara.clock;
 
     if (vdd == MMC_OCR_1V65_1V95) {
         if (clock <= EMMC_EXT_CSD_HIGH_SPEED_26) {
@@ -1295,13 +1262,12 @@ static uint32_t EmmcGetPowerClassValue(struct MmcCntlr *cntlr, struct EmmcExtCsd
 static int32_t EmmcSelectPowerClass(struct MmcCntlr *cntlr, struct EmmcExtCsd *extCsd)
 {
     int32_t error = 0;
-    uint32_t val;
 
     if (cntlr->curDev->reg.csd.specVers < MMC_CSD_SPEC_VER_4) {
         return HDF_SUCCESS;
     }
 
-    val = EmmcGetPowerClassValue(cntlr, extCsd);
+    uint32_t val = EmmcGetPowerClassValue(cntlr, extCsd);
     if (val > 0) {
         error = MmcSwitch(cntlr, EMMC_EXT_CSD_CMD_SET_NORMAL, EMMC_EXT_CSD_POWER_CLASS, val);
     }
@@ -1311,10 +1277,8 @@ static int32_t EmmcSelectPowerClass(struct MmcCntlr *cntlr, struct EmmcExtCsd *e
 static int32_t EmmcSelectActivateHighSpeed(struct MmcCntlr *cntlr,
     struct EmmcDevice *emmcDev, struct EmmcExtCsd *extCsd)
 {
-    int32_t error;
-
     if (extCsd->hsMaxDtr > 0) {
-        error = HDF_SUCCESS;
+        int32_t error = HDF_SUCCESS;
         if (MmcCntlrSupportHighSpeed200(cntlr) == true &&
             extCsd->hsMaxDtr > EMMC_EXT_CSD_HIGH_SPEED_52) {
             error = EmmcSelectHs200(cntlr, emmcDev);
@@ -1416,9 +1380,7 @@ static uint32_t EmmcGetDdrMode(struct MmcCntlr *cntlr, struct EmmcDevice *emmcDe
 static int32_t EmmcSwitchDdrMode(struct MmcCntlr *cntlr, uint32_t ddrMode,
     enum MmcBusWidth width, uint32_t widthBit)
 {
-    int32_t error;
-
-    error = MmcSwitch(cntlr, EMMC_EXT_CSD_CMD_SET_NORMAL, EMMC_EXT_CSD_BUS_WIDTH, widthBit);
+    int32_t error = MmcSwitch(cntlr, EMMC_EXT_CSD_CMD_SET_NORMAL, EMMC_EXT_CSD_BUS_WIDTH, widthBit);
     if (error != HDF_SUCCESS) {
         HDF_LOGE("EmmcSwitchDdrMode: switch BUS_WIDTH fail!");
         return error;
@@ -1441,8 +1403,6 @@ static int32_t EmmcSelectSwitchDdrMode(struct MmcCntlr *cntlr, struct EmmcDevice
     struct EmmcExtCsd *extCsd)
 {
     int32_t error;
-    uint32_t index;
-    uint32_t ddrMode;
     enum MmcBusWidth width;
     const enum MmcBusWidth busWidths[] = { BUS_WIDTH8, BUS_WIDTH4, BUS_WIDTH1 };
     uint32_t busWidthBit[][2] = {
@@ -1451,13 +1411,13 @@ static int32_t EmmcSelectSwitchDdrMode(struct MmcCntlr *cntlr, struct EmmcDevice
         { EMMC_EXT_CSD_BUS_WIDTH_1, EMMC_EXT_CSD_BUS_WIDTH_1 },
     };
 
-    ddrMode = EmmcGetDdrMode(cntlr, emmcDev, extCsd);
+    uint32_t ddrMode = EmmcGetDdrMode(cntlr, emmcDev, extCsd);
     if (emmcDev->mmc.state.bits.hs400es == 0 &&
         emmcDev->mmc.state.bits.hs400 == 0 &&
         emmcDev->mmc.state.bits.hs200 == 0 &&
         cntlr->curDev->reg.csd.specVers >= MMC_CSD_SPEC_VER_4 &&
         (cntlr->caps.bits.cap4Bit | cntlr->caps.bits.cap8Bit) > 0) {
-        index = 1;
+        uint32_t index = 1;
         if (cntlr->caps.bits.cap8Bit > 0) {
             index = 0;
         }
@@ -1491,10 +1451,8 @@ static int32_t EmmcSelectSwitchDdrMode(struct MmcCntlr *cntlr, struct EmmcDevice
 
 static int32_t EmmcActivateHpiMechanism(struct MmcCntlr *cntlr, struct EmmcExtCsd *extCsd)
 {
-    int32_t error;
-
     if (extCsd->hpi == true) {
-        error = MmcSwitch(cntlr, EMMC_EXT_CSD_CMD_SET_NORMAL, EMMC_EXT_CSD_HPI_MGMT, 1);
+        int32_t error = MmcSwitch(cntlr, EMMC_EXT_CSD_CMD_SET_NORMAL, EMMC_EXT_CSD_HPI_MGMT, 1);
         if (error == HDF_SUCCESS) {
             extCsd->hpiEnable = true;
         } else if (error != HDF_MMC_ERR_SWITCH_FAIL) {
@@ -1548,13 +1506,12 @@ static int32_t EmmcSwitchOperationMode(struct MmcCntlr *cntlr)
 static int32_t EmmcReadExtCsd(struct MmcCntlr *cntlr)
 {
     uint8_t extCsd[EXT_CSD_BYTES_LEN] = {0};
-    int32_t error;
 
     if (cntlr->curDev->reg.csd.specVers < MMC_CSD_SPEC_VER_4) {
         return HDF_SUCCESS;
     }
 
-    error = MmcSendExtCsd(cntlr, extCsd, EXT_CSD_BYTES_LEN);
+    int32_t error = MmcSendExtCsd(cntlr, extCsd, EXT_CSD_BYTES_LEN);
     if (error != HDF_SUCCESS) {
         HDF_LOGE("EmmcReadExtCsd: send cmd8 fail, error = %d.", error);
         return error;
@@ -1571,12 +1528,11 @@ static int32_t EmmcReadExtCsd(struct MmcCntlr *cntlr)
 static int32_t EmmcSelect(struct MmcCntlr *cntlr, union MmcOcr ocr)
 {
     union MmcOcr curOcr;
-    int32_t error;
 
     MmcGoIdleState(cntlr);
     ocr.bits.hcs = 1;
     /* set dev work voltage. */
-    error = MmcSendOpCond(cntlr, ocr.ocrData, &curOcr.ocrData);
+    int32_t error = MmcSendOpCond(cntlr, ocr.ocrData, &curOcr.ocrData);
     if (error != HDF_SUCCESS) {
         HDF_LOGE("EmmcSelect: Emmc cmd1(set voltage) fail, error = %d.", error);
         return error;
@@ -1639,11 +1595,10 @@ static int32_t EmmcDeviceAdd(struct MmcCntlr *cntlr)
 
 static int32_t EmmcInit(struct MmcCntlr *cntlr)
 {
-    int32_t error;
     union MmcOcr ocr = {0};
 
     /* cmd1, detect emmc dev and get the voltage range. */
-    error = MmcSendOpCond(cntlr, 0, &(ocr.ocrData));
+    int32_t error = MmcSendOpCond(cntlr, 0, &(ocr.ocrData));
     if (error != HDF_SUCCESS) {
         HDF_LOGE("EmmcInit: cmd1(detect emmc) fail, error = %d.", error);
         return error;
@@ -1671,11 +1626,9 @@ static int32_t EmmcInit(struct MmcCntlr *cntlr)
 
 static int32_t EmmcDetect(struct MmcCntlr *cntlr)
 {
-    int32_t ret;
-
     HDF_LOGD("EmmcDetect: Detect emmc dev start...");
     MmcGoIdleState(cntlr);
-    ret = EmmcInit(cntlr);
+    int32_t ret = EmmcInit(cntlr);
     if (ret == HDF_SUCCESS) {
         HDF_LOGD("EmmcDetect: Detect emmc dev success! %s dev at address 0x%x!",
             cntlr->curDev->state.bits.uhs ? "Ultra high speed" :
@@ -1755,7 +1708,6 @@ static int32_t SdAcmdSdStatus(struct MmcCntlr *cntlr, uint32_t *ssr, uint32_t le
 {
     struct MmcCmd cmd = {0};
     struct MmcData data = {0};
-    int32_t error;
     uint32_t i;
 
     if (cntlr == NULL || ssr == NULL || len == 0) {
@@ -1772,7 +1724,7 @@ static int32_t SdAcmdSdStatus(struct MmcCntlr *cntlr, uint32_t *ssr, uint32_t le
     data.blockNum = 1;
     data.dataFlags = DATA_READ;
     data.dataBuffer = (uint8_t *)ssr;
-    error = SdSendAppCmd(cntlr, &cmd, &data, 1);
+    int32_t error = SdSendAppCmd(cntlr, &cmd, &data, 1);
     if (error != HDF_SUCCESS) {
         return error;
     }
@@ -1786,7 +1738,6 @@ static int32_t SdAppSendScr(struct MmcCntlr *cntlr, uint32_t *scr, uint32_t len)
 {
     struct MmcCmd cmd = {0};
     struct MmcData data = {0};
-    int32_t error;
     uint32_t i;
 
     if (cntlr == NULL || scr == NULL || len == 0) {
@@ -1803,7 +1754,7 @@ static int32_t SdAppSendScr(struct MmcCntlr *cntlr, uint32_t *scr, uint32_t len)
     data.blockNum = 1;
     data.dataFlags = DATA_READ;
     data.dataBuffer = (uint8_t *)scr;
-    error = SdSendAppCmd(cntlr, &cmd, &data, 1);
+    int32_t error = SdSendAppCmd(cntlr, &cmd, &data, 1);
     if (error != HDF_SUCCESS) {
         return error;
     }
@@ -1829,19 +1780,17 @@ static int32_t SdAcmdSetBusWidth(struct MmcCntlr *cntlr, uint32_t width)
 static int32_t SdCmdSendIfCond(struct MmcCntlr *cntlr, uint32_t ocr)
 {
     struct MmcCmd cmd = {0};
-    int32_t err;
-    uint32_t vhs;
 
     cmd.cmdCode = SD_CMD_SEND_IF_COND;
     /*
      * [31:12]reserved bits, [11:8]supply voltage(VHS), [7:0]check pattern.
      * VHS = 0001, 2.7-3.6V.
      */
-    vhs = ((ocr & 0xFF8000U) > 0) ? 1 : 0;
+    uint32_t vhs = ((ocr & 0xFF8000U) > 0) ? 1 : 0;
     cmd.argument = (vhs << 8) | 0xAA;
     cmd.respType = MMC_RESP_SPI_R7 | MMC_RESP_R7 | MMC_CMD_TYPE_BCR;
 
-    err = MmcSendCmd(cntlr, &cmd, NULL, 1);
+    int32_t err = MmcSendCmd(cntlr, &cmd, NULL, 1);
     if (err != HDF_SUCCESS) {
         return err;
     }
@@ -1858,14 +1807,13 @@ static int32_t SdCmdSendIfCond(struct MmcCntlr *cntlr, uint32_t ocr)
 
 static int32_t SdCmdSendRelativeAddr(struct MmcCntlr *cntlr, uint32_t *rca)
 {
-    int32_t error;
     struct MmcCmd cmd = {0};
 
     cmd.cmdCode = SD_CMD_SEND_RELATIVE_ADDR;
     /* [31:0] stuff bits. */
     cmd.argument = 0;
     cmd.respType = MMC_RESP_R6 | MMC_CMD_TYPE_BCR;
-    error = MmcSendCmd(cntlr, &cmd, NULL, MMC_CMD_DEFAULT_RETRY_TIMES);
+    int32_t error = MmcSendCmd(cntlr, &cmd, NULL, MMC_CMD_DEFAULT_RETRY_TIMES);
     if (error != HDF_SUCCESS) {
         return error;
     }
@@ -1878,7 +1826,6 @@ static int32_t SdCmdSendRelativeAddr(struct MmcCntlr *cntlr, uint32_t *rca)
 
 static int32_t SdCmdSwitchVoltage(struct MmcCntlr *cntlr)
 {
-    int32_t error;
     struct MmcCmd cmd = {0};
 
     /* Voltage switch command to change signaling level 3.3V to 1.8V. */
@@ -1886,7 +1833,7 @@ static int32_t SdCmdSwitchVoltage(struct MmcCntlr *cntlr)
     /* [31:0] stuff bits. */
     cmd.argument = 0;
     cmd.respType = MMC_RESP_R1 | MMC_CMD_TYPE_AC;
-    error = MmcSendCmd(cntlr, &cmd, NULL, 1);
+    int32_t error = MmcSendCmd(cntlr, &cmd, NULL, 1);
     if (error != HDF_SUCCESS) {
         return error;
     }
@@ -1935,7 +1882,6 @@ static int32_t SdDecodeScr(struct MmcCntlr *cntlr)
     struct SdScr *scr = NULL;
     uint32_t *rawScr = NULL;
     struct SdDevice *sdDev = NULL;
-    uint32_t scrStruct;
 
     if (cntlr == NULL || cntlr->curDev == NULL) {
         HDF_LOGE("SdDecodeScr: cntlr or curDev is null!");
@@ -1950,7 +1896,7 @@ static int32_t SdDecodeScr(struct MmcCntlr *cntlr)
      * SCR_STRUCTURE: [63:60];
      * SCR_STRUCTURE equal 0, SCR version 1.0; SCR_STRUCTURE equal 1-15, reserved.
      */
-    scrStruct = (uint8_t)MmcParseBits(rawScr, SCR_BITS, 60, 4);
+    uint32_t scrStruct = (uint8_t)MmcParseBits(rawScr, SCR_BITS, 60, 4);
     if (scrStruct != 0) {
         HDF_LOGE("SdDecodeScr: scrStruct is invalid!");
         return HDF_ERR_INVALID_PARAM;
@@ -1980,8 +1926,6 @@ static int32_t SdDecodeSSr(struct MmcCntlr *cntlr, uint32_t *rawSsr, uint32_t le
     struct SdSsr *ssr = NULL;
     struct SdScr *scr = NULL;
     struct SdDevice *sdDev = NULL;
-    uint32_t eraseSize;
-    uint32_t eraseTimeout;
 
     if (cntlr == NULL || cntlr->curDev == NULL || rawSsr == NULL || len == 0) {
         HDF_LOGE("SdDecodeSSr: cntlr or curDev or rawSsr is null or len is invalid!");
@@ -2002,9 +1946,9 @@ static int32_t SdDecodeSSr(struct MmcCntlr *cntlr, uint32_t *rawSsr, uint32_t le
              * ERASE_SIZE: [423:408]. If this field is set to 0, the erase timeout calculation is not supported.
              * ERASE_SIZE = 1, value = 1AU; ERASE_SIZE = 2, value = 2AU...
              */
-            eraseSize = MmcParseBits(rawSsr, SSR_BITS, 408, 16);
+            uint32_t eraseSize = MmcParseBits(rawSsr, SSR_BITS, 408, 16);
             /* ERASE_TIMEOUT: [407:402] */
-            eraseTimeout = MmcParseBits(rawSsr, SSR_BITS, 402, 6);
+            uint32_t eraseTimeout = MmcParseBits(rawSsr, SSR_BITS, 402, 6);
             if (eraseSize > 0) {
                 ssr->eraseTimeout = (eraseTimeout * 1000) / eraseSize;
                 /* ERASE_OFFSET: [401:400] */
@@ -2064,26 +2008,21 @@ static void SdDecodeCid(struct MmcCntlr *cntlr)
 static void SdSetBlockCapacity(struct MmcCntlr *cntlr)
 {
     struct SdDevice *sdDev = (struct SdDevice *)cntlr->curDev;
-    uint32_t gibVal;
-    uint32_t mibVal;
 
     sdDev->mmc.eraseSize = sdDev->mmc.reg.csd.eraseSize;
     sdDev->mmc.capacity = sdDev->mmc.reg.csd.capacity <<
         (sdDev->mmc.reg.csd.readBlkLen - MMC_MAX_BLOCKSIZE_SHIFT);
 
-    gibVal = sdDev->mmc.capacity >> 21;
-    mibVal = (sdDev->mmc.capacity & ~(gibVal << 21)) >> 11;
+    uint32_t gibVal = sdDev->mmc.capacity >> 21;
+    uint32_t mibVal = (sdDev->mmc.capacity & ~(gibVal << 21)) >> 11;
     HDF_LOGD("SdSetBlockCapacity: SD dev capacity %d.%d Gib", gibVal, mibVal);
 }
 
 static void SdDecodeCsdRev1Field(struct MmcCntlr *cntlr, struct MmcCsd *csd, uint32_t *rawCsd)
 {
-    uint32_t unit;
-    uint32_t factor;
-
     /* TAAC: [119:112]; TAAC bit position-->Time unit: [2:0], Multiplier factor: [6:3]. */
-    factor = MmcParseBits(rawCsd, CSD_BITS, 115, 4);
-    unit = MmcParseBits(rawCsd, CSD_BITS, 112, 3);
+    uint32_t factor = MmcParseBits(rawCsd, CSD_BITS, 115, 4);
+    uint32_t unit = MmcParseBits(rawCsd, CSD_BITS, 112, 3);
     csd->taccNs = (g_taccUnit[unit] * g_commFactor[factor] + 9) / 10;
     /* NSAC: [111:104], the unit for NSAC is 100 clock cycles */
     csd->taccClks = MmcParseBits(rawCsd, CSD_BITS, 104, 8) * 100;
@@ -2133,13 +2072,10 @@ static void SdDecodeCsdRev1Field(struct MmcCntlr *cntlr, struct MmcCsd *csd, uin
 
 static void SdDecodeCsdRev2Field(struct MmcCntlr *cntlr, struct MmcCsd *csd, uint32_t *rawCsd)
 {
-    uint32_t unit;
-    uint32_t factor;
-
     cntlr->curDev->state.bits.blockAddr = 1;
     /* TRAN_SPEED: [103:96]; TRAN_SPEED bit-->Frequency unit: [2:0], Multiplier factor: [6:3]. */
-    factor = MmcParseBits(rawCsd, CSD_BITS, 99, 4);
-    unit = MmcParseBits(rawCsd, CSD_BITS, 96, 3);
+    uint32_t factor = MmcParseBits(rawCsd, CSD_BITS, 99, 4);
+    uint32_t unit = MmcParseBits(rawCsd, CSD_BITS, 96, 3);
     csd->maxDtr = g_tranSpeedUnit[unit] * g_commFactor[factor];
     /* card command classes: [95:84] */
     csd->ccc = MmcParseBits(rawCsd, CSD_BITS, 84, 12);
@@ -2277,9 +2213,7 @@ static int32_t SdSelect(struct MmcCntlr *cntlr, uint32_t *rocr)
 
 static int32_t SdReadCsd(struct MmcCntlr *cntlr)
 {
-    int32_t error;
-
-    error = MmcSendCsd(cntlr);
+    int32_t error = MmcSendCsd(cntlr);
     if (error != HDF_SUCCESS) {
         HDF_LOGE("SdReadCsd: cmd9 fail, error = %d.", error);
         return error;
@@ -2289,10 +2223,9 @@ static int32_t SdReadCsd(struct MmcCntlr *cntlr)
 
 static int32_t SdReadScr(struct MmcCntlr *cntlr)
 {
-    int32_t error;
     struct SdDevice *dev = (struct SdDevice *)cntlr->curDev;
 
-    error = SdAppSendScr(cntlr, dev->reg.rawScr, SCR_LEN);
+    int32_t error = SdAppSendScr(cntlr, dev->reg.rawScr, SCR_LEN);
     if (error != HDF_SUCCESS) {
         HDF_LOGE("SdReadScr: acmd51 fail, error = %d.", error);
         return error;
@@ -2302,7 +2235,6 @@ static int32_t SdReadScr(struct MmcCntlr *cntlr)
 
 static int32_t SdReadSsr(struct MmcCntlr *cntlr)
 {
-    int32_t err;
     uint32_t rawSsr[SSR_LEN] = {0};
 
     /* don't support ACMD. */
@@ -2310,7 +2242,7 @@ static int32_t SdReadSsr(struct MmcCntlr *cntlr)
         return HDF_SUCCESS;
     }
 
-    err = SdAcmdSdStatus(cntlr, rawSsr, SSR_LEN);
+    int32_t err = SdAcmdSdStatus(cntlr, rawSsr, SSR_LEN);
     if (err != HDF_SUCCESS) {
         HDF_LOGE("SdReadSsr: acmd13 fail, err = %d.", err);
         return err;
@@ -2320,7 +2252,6 @@ static int32_t SdReadSsr(struct MmcCntlr *cntlr)
 
 static int32_t SdReadSwitchCapbility(struct MmcCntlr *cntlr)
 {
-    int32_t err;
     uint8_t status[SD_SWITCH_FUNCTION_STATUS_BYTES_LEN] = {0};
     struct SdDevice *dev = (struct SdDevice *)cntlr->curDev;
     struct SdSwitchFuncParam param = {0};
@@ -2336,7 +2267,7 @@ static int32_t SdReadSwitchCapbility(struct MmcCntlr *cntlr)
     param.group = SD_SWITCH_FUNC_GROUP_1;
     param.value = 1;
     /* The data(status) is in reverse order relative to the protocol. */
-    err = SdCmdSwitchFunc(cntlr, &param, status, SD_SWITCH_FUNCTION_STATUS_BYTES_LEN);
+    int32_t err = SdCmdSwitchFunc(cntlr, &param, status, SD_SWITCH_FUNCTION_STATUS_BYTES_LEN);
     if (err != HDF_SUCCESS) {
         HDF_LOGE("SdReadSwitchCapbility: swutch func group 1 fail, err = %d.", err);
         return err;
@@ -2397,10 +2328,8 @@ static void SdFillBusSpeedMode(struct MmcCntlr *cntlr)
 
 static int32_t SdReadRegisters(struct MmcCntlr *cntlr)
 {
-    int32_t error;
-
     /* get SCR */
-    error = SdReadScr(cntlr);
+    int32_t error = SdReadScr(cntlr);
     if (error != HDF_SUCCESS) {
         return error;
     }
@@ -2456,10 +2385,8 @@ static uint32_t SdGetDevMaxCurrentLimitValue(enum SdMaxCurrentLimitBit devCap)
 
 static uint32_t SdGetMaxCurrentLimitValue(union MmcCaps *hostCap, enum SdMaxCurrentLimitBit devCap)
 {
-    uint32_t currentLimit;
-
     /* get max support by dev. */
-    currentLimit = SdGetDevMaxCurrentLimitValue(devCap);
+    uint32_t currentLimit = SdGetDevMaxCurrentLimitValue(devCap);
     if (hostCap->bits.maxCurrentLimit800 == 1) {
         currentLimit = ((currentLimit < SD_MAX_CURRENT_LIMIT_800_VALUE) ?
             currentLimit : SD_MAX_CURRENT_LIMIT_800_VALUE);
@@ -2482,7 +2409,6 @@ static int32_t SdSetMaxCurrentLimit(struct MmcCntlr *cntlr)
     uint8_t status[SD_SWITCH_FUNCTION_STATUS_BYTES_LEN] = {0};
     struct SdSwitchFuncParam param = {0};
     uint32_t currentLimit;
-    int32_t err;
 
     if ((dev->busSpeedMode == SD_BUS_SPEED_MODE_UHS_SDR104) ||
         (dev->busSpeedMode == SD_BUS_SPEED_MODE_UHS_DDR50) ||
@@ -2496,7 +2422,7 @@ static int32_t SdSetMaxCurrentLimit(struct MmcCntlr *cntlr)
     param.group = SD_SWITCH_FUNC_GROUP_4;
     param.value = currentLimit;
     /* Current Limit is selected by CMD6 Function Group 4. */
-    err = SdCmdSwitchFunc(cntlr, &param, status, SD_SWITCH_FUNCTION_STATUS_BYTES_LEN);
+    int32_t err = SdCmdSwitchFunc(cntlr, &param, status, SD_SWITCH_FUNCTION_STATUS_BYTES_LEN);
     if (err != HDF_SUCCESS) {
         HDF_LOGE("SdSetMaxCurrentLimit: swutch func group 3 fail!");
         return err;
@@ -2513,7 +2439,6 @@ static int32_t SdSetBusSpeedMode(struct MmcCntlr *cntlr)
     struct SdDevice *dev = (struct SdDevice *)cntlr->curDev;
     uint8_t status[SD_SWITCH_FUNCTION_STATUS_BYTES_LEN] = {0};
     struct SdSwitchFuncParam param = {0};
-    int32_t err;
     enum MmcBusTiming timing;
 
     switch (dev->busSpeedMode) {
@@ -2544,7 +2469,7 @@ static int32_t SdSetBusSpeedMode(struct MmcCntlr *cntlr)
     param.mode = SD_SWITCH_FUNC_MODE_SET;
     param.group = SD_SWITCH_FUNC_GROUP_1;
     param.value = dev->busSpeedMode;
-    err = SdCmdSwitchFunc(cntlr, &param, status, SD_SWITCH_FUNCTION_STATUS_BYTES_LEN);
+    int32_t err = SdCmdSwitchFunc(cntlr, &param, status, SD_SWITCH_FUNCTION_STATUS_BYTES_LEN);
     if (err != HDF_SUCCESS) {
         HDF_LOGE("SdSetBusSpeedMode: swutch func group 1 fail!");
         return err;
@@ -2578,7 +2503,6 @@ static int32_t SdSwitch4BitBusWidth(struct MmcCntlr *cntlr, struct SdDevice *dev
 
 static int32_t SdUltraHighSpeedDevInit(struct MmcCntlr *cntlr)
 {
-    int32_t err;
     struct SdDevice *dev = (struct SdDevice *)cntlr->curDev;
 
     if (dev->reg.scr.sdSpec3 == 0) {
@@ -2588,7 +2512,7 @@ static int32_t SdUltraHighSpeedDevInit(struct MmcCntlr *cntlr)
         return HDF_SUCCESS;
     }
 
-    err = SdSwitch4BitBusWidth(cntlr, dev);
+    int32_t err = SdSwitch4BitBusWidth(cntlr, dev);
     if (err != HDF_SUCCESS) {
         return err;
     }
@@ -2605,7 +2529,6 @@ static int32_t SdUltraHighSpeedDevInit(struct MmcCntlr *cntlr)
 
 static int32_t SdSwitchHighSpeed(struct MmcCntlr *cntlr)
 {
-    int32_t err;
     struct SdDevice *dev = (struct SdDevice *)cntlr->curDev;
     uint8_t status[SD_SWITCH_FUNCTION_STATUS_BYTES_LEN] = {0};
     struct SdSwitchFuncParam param = {0};
@@ -2626,7 +2549,7 @@ static int32_t SdSwitchHighSpeed(struct MmcCntlr *cntlr)
     param.mode = SD_SWITCH_FUNC_MODE_SET;
     param.group = SD_SWITCH_FUNC_GROUP_1;
     param.value = SD_BUS_SPEED_MODE_HS;
-    err = SdCmdSwitchFunc(cntlr, &param, status, SD_SWITCH_FUNCTION_STATUS_BYTES_LEN);
+    int32_t err = SdCmdSwitchFunc(cntlr, &param, status, SD_SWITCH_FUNCTION_STATUS_BYTES_LEN);
     if (err != HDF_SUCCESS) {
         HDF_LOGE("SdSwitchHighSpeed: switch func group 1 fail!");
         return err;
@@ -2640,10 +2563,9 @@ static int32_t SdSwitchHighSpeed(struct MmcCntlr *cntlr)
 
 static int32_t SdHighSpeedDevInit(struct MmcCntlr *cntlr)
 {
-    int err;
     struct SdDevice *sdDev = (struct SdDevice *)cntlr->curDev;
 
-    err = SdSwitchHighSpeed(cntlr);
+    int err = SdSwitchHighSpeed(cntlr);
     if (err == HDF_SUCCESS) {
         cntlr->curDev->state.bits.highSpeed = 1;
         MmcCntlrSetBusTiming(cntlr, BUS_TIMING_SD_HS);
@@ -2671,11 +2593,10 @@ static int32_t SdDeviceAdd(struct MmcCntlr *cntlr)
 
 static int32_t SdInit(struct MmcCntlr *cntlr)
 {
-    int32_t error;
     union MmcOcr ocr = {0};
 
     /* acmd41, detect sd dev and get the voltage range. dev state: idle -> ready. */
-    error = SdAcmdOpCond(cntlr, 0, &(ocr.ocrData));
+    int32_t error = SdAcmdOpCond(cntlr, 0, &(ocr.ocrData));
     if (error != HDF_SUCCESS) {
         HDF_LOGE("SdInit: acmd41(detect sd) fail, err = %d!", error);
         return error;
@@ -2734,15 +2655,13 @@ static int32_t SdInit(struct MmcCntlr *cntlr)
 
 static int32_t SdDetect(struct MmcCntlr *cntlr)
 {
-    int32_t ret;
-
     HDF_LOGD("SdDetect: Detect sd dev start...");
     /* dev state: idle. */
     MmcGoIdleState(cntlr);
     /* dev state: idle -> idle. */
     (void)SdCmdSendIfCond(cntlr, cntlr->ocrDef.ocrData);
     /* Initialize SD. */
-    ret = SdInit(cntlr);
+    int32_t ret = SdInit(cntlr);
     if (ret == HDF_SUCCESS) {
         HDF_LOGD("SdDetect: Detect sd dev success! %s dev at address 0x%x!",
             cntlr->curDev->state.bits.uhs ? "Ultra high speed" :
@@ -2812,7 +2731,6 @@ static int32_t SdioRespR5Check(struct MmcCmd *cmd)
 int32_t SdioRwDirect(struct MmcCntlr *cntlr, struct SdioCmdParam *param, uint8_t *out)
 {
     struct MmcCmd cmd = {0};
-    int32_t err;
 
     if (cntlr == NULL || param == NULL) {
         HDF_LOGE("SdioRwDirect: cntlr or param is null!");
@@ -2834,7 +2752,7 @@ int32_t SdioRwDirect(struct MmcCntlr *cntlr, struct SdioCmdParam *param, uint8_t
     /* [7:0] Write Data or Stuff Bits. */
     cmd.argument |= param->writeData;
     cmd.respType = MMC_RESP_SPI_R5 | MMC_RESP_R5 | MMC_CMD_TYPE_AC;
-    err = MmcSendCmd(cntlr, &cmd, NULL, 1);
+    int32_t err = MmcSendCmd(cntlr, &cmd, NULL, 1);
     if (err != HDF_SUCCESS) {
         return err;
     }
@@ -2855,7 +2773,6 @@ int32_t SdioRwExtended(struct MmcCntlr *cntlr, struct SdioCmdParam *param,
 {
     struct MmcCmd cmd = {0};
     struct MmcData data = {0};
-    int32_t err;
 
     if (cntlr == NULL || param == NULL) {
         HDF_LOGE("SdioRwExtended: cntlr or param is null!");
@@ -2900,7 +2817,7 @@ int32_t SdioRwExtended(struct MmcCntlr *cntlr, struct SdioCmdParam *param,
         data.scatterLen = param->scatterLen;
     }
 
-    err = MmcSendCmd(cntlr, &cmd, &data, 1);
+    int32_t err = MmcSendCmd(cntlr, &cmd, &data, 1);
     if (err != HDF_SUCCESS) {
         return err;
     }
@@ -2913,7 +2830,6 @@ static void SdioIoReset(struct MmcCntlr *cntlr)
 {
     struct SdioCmdParam param = {0};
     uint8_t out = 0;
-    int32_t error;
 
     /*
      * In order to reset an I/O only card or the I/O portion of a combo card,
@@ -2922,7 +2838,7 @@ static void SdioIoReset(struct MmcCntlr *cntlr)
      */
     param.regAddr = IO_ABORT;
     /* read register 6 of CCCR. */
-    error = SdioRwDirect(cntlr, &param, &out);
+    int32_t error = SdioRwDirect(cntlr, &param, &out);
     if (error < 0) {
         out = SDIO_CCCR_RES;
     } else {
@@ -2957,15 +2873,12 @@ int32_t SdioReadWriteByte(struct MmcCntlr *cntlr, bool writeFlag,
 static int32_t SdioReadWriteRemainBytes(struct MmcCntlr *cntlr, struct SdioCmdParam *param,
     uint8_t *data, uint32_t size, uint32_t addr)
 {
-    uint32_t maxBlkSize;
-    uint32_t curSize;
     struct SdioDevice *dev = (struct SdioDevice *)cntlr->curDev;
     uint32_t remLen = size;
     uint32_t curAddr = addr;
     uint8_t *buffer = data;
-    int32_t err;
 
-    maxBlkSize = MMC_MIN(cntlr->maxBlkSize, dev->curFunction->maxBlkSize);
+    uint32_t maxBlkSize = MMC_MIN(cntlr->maxBlkSize, dev->curFunction->maxBlkSize);
     maxBlkSize = MMC_MIN(maxBlkSize, BYTES_PER_BLOCK);
     if (maxBlkSize == 0) {
         HDF_LOGE("SdioReadWriteRemainBytes: max block size is invalid!");
@@ -2973,9 +2886,9 @@ static int32_t SdioReadWriteRemainBytes(struct MmcCntlr *cntlr, struct SdioCmdPa
     }
 
     while (remLen > 0) {
-        curSize = MMC_MIN(remLen, maxBlkSize);
+        uint32_t curSize = MMC_MIN(remLen, maxBlkSize);
         param->regAddr = curAddr;
-        err = SdioRwExtended(cntlr, param, buffer, 1, curSize);
+        int32_t err = SdioRwExtended(cntlr, param, buffer, 1, curSize);
         if (err != HDF_SUCCESS) {
             HDF_LOGD("SdioReadWriteRemainBytes: bytes mode, err = %d, addr = %d, curSize = %d!", err, addr, curSize);
             return err;
@@ -3004,10 +2917,6 @@ static void SdioFillRwExtendedCmdParam(struct SdioCmdParam *param,
 
 int32_t SdioReadWriteBlock(struct MmcCntlr *cntlr, struct SdioRwBlockInfo *info)
 {
-    uint32_t maxBlkNum;
-    uint32_t curblkNum;
-    uint32_t curSize;
-    int32_t err;
     struct SdioCmdParam param = {0};
     struct SdioDevice *dev = NULL;
 
@@ -3037,14 +2946,14 @@ int32_t SdioReadWriteBlock(struct MmcCntlr *cntlr, struct SdioRwBlockInfo *info)
     }
     /* send block. */
     if (dev->sdioReg.cccr.multiBlock > 0 && (remLen > maxBlkSize)) {
-        maxBlkNum = MMC_MIN((cntlr->maxReqSize / dev->curFunction->curBlkSize), cntlr->maxBlkNum);
+        uint32_t maxBlkNum = MMC_MIN((cntlr->maxReqSize / dev->curFunction->curBlkSize), cntlr->maxBlkNum);
         maxBlkNum = MMC_MIN(maxBlkNum, SDIO_BLOCK_TRANSFER_MAX_BLKNUM);
         while (remLen > dev->curFunction->curBlkSize) {
-            curblkNum = remLen / dev->curFunction->curBlkSize;
+            uint32_t curblkNum = remLen / dev->curFunction->curBlkSize;
             curblkNum = MMC_MIN(curblkNum, maxBlkNum);
-            curSize = curblkNum * dev->curFunction->curBlkSize;
+            uint32_t curSize = curblkNum * dev->curFunction->curBlkSize;
             param.regAddr = curAddr;
-            err = SdioRwExtended(cntlr, &param, buffer, curblkNum, dev->curFunction->curBlkSize);
+            int32_t err = SdioRwExtended(cntlr, &param, buffer, curblkNum, dev->curFunction->curBlkSize);
             if (err != HDF_SUCCESS) {
                 return err;
             }
@@ -3063,12 +2972,11 @@ int32_t SdioReadWriteBlock(struct MmcCntlr *cntlr, struct SdioRwBlockInfo *info)
 static int32_t SdioCdDisable(struct MmcCntlr *cntlr)
 {
     struct SdioCmdParam param = {0};
-    int32_t error;
     uint8_t ctrl;
 
     param.regAddr = BUS_INTERFACE_CONTROL;
     /* read register 7 of CCCR. */
-    error = SdioRwDirect(cntlr, &param, &ctrl);
+    int32_t error = SdioRwDirect(cntlr, &param, &ctrl);
     if (error != HDF_SUCCESS) {
         HDF_LOGE("SdioCdDisable: read BIC fail!");
         return error;
@@ -3086,12 +2994,11 @@ static int32_t SdioCdDisable(struct MmcCntlr *cntlr)
 static int32_t SdioReadCccrSdioRev(struct MmcCntlr *cntlr, struct SdioCccr *cccr, uint8_t *cccrRev)
 {
     struct SdioCmdParam param = {0};
-    int32_t err;
     uint8_t data;
 
     /* read register 0 of CCCR. */
     param.regAddr = CCCR_SDIO_REVISION;
-    err = SdioRwDirect(cntlr, &param, &data);
+    int32_t err = SdioRwDirect(cntlr, &param, &data);
     if (err != HDF_SUCCESS) {
         HDF_LOGE("SdioReadCccrSdioRev: read sdio rev fail!");
         return err;
@@ -3110,12 +3017,11 @@ static int32_t SdioReadCccrSdioRev(struct MmcCntlr *cntlr, struct SdioCccr *cccr
 static int32_t SdioReadCccrCapbility(struct MmcCntlr *cntlr, struct SdioCccr *cccr)
 {
     struct SdioCmdParam param = {0};
-    int32_t error;
     uint8_t cap;
 
     /* read register 8 of CCCR. */
     param.regAddr = CARD_CAPBILITY;
-    error = SdioRwDirect(cntlr, &param, &cap);
+    int32_t error = SdioRwDirect(cntlr, &param, &cap);
     if (error != HDF_SUCCESS) {
         HDF_LOGE("SdioReadCccrCapbility: read card cap fail!");
         return error;
@@ -3136,12 +3042,11 @@ static int32_t SdioReadCccrCapbility(struct MmcCntlr *cntlr, struct SdioCccr *cc
 static int32_t SdioReadCccrPowerControl(struct MmcCntlr *cntlr, struct SdioCccr *cccr)
 {
     struct SdioCmdParam param = {0};
-    int32_t error;
     uint8_t ctrl;
 
     /* read register 18 of CCCR. */
     param.regAddr = POWER_CONTROL;
-    error = SdioRwDirect(cntlr, &param, &ctrl);
+    int32_t error = SdioRwDirect(cntlr, &param, &ctrl);
     if (error != HDF_SUCCESS) {
         HDF_LOGE("SdioReadCccrPowerControl: read power control fail!");
         return error;
@@ -3156,12 +3061,11 @@ static int32_t SdioReadCccrPowerControl(struct MmcCntlr *cntlr, struct SdioCccr
 static int32_t SdioReadCccrBusSpeed(struct MmcCntlr *cntlr, struct SdioCccr *cccr)
 {
     struct SdioCmdParam param = {0};
-    int32_t error;
     uint8_t speed;
 
     /* read register 19 of CCCR. */
     param.regAddr = BUS_SPEED_SELECT;
-    error = SdioRwDirect(cntlr, &param, &speed);
+    int32_t error = SdioRwDirect(cntlr, &param, &speed);
     if (error != HDF_SUCCESS) {
         HDF_LOGE("SdioReadCccrBusSpeed: read bus speed select fail!");
         return error;
@@ -3191,7 +3095,6 @@ int32_t SdioCccrIoEnable(struct MmcCntlr *cntlr)
 {
     struct SdioCmdParam param = {0};
     struct SdioDevice *dev = NULL;
-    int32_t err;
     uint8_t data;
 
     if (cntlr == NULL) {
@@ -3206,7 +3109,7 @@ int32_t SdioCccrIoEnable(struct MmcCntlr *cntlr)
 
     /* read register 2(IOEx) of CCCR. */
     param.regAddr = IO_ENABLE;
-    err = SdioRwDirect(cntlr, &param, &data);
+    int32_t err = SdioRwDirect(cntlr, &param, &data);
     if (err != HDF_SUCCESS) {
         HDF_LOGE("SdioCccrIoEnable: read io enable fail! err = %d.", err);
         return err;
@@ -3229,7 +3132,6 @@ int32_t SdioCccrIoDisable(struct MmcCntlr *cntlr)
 {
     struct SdioCmdParam param = {0};
     struct SdioDevice *dev = NULL;
-    int32_t err;
     uint8_t data;
 
     if (cntlr == NULL) {
@@ -3244,7 +3146,7 @@ int32_t SdioCccrIoDisable(struct MmcCntlr *cntlr)
 
     /* read register 2(IOEx) of CCCR. */
     param.regAddr = IO_ENABLE;
-    err = SdioRwDirect(cntlr, &param, &data);
+    int32_t err = SdioRwDirect(cntlr, &param, &data);
     if (err != HDF_SUCCESS) {
         HDF_LOGE("SdioCccrIoDisable: read io enable fail! err = %d.", err);
         return err;
@@ -3299,7 +3201,6 @@ int32_t SdioReadCccrIntPending(struct MmcCntlr *cntlr, uint8_t *val)
 
 int32_t SdioCccrIntEnable(struct MmcCntlr *cntlr)
 {
-    int32_t err;
     uint8_t val;
     struct SdioCmdParam param = {0};
     struct SdioDevice *dev = NULL;
@@ -3316,7 +3217,7 @@ int32_t SdioCccrIntEnable(struct MmcCntlr *cntlr)
 
     /* read register 4 of CCCR. */
     param.regAddr = INT_ENABLE;
-    err = SdioRwDirect(cntlr, &param, &val);
+    int32_t err = SdioRwDirect(cntlr, &param, &val);
     if (err != HDF_SUCCESS) {
         HDF_LOGE("SdioCccrIntEnable: read int enable fail! err = %d.", err);
         return err;
@@ -3343,7 +3244,6 @@ int32_t SdioCccrIntDisable(struct MmcCntlr *cntlr)
 {
     struct SdioDevice *dev = (struct SdioDevice *)cntlr->curDev;
     struct SdioCmdParam param = {0};
-    int32_t err;
     uint8_t val;
 
     if (dev == NULL || dev->curFunction == NULL) {
@@ -3353,7 +3253,7 @@ int32_t SdioCccrIntDisable(struct MmcCntlr *cntlr)
 
     /* read register 4 of CCCR. */
     param.regAddr = INT_ENABLE;
-    err = SdioRwDirect(cntlr, &param, &val);
+    int32_t err = SdioRwDirect(cntlr, &param, &val);
     if (err != HDF_SUCCESS) {
         HDF_LOGE("SdioCccrIntDisable: read int enable fail! err = %d.", err);
         return err;
@@ -3371,7 +3271,6 @@ int32_t SdioCccrIntDisable(struct MmcCntlr *cntlr)
 
 static int32_t SdioReadCccr(struct MmcCntlr *cntlr)
 {
-    int32_t ret;
     uint8_t cccrRev;
     struct SdioDevice *sdioDev = NULL;
     struct SdioCccr *cccr = NULL;
@@ -3383,7 +3282,7 @@ static int32_t SdioReadCccr(struct MmcCntlr *cntlr)
 
     sdioDev = (struct SdioDevice *)cntlr->curDev;
     cccr = &(sdioDev->sdioReg.cccr);
-    ret = SdioReadCccrSdioRev(cntlr, cccr, &cccrRev);
+    int32_t ret = SdioReadCccrSdioRev(cntlr, cccr, &cccrRev);
     if (ret != HDF_SUCCESS) {
         return ret;
     }
@@ -3408,12 +3307,11 @@ static int32_t SdioReadCccr(struct MmcCntlr *cntlr)
 static int32_t SdioBusSpeedSelect(struct MmcCntlr *cntlr, bool enableHighSpeed)
 {
     struct SdioCmdParam param = {0};
-    int32_t error;
     uint8_t speed;
 
     /* read register 19 of CCCR. */
     param.regAddr = BUS_SPEED_SELECT;
-    error = SdioRwDirect(cntlr, &param, &speed);
+    int32_t error = SdioRwDirect(cntlr, &param, &speed);
     if (error != HDF_SUCCESS) {
         HDF_LOGE("SdioBusSpeedSelect: read bus speed select fail! err = %d.", error);
         return error;
@@ -3448,9 +3346,7 @@ static int32_t SdioSwitchHighSpeed(struct MmcCntlr *cntlr)
 
 static int32_t SdioEnableHighSpeed(struct MmcCntlr *cntlr)
 {
-    int32_t err;
-
-    err = SdioSwitchHighSpeed(cntlr);
+    int32_t err = SdioSwitchHighSpeed(cntlr);
     if (cntlr->curDev->type == MMC_DEV_SDIO || err != HDF_SUCCESS) {
         return err;
     }
@@ -3470,12 +3366,11 @@ static int32_t SdioEnableHighSpeed(struct MmcCntlr *cntlr)
 static int32_t SdioSetBusWidth(struct MmcCntlr *cntlr, uint8_t width)
 {
     struct SdioCmdParam param = {0};
-    int32_t error;
     uint8_t data;
 
     /* read register 7 of CCCR. */
     param.regAddr = BUS_INTERFACE_CONTROL;
-    error = SdioRwDirect(cntlr, &param, &data);
+    int32_t error = SdioRwDirect(cntlr, &param, &data);
     if (error != HDF_SUCCESS) {
         HDF_LOGE("SdioSetBusWidth: read BIC fail, error = %d!", error);
         return error;
@@ -3514,7 +3409,6 @@ static int32_t SdioSwitch4BitBusWidth(struct MmcCntlr *cntlr)
 
 static int32_t SdioEnable4BitBusWidth(struct MmcCntlr *cntlr)
 {
-    int32_t error;
     struct SdDevice *dev = (struct SdDevice *)cntlr->curDev;
 
     /*
@@ -3522,7 +3416,7 @@ static int32_t SdioEnable4BitBusWidth(struct MmcCntlr *cntlr)
      * For an SDIO card a write to the CCCR usingCMD52 is used to select bus width.
      * In the case of a combo card, both selection methods exist.
      */
-    error = SdioSwitch4BitBusWidth(cntlr);
+    int32_t error = SdioSwitch4BitBusWidth(cntlr);
     if (cntlr->curDev->type == MMC_DEV_SDIO || error != HDF_SUCCESS) {
         return error;
     }
@@ -3547,8 +3441,6 @@ static int32_t SdioReadCisTplField(struct MmcCntlr *cntlr, uint32_t addr, uint8_
 static void SdioDecodeCisTplManfId(struct MmcCntlr *cntlr, struct SdioFunction *function,
     struct SdioCisTuple *tuple)
 {
-    uint16_t vendorId;
-    uint16_t deviceId;
     struct SdioDevice *dev = NULL;
 
     if (tuple->tplLink < SDIO_CIS_TPL_MANFID_MIN_SIZE) {
@@ -3560,8 +3452,8 @@ static void SdioDecodeCisTplManfId(struct MmcCntlr *cntlr, struct SdioFunction *
      * bit04-05[manufacturer information(Part Number and /or Revision)].
      * bit02-03-->tplBody[0:1], bit04-05-->tplBody[2:3].
      */
-    vendorId = (tuple->tplBody[1] << BITS_PER_BYTE) | tuple->tplBody[0];
-    deviceId = (tuple->tplBody[3] << BITS_PER_BYTE) | tuple->tplBody[2];
+    uint16_t vendorId = (tuple->tplBody[1] << BITS_PER_BYTE) | tuple->tplBody[0];
+    uint16_t deviceId = (tuple->tplBody[3] << BITS_PER_BYTE) | tuple->tplBody[2];
 
     /* function CISTPL_MANFID. */
     if (function != NULL) {
@@ -3610,10 +3502,8 @@ static void SdioDecodeCisTplFunceCommon(struct MmcCntlr *cntlr, struct SdioCisTu
 
 static void SdioDecodeCisTplFunceFunction(struct SdioFunction *function, struct SdioCisTuple *tuple)
 {
-    uint32_t minSize;
-
     /* Rev 1.0, TPL_LINK 28bytes; >Rev 1.0, TPL_LINK 42bytes.  */
-    minSize = (function->dev->sdioReg.cccr.sdioRev == SDIO_CCCR_SDIO_REV_1_00) ?
+    uint32_t minSize = (function->dev->sdioReg.cccr.sdioRev == SDIO_CCCR_SDIO_REV_1_00) ?
         SDIO_CIS_TPL_FUNCE_FUNCTION_PC_MIN_SIZE : SDIO_CIS_TPL_FUNCE_FUNCTION_PC_MAX_SIZE;
     if (tuple->tplLink < minSize) {
         return;
@@ -3682,15 +3572,12 @@ static void SdioDecodeCisTplField(struct MmcCntlr *cntlr, struct SdioFunction *f
 static int32_t SdioFillTplInfo(struct MmcCntlr *cntlr, struct SdioCisTuple *tuple,
     uint32_t *addr, uint8_t tplCode, uint8_t tplLink)
 {
-    int32_t ret;
-    uint32_t i;
-
     tuple->tplCode = tplCode;
     tuple->tplLink = tplLink;
     /* read tuple body. */
-    for (i = 0; i < tplLink; i++) {
+    for (uint32_t i = 0; i < tplLink; i++) {
         (*addr)++;
-        ret = SdioReadCisTplField(cntlr, *addr, &(tuple->tplBody[i]));
+        int32_t ret = SdioReadCisTplField(cntlr, *addr, &(tuple->tplBody[i]));
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("SdioFillTplInfo: read tuple body fail, err = %d.", ret);
             return ret;
@@ -3755,10 +3642,7 @@ static int32_t SdioDecodeCis(struct MmcCntlr *cntlr, struct SdioFunction *functi
 static int32_t SdioReadCis(struct MmcCntlr *cntlr, struct SdioFunction *function)
 {
     uint32_t funcNum;
-    uint32_t i;
-    uint32_t cisStartAddr;
     uint8_t data;
-    int32_t ret;
     struct SdioCmdParam param = {0};
 
     if (function == NULL) {
@@ -3768,11 +3652,11 @@ static int32_t SdioReadCis(struct MmcCntlr *cntlr, struct SdioFunction *function
     }
 
     /* read CIS pointer. */
-    cisStartAddr = 0;
-    for (i = 0; i < SDIO_CCCR_CIS_START_ADDR_BYTES; i++) {
+    uint32_t cisStartAddr = 0;
+    for (uint32_t i = 0; i < SDIO_CCCR_CIS_START_ADDR_BYTES; i++) {
         /* read register 0xn09-0xn0B of FBR. */
         param.regAddr = SDIO_FBR_BASE_ADDR(funcNum) + SDIO_FBR_POINTER_CIS + i;
-        ret = SdioRwDirect(cntlr, &param, &data);
+        int32_t ret = SdioRwDirect(cntlr, &param, &data);
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("SdioReadCis: read CIS pointer fail, err = %d.", ret);
             return ret;
@@ -3785,12 +3669,11 @@ static int32_t SdioReadCis(struct MmcCntlr *cntlr, struct SdioFunction *function
 static int32_t SdioReadFbr(struct MmcCntlr *cntlr, struct SdioFunction *func)
 {
     struct SdioCmdParam param = {0};
-    int32_t error;
     uint8_t data;
 
     /* read register 0xn00 of FBR. */
     param.regAddr = SDIO_FBR_BASE_ADDR(func->funcNum) + SDIO_FBR_STD_FUNCTION_INTERFACE_CODE;
-    error = SdioRwDirect(cntlr, &param, &data);
+    int32_t error = SdioRwDirect(cntlr, &param, &data);
     if (error != HDF_SUCCESS) {
         HDF_LOGE("SdioReadFbr: read SFIC fail, err = %d.", error);
         return error;
@@ -3816,7 +3699,6 @@ int32_t SdioSetFbrIoBlockSize(struct MmcCntlr *cntlr, uint32_t blkSize)
 {
     struct SdioCmdParam param = {0};
     struct SdioDevice *dev = NULL;
-    int32_t ret;
 
     if (cntlr == NULL) {
         HDF_LOGE("SdioSetFbrIoBlockSize: cntlr is null!");
@@ -3839,7 +3721,7 @@ int32_t SdioSetFbrIoBlockSize(struct MmcCntlr *cntlr, uint32_t blkSize)
      * value for the block size supported by each function. This pointer is stored in little-endian format.
      */
     param.writeData = (blkSize & 0xff);
-    ret = SdioRwDirect(cntlr, &param, NULL);
+    int32_t ret = SdioRwDirect(cntlr, &param, NULL);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("SdioSetFbrIoBlockSize: write I/O Block Size fail, err = %d.", ret);
         return ret;
@@ -3901,16 +3783,14 @@ static int32_t SdioAddFunctions(struct MmcCntlr *cntlr, uint32_t funcs)
 {
     struct SdioDevice *sdioDev = (struct SdioDevice *)cntlr->curDev;
     struct SdioFunction *function = NULL;
-    uint32_t i;
-    int32_t ret;
 
     sdioDev->functions = 0;
-    for (i = 0; i < funcs; i++) {
+    for (uint32_t i = 0; i < funcs; i++) {
         function = SdioAllocFunction(sdioDev, i + 1);
         if (function == NULL) {
             return HDF_ERR_MALLOC_FAIL;
         }
-        ret = SdioReadFbr(cntlr, function);
+        int32_t ret = SdioReadFbr(cntlr, function);
         if (ret != HDF_SUCCESS) {
             SdioDeleteFunction(function);
             return ret;
@@ -3959,10 +3839,8 @@ static int32_t SdioDeviceAdd(struct MmcCntlr *cntlr)
 
 static int32_t SdioSelect(struct MmcCntlr *cntlr, uint32_t *rocr)
 {
-    int32_t error;
-
     /* cmd5, set the support voltage. */
-    error = SdioSendOpCond(cntlr, cntlr->curDev->reg.ocr.ocrData, rocr);
+    int32_t error = SdioSendOpCond(cntlr, cntlr->curDev->reg.ocr.ocrData, rocr);
     if (error != HDF_SUCCESS) {
         HDF_LOGE("SdioSelect: cmd5(set voltage) fail, err = %d.", error);
         return error;
@@ -4020,11 +3898,10 @@ static int32_t SdioSelect(struct MmcCntlr *cntlr, uint32_t *rocr)
 
 static int32_t SdioInit(struct MmcCntlr *cntlr)
 {
-    int32_t error;
     union MmcOcr ocr = {0};
 
     /* cmd5, detect sdio dev and get the voltage range. */
-    error = SdioSendOpCond(cntlr, 0, &(ocr.ocrData));
+    int32_t error = SdioSendOpCond(cntlr, 0, &(ocr.ocrData));
     if (error != HDF_SUCCESS) {
         HDF_LOGE("SdioInit: cmd5(detect sdio) fail, err = %d", error);
         return error;
@@ -4076,13 +3953,12 @@ static int32_t SdioInit(struct MmcCntlr *cntlr)
 int32_t SdioReinit(struct MmcCntlr *cntlr)
 {
     union MmcOcr ocr = {0};
-    int error;
 
     MmcGoIdleState(cntlr);
     MmcCntlrSetClock(cntlr, cntlr->freqMin);
 
     /* cmd5, detect sdio dev and get the voltage range. */
-    error = SdioSendOpCond(cntlr, 0, &(ocr.ocrData));
+    int error = SdioSendOpCond(cntlr, 0, &(ocr.ocrData));
     if (error != HDF_SUCCESS) {
         return error;
     }
@@ -4116,8 +3992,6 @@ int32_t SdioReinit(struct MmcCntlr *cntlr)
 
 static int32_t SdioDetect(struct MmcCntlr *cntlr)
 {
-    int32_t err;
-
     HDF_LOGD("SdioDetect: Detect sdio dev start...");
     /*
      * After reset or power-up, all I/O functions on the card are disabled and the I/O portion of the card shall
@@ -4127,7 +4001,7 @@ static int32_t SdioDetect(struct MmcCntlr *cntlr)
     SdioIoReset(cntlr);
     MmcGoIdleState(cntlr);
     /* Initialize SDIO. */
-    err = SdioInit(cntlr);
+    int32_t err = SdioInit(cntlr);
     if (err == HDF_SUCCESS) {
         HDF_LOGD("SdioDetect: Detect sdio dev success! %s dev at address 0x%x!",
             cntlr->curDev->state.bits.highSpeed ? "High speed" : "", cntlr->curDev->reg.rca);
diff --git a/framework/model/storage/src/mmc/mmc_sdio.c b/framework/model/storage/src/mmc/mmc_sdio.c
index 292d936e699660adefc705112879eaf521b9919c..dd28342fe100b8252b1e29687aa3362bcd559569 100644
--- a/framework/model/storage/src/mmc/mmc_sdio.c
+++ b/framework/model/storage/src/mmc/mmc_sdio.c
@@ -157,7 +157,6 @@ static int32_t SdioDeviceDefaultFunc0ReadBytes(struct SdioDevice *dev,
     struct SdioFunction *func = dev->curFunction;
     struct MmcCntlr *cntlr = NULL;
     uint32_t i;
-    int32_t ret;
 
     if (func == NULL) {
         HDF_LOGE("SdioDeviceDefaultFunc0ReadBytes: fail, func is null!");
@@ -174,7 +173,7 @@ static int32_t SdioDeviceDefaultFunc0ReadBytes(struct SdioDevice *dev,
     }
 
     for (i = 0; i < size; i++) {
-        ret = SdioReadWriteByte(cntlr, false, 0, (addr + i), &data[i]);
+        int32_t ret = SdioReadWriteByte(cntlr, false, 0, (addr + i), &data[i]);
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("SdioDeviceDefaultFunc0ReadBytes: fail, i = %u!", i);
             return ret;
@@ -188,7 +187,6 @@ static int32_t SdioDeviceDefaultFunc0WriteBytes(struct SdioDevice *dev,
 {
     struct SdioFunction *func = dev->curFunction;
     struct MmcCntlr *cntlr = NULL;
-    int32_t ret;
     uint32_t i;
 
     if (func == NULL) {
@@ -206,7 +204,7 @@ static int32_t SdioDeviceDefaultFunc0WriteBytes(struct SdioDevice *dev,
     }
 
     for (i = 0; i < size; i++) {
-        ret = SdioReadWriteByte(cntlr, true, 0, (addr + i), &data[i]);
+        int32_t ret = SdioReadWriteByte(cntlr, true, 0, (addr + i), &data[i]);
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("SdioDeviceDefaultFunc0WriteBytes: fail, i = %u!", i);
             return ret;
@@ -220,7 +218,6 @@ static int32_t SdioDeviceDefaultSetBlockSize(struct SdioDevice *dev, uint32_t bl
     struct SdioFunction *func = dev->curFunction;
     struct MmcCntlr *cntlr = NULL;
     uint32_t blockSize = blkSize;
-    int32_t ret;
 
     if (func == NULL) {
         HDF_LOGE("SdioDeviceDefaultSetBlockSize: func is null!");
@@ -233,7 +230,7 @@ static int32_t SdioDeviceDefaultSetBlockSize(struct SdioDevice *dev, uint32_t bl
     }
     blockSize = MMC_MIN(blockSize, MMC_SEC_SIZE);
 
-    ret = SdioSetFbrIoBlockSize(cntlr, blockSize);
+    int32_t ret = SdioSetFbrIoBlockSize(cntlr, blockSize);
     if (ret == HDF_SUCCESS) {
         func->curBlkSize = blockSize;
     }
@@ -322,7 +319,6 @@ static int32_t SdioDeviceDefaultFlushData(struct SdioDevice *dev)
 static int32_t SdioDeviceDefaultEnableFunc(struct SdioDevice *dev)
 {
     struct SdioFunction *func = dev->curFunction;
-    int32_t ret;
     uint32_t i;
     uint8_t val;
 
@@ -331,7 +327,7 @@ static int32_t SdioDeviceDefaultEnableFunc(struct SdioDevice *dev)
         return HDF_ERR_INVALID_OBJECT;
     }
 
-    ret = SdioCccrIoEnable(dev->sd.mmc.cntlr);
+    int32_t ret = SdioCccrIoEnable(dev->sd.mmc.cntlr);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("SdioDeviceDefaultEnableFunc: Io Enable fail, ret: %d!", ret);
         return ret;
@@ -367,7 +363,6 @@ static int32_t SdioDeviceDefaultClaimIrq(struct SdioDevice *dev, SdioIrqHandler
 {
     struct SdioFunction *func = dev->curFunction;
     struct MmcCntlr *cntlr = NULL;
-    int32_t ret;
 
     if (func == NULL) {
         HDF_LOGE("SdioDeviceDefaultClaimIrq: func is null!");
@@ -388,7 +383,7 @@ static int32_t SdioDeviceDefaultClaimIrq(struct SdioDevice *dev, SdioIrqHandler
         return HDF_ERR_INVALID_OBJECT;
     }
 
-    ret = SdioCccrIntEnable(cntlr);
+    int32_t ret = SdioCccrIntEnable(cntlr);
     if (ret != HDF_SUCCESS) {
         return ret;
     }
diff --git a/framework/model/storage/src/mtd/mtd_core.c b/framework/model/storage/src/mtd/mtd_core.c
index 68bea3f20e8e71d7e635750f05375a2d0e921ef0..295965c7075710b84a8feb281520241cb160c20f 100644
--- a/framework/model/storage/src/mtd/mtd_core.c
+++ b/framework/model/storage/src/mtd/mtd_core.c
@@ -94,11 +94,10 @@ static void MtdDeviceUnlockDefault(struct MtdDevice *mtdDevice)
 
 struct PlatformManager *MtdManagerGet(void)
 {
-    int32_t ret;
     static struct PlatformManager *g_mtdManager = NULL;
 
     if (g_mtdManager == NULL) {
-        ret = PlatformManagerCreate("STORAGE_MTD", &g_mtdManager);
+        int32_t ret = PlatformManagerCreate("STORAGE_MTD", &g_mtdManager);
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("MtdManagerGet: create manager fail, ret: %d!", ret);
             return NULL;
@@ -109,14 +108,12 @@ struct PlatformManager *MtdManagerGet(void)
 
 int32_t MtdDeviceAdd(struct MtdDevice *mtdDevice)
 {
-    int32_t ret;
-
     if (mtdDevice == NULL || mtdDevice->ops == NULL) {
         HDF_LOGE("MtdDeviceAdd: mtdDevice or ops is null!");
         return HDF_ERR_INVALID_OBJECT;
     }
 
-    ret = MtdDeviceCheckParms(mtdDevice);
+    int32_t ret = MtdDeviceCheckParms(mtdDevice);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("MtdDeviceAdd: mtd device check parms fail!");
         return HDF_ERR_INVALID_OBJECT;
diff --git a/framework/support/platform/src/can/can_manager.c b/framework/support/platform/src/can/can_manager.c
index d527b8afbafb8ac624f1e81208166916811847f1..bd4f75b6d83328851d5b3fc956b4ec746b43b5fc 100644
--- a/framework/support/platform/src/can/can_manager.c
+++ b/framework/support/platform/src/can/can_manager.c
@@ -21,10 +21,8 @@ static struct PlatformManager *g_manager;
 
 static struct PlatformManager *CanManagerGet(void)
 {
-    int32_t ret;
-
     if (g_manager == NULL) {
-        ret = PlatformManagerCreate("CAN_BUS_MANAGER", &g_manager);
+        int32_t ret = PlatformManagerCreate("CAN_BUS_MANAGER", &g_manager);
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("CanManagerGet: create can manager fail, ret: %d!", ret);
         }
@@ -42,7 +40,6 @@ static void CanManagerDestroyIfNeed(void)
 
 static int32_t CanIrqThreadWorker(void *data)
 {
-    int32_t ret;
     struct CanCntlr *cntlr = (struct CanCntlr *)data;
 
     if (cntlr == NULL) {
@@ -53,7 +50,7 @@ static int32_t CanIrqThreadWorker(void *data)
     cntlr->threadStatus |= CAN_THREAD_RUNNING;
     while ((cntlr->threadStatus & CAN_THREAD_RUNNING) != 0) {
         /* wait event */
-        ret = OsalSemWait(&cntlr->sem, HDF_WAIT_FOREVER);
+        int32_t ret = OsalSemWait(&cntlr->sem, HDF_WAIT_FOREVER);
         if (ret != HDF_SUCCESS) {
             continue;
         }
diff --git a/framework/support/platform/src/dma/dmac_core.c b/framework/support/platform/src/dma/dmac_core.c
index ced6c517fa290219f9a7ea5a4ff705c2ed6df9be..59bca5f5319326941fe22daa12205285499f6ab8 100644
--- a/framework/support/platform/src/dma/dmac_core.c
+++ b/framework/support/platform/src/dma/dmac_core.c
@@ -144,14 +144,12 @@ static void DmacFreeLli(struct DmacChanInfo *chanInfo)
  */
 void DmaCntlrDestroy(struct DmaCntlr *cntlr)
 {
-    uint16_t i;
-
     if (cntlr == NULL || cntlr->channelNum > DMAC_CHAN_NUM_MAX) {
         HDF_LOGE("DmaCntlrDestroy: dma cntlr is null or channel is invalid!");
         return;
     }
     if (cntlr->channelList != NULL) {
-        for (i = 0; i < cntlr->channelNum; i++) {
+        for (uint16_t i = 0; i < cntlr->channelNum; i++) {
             DmacFreeLli(&(cntlr->channelList[i]));
         }
         OsalMemFree(cntlr->channelList);
@@ -431,9 +429,6 @@ static int32_t DmacPeriphTransfer(struct DmaCntlr *cntlr, struct DmacMsg *msg)
 
 static int32_t DmacM2mTransfer(struct DmaCntlr *cntlr, struct DmacMsg *msg)
 {
-    int32_t ret;
-    size_t leftSize;
-    size_t dmaSize;
     size_t dmaCount = 0;
     struct DmacChanInfo *chanInfo = NULL;
 
@@ -451,10 +446,10 @@ static int32_t DmacM2mTransfer(struct DmaCntlr *cntlr, struct DmacMsg *msg)
     chanInfo->callbackData = msg->para;
     cntlr->dmacCacheFlush((uintptr_t)msg->srcAddr, (uintptr_t)(msg->srcAddr + msg->transLen));
     cntlr->dmacCacheInv((uintptr_t)msg->destAddr, (uintptr_t)(msg->destAddr + msg->transLen));
-    leftSize = msg->transLen;
+    size_t leftSize = msg->transLen;
     while (leftSize > 0) {
-        dmaSize = (leftSize >= cntlr->maxTransSize) ? cntlr->maxTransSize : leftSize;
-        ret = cntlr->dmaM2mChanEnable(cntlr, chanInfo, msg->srcAddr + dmaCount * cntlr->maxTransSize,
+        size_t dmaSize = (leftSize >= cntlr->maxTransSize) ? cntlr->maxTransSize : leftSize;
+        int32_t ret = cntlr->dmaM2mChanEnable(cntlr, chanInfo, msg->srcAddr + dmaCount * cntlr->maxTransSize,
             msg->destAddr + dmaCount * cntlr->maxTransSize, dmaSize);
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("DmacM2mTransfer: enable channel m2m fail!");
@@ -525,8 +520,6 @@ uintptr_t DmaGetCurrChanDestAddr(struct DmaCntlr *cntlr, uint16_t chan)
 
 static uint32_t DmacIsr(uint32_t irq, void *dev)
 {
-    uint16_t i;
-    int channelStatus;
     struct DmaCntlr *cntlr = (struct DmaCntlr *)dev;
 
     if (DmacCntlrCheck(cntlr) != HDF_SUCCESS) {
@@ -538,8 +531,8 @@ static uint32_t DmacIsr(uint32_t irq, void *dev)
         HDF_LOGE("DmacIsr: cntlr parm err! irq:%d, channel:%u!", cntlr->irq, cntlr->channelNum);
         return HDF_ERR_INVALID_OBJECT;
     }
-    for (i = 0; i < cntlr->channelNum; i++) {
-        channelStatus = cntlr->dmacGetChanStatus(cntlr, i);
+    for (uint16_t i = 0; i < cntlr->channelNum; i++) {
+        int channelStatus = cntlr->dmacGetChanStatus(cntlr, i);
         if (channelStatus == DMAC_CHN_SUCCESS || channelStatus == DMAC_CHN_ERROR) {
             cntlr->channelList[i].status = channelStatus;
             DmacCallbackHandle(&(cntlr->channelList[i]));
diff --git a/framework/support/platform/src/fwk/platform_manager.c b/framework/support/platform/src/fwk/platform_manager.c
index 32abba8aeee21e3a17a2477ecdbeaa1ccdeb7388..c8a082267ba852ac86e3ca65924b6268b93be2a5 100644
--- a/framework/support/platform/src/fwk/platform_manager.c
+++ b/framework/support/platform/src/fwk/platform_manager.c
@@ -98,7 +98,6 @@ void PlatformManagerDestroy(struct PlatformManager *manager)
 
 struct PlatformManager *PlatformManagerGet(int module)
 {
-    int32_t ret;
     struct PlatformManager *manager = NULL;
     struct PlatformModuleInfo *info = NULL;
 
@@ -110,7 +109,7 @@ struct PlatformManager *PlatformManagerGet(int module)
 
     PlatformGlobalLock();
     if (info->priv == NULL) {
-        ret = PlatformManagerCreate(info->moduleName, &manager);
+        int32_t ret = PlatformManagerCreate(info->moduleName, &manager);
         if (ret != HDF_SUCCESS) {
             PLAT_LOGE("PlatformManagerGet: create manager fail, ret: %d!", ret);
         } else {
diff --git a/framework/support/platform/src/fwk/platform_queue.c b/framework/support/platform/src/fwk/platform_queue.c
index 4b17e583081eee1f5600aa47d1fad7e24821683b..2a1670a218a6af1e62cb381145bf5e9514f39710 100644
--- a/framework/support/platform/src/fwk/platform_queue.c
+++ b/framework/support/platform/src/fwk/platform_queue.c
@@ -47,13 +47,12 @@ static int32_t PlatformQueueNextMsg(struct PlatformQueue *queue, struct Platform
 
 static int32_t PlatformQueueWorker(void *data)
 {
-    int32_t ret;
     struct PlatformQueue *queue = (struct PlatformQueue *)data;
     struct PlatformMsg *msg = NULL;
 
     while (true) {
         /* wait envent */
-        ret = OsalSemWait(&queue->sem, HDF_WAIT_FOREVER);
+        int32_t ret = OsalSemWait(&queue->sem, HDF_WAIT_FOREVER);
         if (ret != HDF_SUCCESS) {
             continue;
         }
diff --git a/framework/support/platform/src/gpio/gpio_core.c b/framework/support/platform/src/gpio/gpio_core.c
index c287c2af4fa43e560a4f3dbc893dc8128328c103..436d5230b6fa8e3995692f8aa882dbe644eb71bd 100644
--- a/framework/support/platform/src/gpio/gpio_core.c
+++ b/framework/support/platform/src/gpio/gpio_core.c
@@ -142,7 +142,6 @@ void GpioCntlrIrqCallback(struct GpioCntlr *cntlr, uint16_t local)
 
 static int32_t GpioCntlrIrqThreadHandler(void *data)
 {
-    int32_t ret;
     uint32_t irqSave;
     struct GpioIrqRecord *irqRecord = (struct GpioIrqRecord *)data;
 
@@ -151,7 +150,7 @@ static int32_t GpioCntlrIrqThreadHandler(void *data)
         return HDF_FAILURE;
     }
     while (true) {
-        ret = OsalSemWait(&irqRecord->sem, HDF_WAIT_FOREVER);
+        int32_t ret = OsalSemWait(&irqRecord->sem, HDF_WAIT_FOREVER);
         if (irqRecord->removed) {
             break;
         }
@@ -174,7 +173,6 @@ static int32_t GpioCntlrIrqThreadHandler(void *data)
 
 static int32_t GpioCntlrSetIrqInner(struct GpioInfo *ginfo, struct GpioIrqRecord *irqRecord)
 {
-    int32_t ret;
     uint16_t local = GpioInfoToLocal(ginfo);
     struct GpioCntlr *cntlr = ginfo->cntlr;
 
@@ -192,7 +190,7 @@ static int32_t GpioCntlrSetIrqInner(struct GpioInfo *ginfo, struct GpioIrqRecord
 
     ginfo->irqRecord = irqRecord;
     GpioInfoUnlock(ginfo);
-    ret = cntlr->ops->setIrq(cntlr, local, irqRecord->mode);
+    int32_t ret = cntlr->ops->setIrq(cntlr, local, irqRecord->mode);
     if (ret != HDF_SUCCESS) {
         GpioInfoLock(ginfo);
         HDF_LOGE("GpioCntlrSetIrqInner: gpio fail to setIrq!");
@@ -205,7 +203,6 @@ static int32_t GpioCntlrSetIrqInner(struct GpioInfo *ginfo, struct GpioIrqRecord
 static int32_t GpioIrqRecordCreate(struct GpioInfo *ginfo, uint16_t mode, GpioIrqFunc func, void *arg,
     struct GpioIrqRecord **new)
 {
-    int32_t ret;
     struct GpioIrqRecord *irqRecord = NULL;
     struct OsalThreadParam cfg;
 
@@ -221,7 +218,7 @@ static int32_t GpioIrqRecordCreate(struct GpioInfo *ginfo, uint16_t mode, GpioIr
     irqRecord->irqData = arg;
     irqRecord->global = GpioInfoToGlobal(ginfo);
     if (irqRecord->btmFunc != NULL) {
-        ret = OsalThreadCreate(&irqRecord->thread, GpioCntlrIrqThreadHandler, irqRecord);
+        int32_t ret = OsalThreadCreate(&irqRecord->thread, GpioCntlrIrqThreadHandler, irqRecord);
         if (ret != HDF_SUCCESS) {
             OsalMemFree(irqRecord);
             HDF_LOGE("GpioIrqRecordCreate: fail to create irq thread, ret: %d!", ret);
@@ -250,7 +247,6 @@ static int32_t GpioIrqRecordCreate(struct GpioInfo *ginfo, uint16_t mode, GpioIr
 
 int32_t GpioCntlrSetIrq(struct GpioCntlr *cntlr, uint16_t local, uint16_t mode, GpioIrqFunc func, void *arg)
 {
-    int32_t ret;
     struct GpioInfo *ginfo = NULL;
     struct GpioIrqRecord *irqRecord = NULL;
 
@@ -268,7 +264,7 @@ int32_t GpioCntlrSetIrq(struct GpioCntlr *cntlr, uint16_t local, uint16_t mode,
     }
 
     ginfo = &cntlr->ginfos[local];
-    ret = GpioIrqRecordCreate(ginfo, mode, func, arg, &irqRecord);
+    int32_t ret = GpioIrqRecordCreate(ginfo, mode, func, arg, &irqRecord);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("GpioCntlrSetIrq: fail to create irq record, ret: %d!", ret);
         return ret;
@@ -284,7 +280,6 @@ int32_t GpioCntlrSetIrq(struct GpioCntlr *cntlr, uint16_t local, uint16_t mode,
 
 int32_t GpioCntlrUnsetIrq(struct GpioCntlr *cntlr, uint16_t local, void *arg)
 {
-    int32_t ret;
     struct GpioInfo *ginfo = NULL;
     struct GpioIrqRecord *irqRecord = NULL;
 
@@ -314,7 +309,7 @@ int32_t GpioCntlrUnsetIrq(struct GpioCntlr *cntlr, uint16_t local, void *arg)
         HDF_LOGE("GpioCntlrUnsetIrq: gpio(%hu+%hu) arg not match!", cntlr->start, local);
         return HDF_ERR_INVALID_PARAM;
     }
-    ret = cntlr->ops->unsetIrq(cntlr, local);
+    int32_t ret = cntlr->ops->unsetIrq(cntlr, local);
     if (ret == HDF_SUCCESS) {
         ginfo->irqRecord = NULL;
     }
diff --git a/framework/support/platform/src/hdmi/hdmi_core.c b/framework/support/platform/src/hdmi/hdmi_core.c
index 995ad55b3deed081862245ed06230f1ddbe35458..35cd9708a3f42d3afceedacdd903c6287725cac8 100644
--- a/framework/support/platform/src/hdmi/hdmi_core.c
+++ b/framework/support/platform/src/hdmi/hdmi_core.c
@@ -74,8 +74,6 @@ static void HdmiCecDeinit(struct HdmiCntlr *cntlr)
 
 static void HdmiDdcInit(struct HdmiCntlr *cntlr)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("ddc init: param is invalid");
         return;
@@ -84,7 +82,7 @@ static void HdmiDdcInit(struct HdmiCntlr *cntlr)
     if (cntlr->ddc.init == true) {
         return;
     }
-    ret = OsalMutexInit(&(cntlr->ddc.ddcMutex));
+    int32_t ret = OsalMutexInit(&(cntlr->ddc.ddcMutex));
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("HdmiDdcInit: mutex init fail!");
         return;
@@ -142,8 +140,6 @@ static void HdmiFrlDeinit(struct HdmiCntlr *cntlr)
 
 static void HdmiHdcpInit(struct HdmiCntlr *cntlr)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         return;
     }
@@ -158,7 +154,7 @@ static void HdmiHdcpInit(struct HdmiCntlr *cntlr)
             HDF_LOGE("hdcp malloc fail");
             return;
         }
-        ret = OsalMutexInit(&(cntlr->hdcp->hdcpMutex));
+        int32_t ret = OsalMutexInit(&(cntlr->hdcp->hdcpMutex));
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("HdmiHdcpInit: mutex init fail!");
             return;
@@ -267,7 +263,6 @@ static void HdmiScdcDeinit(struct HdmiCntlr *cntlr)
 
 static int32_t HdmiCntlrInit(struct HdmiCntlr *cntlr)
 {
-    int32_t ret;
 
     if (cntlr == NULL) {
         return HDF_ERR_INVALID_OBJECT;
@@ -278,7 +273,7 @@ static int32_t HdmiCntlrInit(struct HdmiCntlr *cntlr)
         return HDF_ERR_INVALID_OBJECT;
     }
 
-    ret = OsalMutexInit(&cntlr->mutex);
+    int32_t ret = OsalMutexInit(&cntlr->mutex);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("HdmiCntlrInit: mutex init fail!");
         return ret;
@@ -321,13 +316,11 @@ static void HdmiCntlrUninit(struct HdmiCntlr *cntlr)
 
 int32_t HdmiCntlrAdd(struct HdmiCntlr *cntlr)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         return HDF_ERR_INVALID_OBJECT;
     }
 
-    ret = HdmiCntlrInit(cntlr);
+    int32_t ret = HdmiCntlrInit(cntlr);
     if (ret != HDF_SUCCESS) {
         return ret;
     }
@@ -353,9 +346,7 @@ void HdmiCntlrRemove(struct HdmiCntlr *cntlr)
 static int32_t HdmiCntlrParseVideoCaps(
     struct HdmiCntlr *cntlr, struct DeviceResourceIface *drsOps, const struct DeviceResourceNode *node)
 {
-    int32_t ret;
-
-    ret = drsOps->GetUint32(node, "maxTmdsClock", &(cntlr->cap.maxTmdsClock), 0);
+    int32_t ret = drsOps->GetUint32(node, "maxTmdsClock", &(cntlr->cap.maxTmdsClock), 0);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("HdmiCntlrParseVideoCaps: read maxTmdsClock fail!");
         return ret;
@@ -402,9 +393,7 @@ static int32_t HdmiCntlrParseVideoCaps(
 static int32_t HdmiCntlrParseAudioCaps(
     struct HdmiCntlr *cntlr, struct DeviceResourceIface *drsOps, const struct DeviceResourceNode *node)
 {
-    int32_t ret;
-
-    ret = drsOps->GetUint32(node, "audioIfType", &(cntlr->cap.audioIfType), 0);
+    int32_t ret = drsOps->GetUint32(node, "audioIfType", &(cntlr->cap.audioIfType), 0);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("HdmiCntlrParseAudioCaps: read audioIfType fail!");
         return ret;
@@ -437,9 +426,7 @@ static int32_t HdmiCntlrParseAudioCaps(
 static int32_t HdmiCntlrParseHdrCaps(
     struct HdmiCntlr *cntlr, struct DeviceResourceIface *drsOps, const struct DeviceResourceNode *node)
 {
-    int32_t ret;
-
-    ret = drsOps->GetUint32(node, "hdrColorimetry", &(cntlr->cap.hdrColorimetry), 0);
+    int32_t ret = drsOps->GetUint32(node, "hdrColorimetry", &(cntlr->cap.hdrColorimetry), 0);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("HdmiCntlrParseAudioCaps: read hdrColorimetry fail!");
         return ret;
@@ -459,7 +446,6 @@ int32_t HdmiCntlrParse(struct HdmiCntlr *cntlr, struct HdfDeviceObject *obj)
 {
     const struct DeviceResourceNode *node = NULL;
     struct DeviceResourceIface *drsOps = NULL;
-    int32_t ret;
 
     if (obj == NULL || cntlr == NULL) {
         HDF_LOGE("HdmiCntlrParse: input param is NULL.");
@@ -477,7 +463,7 @@ int32_t HdmiCntlrParse(struct HdmiCntlr *cntlr, struct HdfDeviceObject *obj)
         return HDF_FAILURE;
     }
 
-    ret = drsOps->GetUint32(node, "index", &(cntlr->deviceIndex), 0);
+    int32_t ret = drsOps->GetUint32(node, "index", &(cntlr->deviceIndex), 0);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("HdmiCntlrParse: read hostId fail!");
         return ret;
@@ -523,8 +509,6 @@ static struct HdmiSinkDeviceCapability *HdmiGetSinkCapability(struct HdmiDevice
 
 int32_t HdmiCntlrGetSinkEdid(struct HdmiCntlr *cntlr, uint8_t *buffer, uint32_t len)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         return HDF_ERR_INVALID_OBJECT;
     }
@@ -537,7 +521,7 @@ int32_t HdmiCntlrGetSinkEdid(struct HdmiCntlr *cntlr, uint8_t *buffer, uint32_t
         return HdmiEdidGetRaw(&(cntlr->hdmi->edid), buffer, len);
     }
 
-    ret = HdmiCntlrAllocDev(cntlr);
+    int32_t ret = HdmiCntlrAllocDev(cntlr);
     if (ret != HDF_SUCCESS) {
         return ret;
     }
@@ -683,8 +667,6 @@ static void HdmiAttrInit(struct HdmiCntlr *cntlr)
 
 int32_t HdmiCntlrOpen(struct HdmiCntlr *cntlr)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         return HDF_ERR_INVALID_OBJECT;
     }
@@ -699,7 +681,7 @@ int32_t HdmiCntlrOpen(struct HdmiCntlr *cntlr)
     HdmiCntlrHardWareInit(cntlr);
     /* HDCP on. */
     if ((cntlr->cap.baseCap.data & HDMI_CAP_HDCP_MARK) > 0) {
-        ret = HdmiHdcpOpen(cntlr->hdcp);
+        int32_t ret = HdmiHdcpOpen(cntlr->hdcp);
         if (ret != HDF_SUCCESS) {
             HdmiHdcpClose(cntlr->hdcp);
         }
@@ -1078,13 +1060,10 @@ static void HdmiHdrModeCheck(
 static void HdmiFillVideoAttrFromHardwareStatus(
     struct HdmiVideoAttr *videoAttr, const struct HdmiHardwareStatus *hwStatus, struct HdmiCommonAttr *commAttr)
 {
-    bool rgb;
-    bool aspectIs256;
-    uint8_t vic;
     enum HdmiVsVideoFormat format;
     enum Hdmi4kVic vic4k;
 
-    rgb = ((hwStatus->videoStatus.rgb2Ycbcr) ||
+    bool rgb = ((hwStatus->videoStatus.rgb2Ycbcr) ||
         ((!hwStatus->videoStatus.ycbcr2Rgb) && (hwStatus->videoStatus.outColorSpace == HDMI_COLOR_SPACE_RGB)));
     videoAttr->colorSpace = (rgb == true) ? HDMI_COLOR_SPACE_RGB : HDMI_COLOR_SPACE_YCBCR444;
     /*
@@ -1102,7 +1081,7 @@ static void HdmiFillVideoAttrFromHardwareStatus(
      * ...
      */
     if (hwStatus->infoFrameStatus.aviEnable) {
-        vic = hwStatus->infoFrameStatus.avi[7];
+        uint8_t vic = hwStatus->infoFrameStatus.avi[7];
         /*
          * when the timing is 4096*2160, the aspect ratio in AVI infoFrame is 0
          * (but the real aspect ratio is 256:135<0x04>, the video_code is 0)
@@ -1114,7 +1093,7 @@ static void HdmiFillVideoAttrFromHardwareStatus(
          * vsif[7]: BIT[7]: reserved for future, BIT[6:5]: HDMI_Video_Format, BIT[4:0]: reserved.
          * vsif[8]: HDMI_VIC, 0x04: 4K*2K @24Hz(SMPTE).
          */
-        aspectIs256 = (((vic == 0) && (hwStatus->infoFrameStatus.vsif[8] == 0x04)) ||
+        bool aspectIs256 = (((vic == 0) && (hwStatus->infoFrameStatus.vsif[8] == 0x04)) ||
             ((vic >= HDMI_VIC_4096X2160P25_256_135) && (vic <= HDMI_VIC_4096X2160P60_256_135)));
         videoAttr->aspect = (aspectIs256 == true) ? HDMI_PICTURE_ASPECT_256_135 :
             ((hwStatus->infoFrameStatus.avi[5] >> 4) & 0x3);                        /* 4'b, BIT[2:1] */
@@ -1219,7 +1198,6 @@ static int32_t HdmiVedioAttrHandle(struct HdmiCntlr *cntlr, struct HdmiHardwareS
     struct HdmiVideoAttr *videoAttr = &(cntlr->attr.videoAttr);
     struct HdmiCommonAttr curCommAttr = {0};
     struct HdmiVideoAttr curVideoAttr = {0};
-    int32_t ret;
 
     /* support HDR. */
     if (cntlr->cap.baseCap.bits.hdr > 0) {
@@ -1228,7 +1206,7 @@ static int32_t HdmiVedioAttrHandle(struct HdmiCntlr *cntlr, struct HdmiHardwareS
 
     /* support FRL. */
     if (cntlr->cap.baseCap.bits.frl > 0) {
-        ret = HdmiFrlModeSelect(cntlr->frl);
+        int32_t ret = HdmiFrlModeSelect(cntlr->frl);
         if (ret != HDF_SUCCESS) {
             return ret;
         }
diff --git a/framework/support/platform/src/hdmi/hdmi_edid.c b/framework/support/platform/src/hdmi/hdmi_edid.c
index e3d56d3e75a773c491a6bba4012fd2efc5463ec9..f570b5792aa575d0cbb09d4cfaf2b6407ff13b34 100644
--- a/framework/support/platform/src/hdmi/hdmi_edid.c
+++ b/framework/support/platform/src/hdmi/hdmi_edid.c
@@ -32,13 +32,11 @@ int32_t HdmiEdidReset(struct HdmiEdid *edid)
 
 int32_t HdmiEdidGetRaw(struct HdmiEdid *edid, uint8_t *raw, uint32_t len)
 {
-    uint32_t length;
-
     if (edid == NULL || raw == NULL) {
         return HDF_ERR_INVALID_PARAM;
     }
 
-    length = ((len < edid->rawLen) ? len : edid->rawLen);
+    uint32_t length = ((len < edid->rawLen) ? len : edid->rawLen);
     if (length == 0) {
         HDF_LOGE("edid data not get.");
         return (int32_t)length;
@@ -82,18 +80,16 @@ static int32_t HdmiEdidBlockCheckSum(uint8_t *data)
 
 static int32_t HdmiEdidVendorInfoPhase(struct HdmiEdid *edid)
 {
-    uint16_t data;
     uint16_t i;
-    uint16_t tmpData;
     struct HdmiSinkDeviceCapability *sinkCap = &(edid->sinkCap);
     struct HdmiEdidFirstBlockInfo *block = (struct HdmiEdidFirstBlockInfo *)edid->raw;
 
     /* Manufacturer Name */
-    data = (block->vendorName[UINT8_ARRAY_TELEMENT_0] <<
+    uint16_t data = (block->vendorName[UINT8_ARRAY_TELEMENT_0] <<
             HDMI_EDID_MANUFACRURER_NAME_SHIFT) |
             (block->vendorName[UINT8_ARRAY_TELEMENT_1]);
     for (i = 0; i < HDMI_EDID_MANUFACRURER_NAME_MAX_LEN - 1; i++) {
-        tmpData = (data & (HDMI_EDID_MANUFACRURER_NAME_CHAR_MARK << (HDMI_EDID_MANUFACRURER_NAME_CHAR_SHIFT * i)));
+        uint16_t tmpData = (data & (HDMI_EDID_MANUFACRURER_NAME_CHAR_MARK << (HDMI_EDID_MANUFACRURER_NAME_CHAR_SHIFT * i)));
         tmpData = (tmpData >> (HDMI_EDID_MANUFACRURER_NAME_CHAR_SHIFT * i));
         if (tmpData > HDMI_EDID_MANUFACRURER_NAME_LOW_INVALID &&
             tmpData < HDMI_EDID_MANUFACRURER_NAME_HIGH_INVALID) {
@@ -224,7 +220,6 @@ static uint32_t HdmiEdidGetStandardTimingVertPixel(uint32_t aspectRatio, uint32_
 static int32_t HdmiEdidStandardTimingPhase(struct HdmiEdid *edid)
 {
     uint32_t i;
-    uint32_t aspectRatio;
     struct HdmiSinkDeviceCapability *sinkCap = &(edid->sinkCap);
     struct HdmiEdidFirstBlockInfo *block = (struct HdmiEdidFirstBlockInfo *)edid->raw;
     uint8_t *data = block->stdTiming;
@@ -242,7 +237,7 @@ static int32_t HdmiEdidStandardTimingPhase(struct HdmiEdid *edid)
             sinkCap->stdTimingsInfo[i].refreshRate = (data[UINT8_ARRAY_TELEMENT_1] &
                                                       HDMI_EDID_STANDARD_TIMING_REFRESH_RATE_MARK) +
                                                       HDMI_EDID_STANDARD_TIMING_REFRESH_RATE_BASE;
-            aspectRatio =  (data[UINT8_ARRAY_TELEMENT_1] & HDMI_EDID_STANDARD_TIMING_ASPECT_RATE_MARK) >>
+            uint32_t aspectRatio =  (data[UINT8_ARRAY_TELEMENT_1] & HDMI_EDID_STANDARD_TIMING_ASPECT_RATE_MARK) >>
                 HDMI_EDID_STANDARD_TIMING_ASPECT_RATE_SHIFT;
             sinkCap->stdTimingsInfo[i].vertPixel =
                 HdmiEdidGetStandardTimingVertPixel(aspectRatio, sinkCap->stdTimingsInfo[i].horizPixel);
@@ -401,8 +396,6 @@ static int32_t HdmiEdidExtBlockNumPhase(struct HdmiEdid *edid)
 static int32_t HdmiEdidFirstBlockPhase(struct HdmiEdid *edid)
 {
     uint32_t i;
-    uint32_t len;
-    int32_t ret;
 
     HdmiEdidPhaseFunc func[] = {
         HdmiEdidHeaderPhase,
@@ -416,13 +409,13 @@ static int32_t HdmiEdidFirstBlockPhase(struct HdmiEdid *edid)
         HdmiEdidExtBlockNumPhase
     };
 
-    ret = HdmiEdidBlockCheckSum(edid->raw);
+    int32_t ret = HdmiEdidBlockCheckSum(edid->raw);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("edid block0 check sum fail.");
         return ret;
     }
 
-    len = sizeof(func) / sizeof(func[UINT8_ARRAY_TELEMENT_0]);
+    uint32_t len = sizeof(func) / sizeof(func[UINT8_ARRAY_TELEMENT_0]);
     for (i = 0; i < len; i++) {
         if (func[i] == NULL) {
             continue;
@@ -509,9 +502,6 @@ static void HdmiEdidExtAdbDepthAndMaxRatePhase(struct HdmiEdidAudioInfo *audio,
 
 static int32_t HdmiEdidExtAudioDataBlockPhase(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data, uint8_t len)
 {
-    uint8_t i;
-    uint8_t formatCode;
-
     /*
      * Each Short Audio Descriptor is 3-bytes long. There can be up to 31 bytes following any tag,
      * therefore there may be up to 10 Short Audio Descriptors in the Audio Data Block.
@@ -521,14 +511,14 @@ static int32_t HdmiEdidExtAudioDataBlockPhase(struct HdmiSinkDeviceCapability *s
         return HDF_ERR_INVALID_PARAM;
     }
 
-    for (i = 0; i < (len / HDMI_EDID_EXTENSION_SHORT_AUDIO_DESCRIPTOR_LEN); i++) {
+    for (uint8_t i = 0; i < (len / HDMI_EDID_EXTENSION_SHORT_AUDIO_DESCRIPTOR_LEN); i++) {
         if (sinkCap->audioInfoCnt >= HDMI_EDID_EXTENSION_AUDIO_CAP_COUNT) {
             HDF_LOGE("ADB: info cnt reach the maximum");
             break;
         }
         data += (i * HDMI_EDID_EXTENSION_SHORT_AUDIO_DESCRIPTOR_LEN);
         /* byte0: bit[6:3] Audio Format Code; bit[2:0] Max Number of channels - 1 */
-        formatCode = (data[UINT8_ARRAY_TELEMENT_0] & HDMI_EDID_EXTENSION_AUDIO_FORMAT_CODE_MARK) >>
+        uint8_t formatCode = (data[UINT8_ARRAY_TELEMENT_0] & HDMI_EDID_EXTENSION_AUDIO_FORMAT_CODE_MARK) >>
             HDMI_EDID_EXTENSION_AUDIO_FORMAT_CODE_SHIFT;
         sinkCap->audioInfo[sinkCap->audioInfoCnt].formatCode = (enum HdmiAudioCodingType)formatCode;
         sinkCap->audioInfo[sinkCap->audioInfoCnt].channels =
@@ -549,18 +539,15 @@ static int32_t HdmiEdidExtAudioDataBlockPhase(struct HdmiSinkDeviceCapability *s
 static int32_t HdmiEdidExtVideoDataBlockPhase(struct HdmiSinkDeviceCapability *sinkCap, const uint8_t *data,
     uint8_t len)
 {
-    uint8_t i;
-    uint32_t vicAll;
-    uint32_t vicLower;
     uint32_t implicitNative = 0;
 
-    for (i = 0; i < len; i++) {
+    for (uint8_t i = 0; i < len; i++) {
         if (sinkCap->videoInfo.vicNum >= HDMI_EDID_EXTENSION_MAX_VIC_COUNT) {
             HDF_LOGD("VDB: vicNum reach the maximum");
             break;
         }
-        vicAll = data[i];
-        vicLower = (vicAll & HDMI_EDID_EXTENSION_VIC_LOWER7_MARK);
+        uint32_t vicAll = data[i];
+        uint32_t vicLower = (vicAll & HDMI_EDID_EXTENSION_VIC_LOWER7_MARK);
         if (vicAll == 0) {
             continue;
         }
@@ -665,8 +652,6 @@ static void HdmiEdidVsdbSinkLatencyPhase(struct HdmiSinkDeviceCapability *sinkCa
 static void HdmiEdidVsdbVicInfoPhase(struct HdmiSinkDeviceCapability *sinkCap,
     const uint8_t *data, uint8_t vicLen, uint8_t *offset)
 {
-    uint8_t i;
-    uint8_t index;
     /* see hdmi spec 1.4 table 8-13. */
     uint32_t hdmi4kVic[] = {
         0,
@@ -676,11 +661,11 @@ static void HdmiEdidVsdbVicInfoPhase(struct HdmiSinkDeviceCapability *sinkCap,
         HDMI_VIC_4096X2160P24_256_135
     };
 
-    for (i = 0; i < vicLen; i++) {
+    for (uint8_t i = 0; i < vicLen; i++) {
         if (sinkCap->videoInfo.vicNum >= HDMI_EDID_EXTENSION_MAX_VIC_COUNT) {
             break;
         }
-        index = data[(*offset)];
+        uint8_t index = data[(*offset)];
         if (index != 0 && index < sizeof(hdmi4kVic) / sizeof(hdmi4kVic[UINT8_ARRAY_TELEMENT_0])) {
             sinkCap->videoInfo.vic[sinkCap->videoInfo.vicNum] = hdmi4kVic[index];
             sinkCap->videoInfo.vicNum++;
@@ -733,7 +718,6 @@ static void HdmiEdidVsdbVicAnd3dInfoPhase(struct HdmiSinkDeviceCapability *sinkC
 {
     uint8_t hdmiVicLen = 0;
     uint8_t hdmi3dLen = 0;
-    uint8_t offset;
 
     if (len < HDMI_EDID_VSDB_MIN_LEN_FOR_3D_PRESENT_INFO) {
         HDF_LOGD("vsdb: these is no vic/3d field.");
@@ -752,7 +736,7 @@ static void HdmiEdidVsdbVicAnd3dInfoPhase(struct HdmiSinkDeviceCapability *sinkC
     }
 
     /* byte14~byteN: Vic info/3D info */
-    offset = HDMI_EDID_VSDB_MIN_LEN_FOR_VIC_INFO;
+    uint8_t offset = HDMI_EDID_VSDB_MIN_LEN_FOR_VIC_INFO;
     if (hdmiVicLen > 0 && (hdmiVicLen + offset + 1) <= len) {
         HdmiEdidVsdbVicInfoPhase(sinkCap, data, hdmiVicLen, &offset);
     }
@@ -952,14 +936,13 @@ static void HdmiEdidExtUseExtDataBlockY420VdbPhase(struct HdmiSinkDeviceCapabili
     const uint8_t *data, uint8_t len)
 {
     uint8_t i;
-    uint32_t vic;
 
     for (i = 1; i < len; i++) {
         if (sinkCap->y420Cap.onlySupportY420VicNum >= HDMI_EDID_EXTENSION_MAX_VIC_COUNT) {
             HDF_LOGD("Y420Vdb: vic num reach to max.");
             break;
         }
-        vic = data[i];
+        uint32_t vic = data[i];
         if (vic == 0 ||
             (vic >= HDMI_EDID_EXTENSION_VIC_INVALID_LOW && vic <= HDMI_EDID_EXTENSION_VIC_INVALID_HIGH)) {
             continue;
@@ -974,8 +957,6 @@ static void HdmiEdidExtUseExtDataBlockY420CmdbPhase(struct HdmiSinkDeviceCapabil
     uint8_t *data, uint8_t len)
 {
     uint32_t i;
-    uint32_t loop;
-
     /*
      * When the Length field is set to 1, the Y420CMDB does not include a YCBCR 4:2:0 Capability Bit Map and
      * all the SVDs in the regular Video Data Block(s) support YCBCR 4:2:0 sampling mode.
@@ -996,7 +977,7 @@ static void HdmiEdidExtUseExtDataBlockY420CmdbPhase(struct HdmiSinkDeviceCapabil
      * Bit 0 of data byte 3 is associated with the first sequential SVD listed in the regular Video Data Block(s)
      * of the EDID, bit 1 the second SVD, bit 2 the third, and so on.
      */
-    loop = len * HDMI_BITS_OF_ONE_BYTE;
+    uint32_t loop = len * HDMI_BITS_OF_ONE_BYTE;
     loop = (loop > HDMI_EDID_EXTENSION_MAX_VIC_COUNT) ? HDMI_EDID_EXTENSION_MAX_VIC_COUNT : loop;
     data++;
     for (i = 0; (i < loop) && (i < sinkCap->videoInfo.vicNum); i++) {
@@ -1101,15 +1082,13 @@ static void HdmiEdidExtUseExtDataBlockVsvdbPhase(struct HdmiSinkDeviceCapability
                                                  uint8_t *data,
                                                  uint8_t len)
 {
-    uint32_t oui;
-
     if (len != HDMI_EDID_VSVDB_DOLBY_VERSION_0_LEN &&
         len != HDMI_EDID_VSVDB_DOLBY_VERSION_1_LEN) {
         HDF_LOGD("Vsvdb: invalid dolby len");
         return;
     }
 
-    oui = (data[UINT8_ARRAY_TELEMENT_1]) | (data[UINT8_ARRAY_TELEMENT_2] << SHIFT_8_BIT) |
+    uint32_t oui = (data[UINT8_ARRAY_TELEMENT_1]) | (data[UINT8_ARRAY_TELEMENT_2] << SHIFT_8_BIT) |
         (data[UINT8_ARRAY_TELEMENT_3] << SHIFT_16_BIT);
     if (oui != HDMI_EDID_VSVDB_DOLBY_OUI) {
         return;
@@ -1199,19 +1178,17 @@ static void HdmiEdidExtSeveralDataBlockPhase(struct HdmiEdid *edid, uint8_t bloc
     struct HdmiSinkDeviceCapability *sinkCap = &(edid->sinkCap);
     uint8_t blkOffset = HDMI_EDID_EXTENSION_BLOCK_OFFSET;
     uint8_t dtdOffset = data[UINT8_ARRAY_TELEMENT_2];
-    uint8_t dbTagCode;
     uint8_t blkLen;
-    int32_t ret;
 
     data += blkOffset;
     /* phase data block */
     for (blkLen = 0; (blkOffset < dtdOffset) && (data != NULL); blkOffset += (blkLen + 1)) {
         data += blkLen;
         blkLen = (data[UINT8_ARRAY_TELEMENT_0] & HDMI_EDID_EXTENSION_DATA_BLOCK_LEN_MARK);
-        dbTagCode = (data[UINT8_ARRAY_TELEMENT_0] & HDMI_EDID_EXTENSION_DATA_BLOCK_TAG_CODE_MARK) >>
+        uint8_t dbTagCode = (data[UINT8_ARRAY_TELEMENT_0] & HDMI_EDID_EXTENSION_DATA_BLOCK_TAG_CODE_MARK) >>
             HDMI_EDID_EXTENSION_DATA_BLOCK_TAG_CODE_SHIFT;
         data++;
-        ret = HdmiEdidExtDataBlockPhase(sinkCap, data, blkLen, dbTagCode);
+        int32_t ret = HdmiEdidExtDataBlockPhase(sinkCap, data, blkLen, dbTagCode);
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("data block %hhu phase fail", dbTagCode);
             return;
@@ -1231,7 +1208,6 @@ static int32_t HdmiEdidExtBlockPhase(struct HdmiEdid *edid, uint8_t blockNum)
 {
     uint8_t *data = edid->raw;
     struct HdmiSinkDeviceCapability *sinkCap = &(edid->sinkCap);
-    int32_t ret;
 
     if (blockNum >= HDMI_EDID_MAX_BLOCK_NUM) {
         HDF_LOGE("blockNum %hhu is invalid", blockNum);
@@ -1239,7 +1215,7 @@ static int32_t HdmiEdidExtBlockPhase(struct HdmiEdid *edid, uint8_t blockNum)
     }
 
     data += (blockNum * HDMI_EDID_SINGLE_BLOCK_SIZE);
-    ret = HdmiEdidBlockCheckSum(data);
+    int32_t ret = HdmiEdidBlockCheckSum(data);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("edid block%hhu check sum fail.", blockNum);
         return ret;
@@ -1278,14 +1254,13 @@ static int32_t HdmiEdidExtBlockPhase(struct HdmiEdid *edid, uint8_t blockNum)
 int32_t HdmiEdidPhase(struct HdmiEdid *edid)
 {
     uint8_t blockNum;
-    int32_t ret;
     struct HdmiSinkDeviceCapability *sinkCap = NULL;
 
     if (edid == NULL) {
         return HDF_ERR_INVALID_PARAM;
     }
 
-    ret = HdmiEdidFirstBlockPhase(edid);
+    int32_t ret = HdmiEdidFirstBlockPhase(edid);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("edid first block phase fail.");
         return ret;
@@ -1305,8 +1280,6 @@ int32_t HdmiEdidPhase(struct HdmiEdid *edid)
 int32_t HdmiEdidRawDataRead(struct HdmiEdid *edid, struct HdmiDdc *ddc)
 {
     struct HdmiDdcCfg cfg = {0};
-    int32_t ret;
-    uint8_t extBlkNum;
 
     if (edid == NULL || ddc == NULL) {
         return HDF_ERR_INVALID_PARAM;
@@ -1319,14 +1292,14 @@ int32_t HdmiEdidRawDataRead(struct HdmiEdid *edid, struct HdmiDdc *ddc)
     cfg.dataLen = HDMI_EDID_SINGLE_BLOCK_SIZE;
     cfg.readFlag = true;
     cfg.devAddr = HDMI_DDC_EDID_DEV_ADDRESS;
-    ret = HdmiDdcTransfer(ddc, &cfg);
+    int32_t ret = HdmiDdcTransfer(ddc, &cfg);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("edid block0 read fail");
         return ret;
     }
     edid->rawLen += HDMI_EDID_SINGLE_BLOCK_SIZE;
 
-    extBlkNum = edid->raw[HDMI_EDID_EXTENSION_BLOCK_ADDR];
+    uint8_t extBlkNum = edid->raw[HDMI_EDID_EXTENSION_BLOCK_ADDR];
     if (extBlkNum > (HDMI_EDID_MAX_BLOCK_NUM - 1)) {
         extBlkNum = (HDMI_EDID_MAX_BLOCK_NUM - 1);
         HDF_LOGD("extBlkNum > max, use max.");
diff --git a/framework/support/platform/src/hdmi/hdmi_event.c b/framework/support/platform/src/hdmi/hdmi_event.c
index 87de39f377be23c8627b5e15c645716a8ce155d2..8a37dce5ea8359e15d94710f3fc899d6d449368c 100644
--- a/framework/support/platform/src/hdmi/hdmi_event.c
+++ b/framework/support/platform/src/hdmi/hdmi_event.c
@@ -14,8 +14,6 @@
 
 static int32_t HdmiEventPostMsg(struct HdmiCntlr *cntlr, struct HdmiEventMsg *event)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         return HDF_ERR_INVALID_OBJECT;
     }
@@ -31,7 +29,7 @@ static int32_t HdmiEventPostMsg(struct HdmiCntlr *cntlr, struct HdmiEventMsg *ev
         return HDF_SUCCESS;
     }
 
-    ret = OsalSemWait(&event->sem, HDF_WAIT_FOREVER);
+    int32_t ret = OsalSemWait(&event->sem, HDF_WAIT_FOREVER);
     (void)OsalSemDestroy(&event->sem);
     OsalMemFree(event);
     if (ret != HDF_SUCCESS) {
diff --git a/framework/support/platform/src/hdmi/hdmi_frl.c b/framework/support/platform/src/hdmi/hdmi_frl.c
index 1dd76100c59a29b68db03d125329a8322df44138..142bcb85d310fe18a74b5e59f50ae159443d315c 100644
--- a/framework/support/platform/src/hdmi/hdmi_frl.c
+++ b/framework/support/platform/src/hdmi/hdmi_frl.c
@@ -148,10 +148,8 @@ static void HdmiFrlSetTrainRate(const struct HdmiFrl *frl)
 static bool HdmiFrlCheckFrlCapability(struct HdmiFrl *frl)
 {
     struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv;
-    uint8_t sinkScdcVerion;
-    uint8_t sinkMaxFrlRate;
 
-    sinkScdcVerion = HdmiFrlGetSinkVersion(cntlr->scdc);
+    uint8_t sinkScdcVerion = HdmiFrlGetSinkVersion(cntlr->scdc);
     if (HdmiEdidSupportFrl(cntlr->hdmi) != true ||
         cntlr->cap.baseCap.bits.hdmi21 == 0 ||
         cntlr->cap.baseCap.bits.frl == 0 ||
@@ -159,7 +157,7 @@ static bool HdmiFrlCheckFrlCapability(struct HdmiFrl *frl)
         frl->info.maxFrlRate = 0;
         return HDF_ERR_NOT_SUPPORT;
     }
-    sinkMaxFrlRate = HdmiEdidGetMaxFrlRate(cntlr->hdmi);
+    uint8_t sinkMaxFrlRate = HdmiEdidGetMaxFrlRate(cntlr->hdmi);
     frl->info.maxFrlRate = (sinkMaxFrlRate > cntlr->cap.maxFrlRate) ? cntlr->cap.maxFrlRate : sinkMaxFrlRate;
     return HDF_SUCCESS;
 }
@@ -226,10 +224,9 @@ static bool HdnmiFrlCheckFrlMode(struct HdmiFrl *frl)
     struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv;
     struct HdmiVideoDefInfo *videoInfo = NULL;
     struct HdmiDfmParam param = {0};
-    bool enable3d;
     uint32_t i;
 
-    enable3d = (cntlr->attr.videoAttr._3dStruct >= HDMI_VS_VIDEO_3D_BUTT) ? false : true;
+    bool enable3d = (cntlr->attr.videoAttr._3dStruct >= HDMI_VS_VIDEO_3D_BUTT) ? false : true;
     videoInfo = HdmiCommonGetVideoDefInfo(cntlr->attr.videoAttr.timing, cntlr->attr.videoAttr.aspect, enable3d);
     if (videoInfo == NULL) {
         HDF_LOGD("have no this video param, use tmds to transmit.");
@@ -679,8 +676,6 @@ static void HdmiFrlTrainingResultCheckTimeout(struct HdmiFrl *frl)
 
 static void HdmiFrlTrainingResultHandleTimeout(struct HdmiFrl *frl)
 {
-    uint64_t curTime;
-    bool frlStart;
     struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv;
 
     if (cntlr == NULL || cntlr->ops == NULL) {
@@ -688,7 +683,7 @@ static void HdmiFrlTrainingResultHandleTimeout(struct HdmiFrl *frl)
     }
 
     do {
-        frlStart = HdmiFrlGetFrlStart(cntlr->scdc);
+        bool frlStart = HdmiFrlGetFrlStart(cntlr->scdc);
         if (frlStart == true && frl->info.start == true) {
             frl->info.work = true;
             /* n/cts config */
@@ -705,7 +700,7 @@ static void HdmiFrlTrainingResultHandleTimeout(struct HdmiFrl *frl)
             break;
         }
 
-        curTime = OsalGetSysTimeMs();
+        uint64_t curTime = OsalGetSysTimeMs();
         if ((curTime - frl->info.machineInfo.startTime) > frl->info.machineInfo.waitHandleTime) {
             (frl->info.machineInfo.timeoutCnt)++;
             break;
@@ -797,7 +792,6 @@ void HdmiFrlEnable(struct HdmiFrl *frl, bool enable)
 
 int32_t HdmiFrlModeSelect(struct HdmiFrl *frl)
 {
-    int32_t ret;
     struct HdmiCntlr *cntlr = NULL;
     struct HdmiVideoAttr *videoAttr = NULL;
 
@@ -805,7 +799,7 @@ int32_t HdmiFrlModeSelect(struct HdmiFrl *frl)
         return HDF_ERR_INVALID_PARAM;
     }
 
-    ret = HdmiFrlCheckFrlCapability(frl);
+    int32_t ret = HdmiFrlCheckFrlCapability(frl);
     if (ret != HDF_SUCCESS) {
         HDF_LOGD("frl check capability fail, change to TMDS.");
         frl->info.mode = HDMI_FRL_MODE_TMDS;
diff --git a/framework/support/platform/src/hdmi/hdmi_hdcp.c b/framework/support/platform/src/hdmi/hdmi_hdcp.c
index 0874830932618931894a8a4025da5bd124e2092a..369260fd5f9108aab84628f77966927d2adaf611 100644
--- a/framework/support/platform/src/hdmi/hdmi_hdcp.c
+++ b/framework/support/platform/src/hdmi/hdmi_hdcp.c
@@ -124,18 +124,16 @@ static int32_t HdmiHdcpWriteMsgAn(struct HdmiHdcp *hdcp)
 
 static int32_t HdmiHdcpReadMsgHv(struct HdmiHdcp *hdcp)
 {
-    uint8_t offset;
     uint8_t i;
     uint8_t vhNum = HDMI_HDCP_MSG_ALL_VH_LEN / HDMI_HDCP_MSG_PER_VH_LEN;
-    int32_t ret;
 
     if (hdcp == NULL) {
         return HDF_ERR_INVALID_PARAM;
     }
 
     for (i = 0; i < vhNum; i++) {
-        offset = HDMI_HDCP_V_H0 + i * HDMI_HDCP_MSG_PER_VH_LEN;
-        ret = HdmiHdcpRead(hdcp, offset, &(hdcp->vh[i]), HDMI_HDCP_MSG_PER_VH_LEN);
+        uint8_t offset = HDMI_HDCP_V_H0 + i * HDMI_HDCP_MSG_PER_VH_LEN;
+        int32_t ret = HdmiHdcpRead(hdcp, offset, &(hdcp->vh[i]), HDMI_HDCP_MSG_PER_VH_LEN);
         if (ret != HDF_SUCCESS) {
             return ret;
         }
@@ -145,8 +143,7 @@ static int32_t HdmiHdcpReadMsgHv(struct HdmiHdcp *hdcp)
 
 static int32_t HdmiHdcpReadMsgBcaps(struct HdmiHdcp *hdcp)
 {
-    int32_t ret;
-    ret = HdmiHdcpRead(hdcp, HDMI_HDCP_BCAPS, &(hdcp->bcaps), sizeof(hdcp->bcaps));
+    int32_t ret = HdmiHdcpRead(hdcp, HDMI_HDCP_BCAPS, &(hdcp->bcaps), sizeof(hdcp->bcaps));
     if (ret != HDF_SUCCESS) {
         return ret;
     }
@@ -175,11 +172,9 @@ static void HdmiHdcpRegPrepare(const struct HdmiHdcp *hdcp)
 
 static int32_t HdmiHdcpAuthenticationPrepare(struct HdmiHdcp *hdcp)
 {
-    int32_t ret;
-
     HdmiHdcpRegPrepare(hdcp);
     if (hdcp->aksvValid == false) {
-        ret = HdmiHdcpAuthenticationGenerateAksvAn(hdcp);
+        int32_t ret = HdmiHdcpAuthenticationGenerateAksvAn(hdcp);
         if (ret != HDF_SUCCESS) {
             hdcp->state = HDMI_HDCP_AUTH_AKSV_INVALID;
             return ret;
@@ -191,14 +186,12 @@ static int32_t HdmiHdcpAuthenticationPrepare(struct HdmiHdcp *hdcp)
 
 static int32_t HdmiHdcpAuthenticationFirstPart(struct HdmiHdcp *hdcp)
 {
-    int32_t ret;
-
     hdcp->state = HDMI_HDCP_AUTH_DOING;
     /*
     * Authentication is initiated by the HDCP Transmitter by sendind an initiation massage containing its KSV(aksv)
     * and a 64-bit pseudo-random value(An) generated by the HDCP Cipher function hdcpRngCipher to the HDCP Reciever.
     */
-    ret = HdmiHdcpWriteMsgAksv(hdcp);
+    int32_t ret = HdmiHdcpWriteMsgAksv(hdcp);
     if (ret != HDF_SUCCESS) {
         return ret;
     }
@@ -241,10 +234,9 @@ static int32_t HdmiHdcpAuthenticationFirstPart(struct HdmiHdcp *hdcp)
 
 static int32_t HdmiHdcpAuthenticationCheckBstatus(struct HdmiHdcp *hdcp)
 {
-    int32_t ret;
     uint16_t bstatus;
 
-    ret = HdmiHdcpRead(hdcp, HDMI_HDCP_BSTATUS, hdcp->bstatus, sizeof(hdcp->bstatus));
+    int32_t ret = HdmiHdcpRead(hdcp, HDMI_HDCP_BSTATUS, hdcp->bstatus, sizeof(hdcp->bstatus));
     if (ret != HDF_SUCCESS) {
         return ret;
     }
@@ -337,10 +329,8 @@ static int32_t HdmiHdcpAuthenticationReadKsvList(struct HdmiHdcp *hdcp)
 
 static int32_t HdmiHdcpAuthenticationSecondPart(struct HdmiHdcp *hdcp)
 {
-    int32_t ret;
-
     /* Poll: KSV list ready. */
-    ret = HdmiHdcpAuthenticationWaitKsvListReady(hdcp);
+    int32_t ret = HdmiHdcpAuthenticationWaitKsvListReady(hdcp);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("hdcp auth, wait ksv list ready fail.");
         return ret;
@@ -381,14 +371,12 @@ static void HdmiHdcpAuthenticationFail(struct HdmiHdcp *hdcp)
 
 static int32_t HdmiHdcpAuthentication(struct HdmiHdcp *hdcp)
 {
-    int32_t ret;
-
     if (hdcp == NULL || hdcp->priv == NULL) {
         return HDF_ERR_INVALID_PARAM;
     }
 
     /* auth prepare, get aksv and driver clear registers. */
-    ret = HdmiHdcpAuthenticationPrepare(hdcp);
+    int32_t ret = HdmiHdcpAuthenticationPrepare(hdcp);
     if (ret != HDF_SUCCESS) {
         HdmiHdcpAuthenticationFail(hdcp);
         return ret;
@@ -437,12 +425,10 @@ static int32_t HdmiHdcpAuthenticationRetry(struct HdmiHdcp *hdcp)
 
 int32_t HdmiHdcpOpen(struct HdmiHdcp *hdcp)
 {
-    int32_t ret;
-
     (void)OsalMutexLock(&(hdcp->hdcpMutex));
     hdcp->state = HDMI_HDCP_AUTH_INACTIVE;
     hdcp->authRetryCnt = 0;
-    ret = HdmiHdcpAuthentication(hdcp);
+    int32_t ret = HdmiHdcpAuthentication(hdcp);
     if (ret == HDF_SUCCESS) {
         HDF_LOGD("hdcp Authentication success!");
         (void)OsalMutexUnlock(&(hdcp->hdcpMutex));
diff --git a/framework/support/platform/src/hdmi/hdmi_infoframe.c b/framework/support/platform/src/hdmi/hdmi_infoframe.c
index 351e2452d7d66ae5d68974fff7655988edd7049f..30df5dae2dce9f244b75db65c3e1000f6c332020 100644
--- a/framework/support/platform/src/hdmi/hdmi_infoframe.c
+++ b/framework/support/platform/src/hdmi/hdmi_infoframe.c
@@ -18,10 +18,9 @@
 
 static void HdmiInfoFrameFillCheckSum(uint8_t *data, uint32_t len)
 {
-    uint32_t i;
     uint8_t checkSum = 0;
 
-    for (i = 0; i < len; i++) {
+    for (uint32_t i = 0; i < len; i++) {
         checkSum += data[i];
     }
     if (checkSum > 0) {
@@ -47,12 +46,11 @@ static void HdmiInfoFrameFillHeader(const struct HdmiInfoFrameHeader *header, ui
 
 static int32_t HdmiInfoFramePacketVsEncoding(union HdmiInfoFrameInfo *infoFrame, uint8_t *data, uint32_t len)
 {
-    uint32_t length;
     struct HdmiVs14VsifContent *vsifContent = NULL;
     struct HdmiVsUserVsifContent *userContent = NULL;
     struct HdmiVsInfoFrame *vs = &(infoFrame->vs);
 
-    length = HDMI_INFOFRAME_PACKET_HEADER_LEN + vs->len;
+    uint32_t length = HDMI_INFOFRAME_PACKET_HEADER_LEN + vs->len;
     if (len < length) {
         HDF_LOGE("len = %u, val is too small.", len);
         return HDF_ERR_INVALID_PARAM;
@@ -97,11 +95,10 @@ static int32_t HdmiInfoFramePacketVsEncoding(union HdmiInfoFrameInfo *infoFrame,
 
 static int32_t HdmiInfoFramePacketAviEncoding(union HdmiInfoFrameInfo *infoFrame, uint8_t *data, uint32_t len)
 {
-    uint32_t length;
     uint8_t *buff = data;
     struct HdmiAviInfoFrame *avi = &(infoFrame->avi);
 
-    length = HDMI_INFOFRAME_PACKET_HEADER_LEN + avi->len;
+    uint32_t length = HDMI_INFOFRAME_PACKET_HEADER_LEN + avi->len;
     if (len < length) {
         HDF_LOGE("len = %u, val is too small.", len);
         return HDF_ERR_INVALID_PARAM;
@@ -171,11 +168,10 @@ static int32_t HdmiInfoFramePacketAviEncoding(union HdmiInfoFrameInfo *infoFrame
 
 static int32_t HdmiInfoFramePacketSpdEncoding(union HdmiInfoFrameInfo *infoFrame, uint8_t *data, uint32_t len)
 {
-    uint32_t length;
     uint8_t *buff = data;
     struct HdmiSpdInfoFrame *spd = &(infoFrame->spd);
 
-    length = HDMI_INFOFRAME_PACKET_HEADER_LEN + spd->len;
+    uint32_t length = HDMI_INFOFRAME_PACKET_HEADER_LEN + spd->len;
     if (len < length) {
         HDF_LOGE("len = %u, val is too small.", len);
         return HDF_ERR_INVALID_PARAM;
@@ -207,11 +203,10 @@ static int32_t HdmiInfoFramePacketSpdEncoding(union HdmiInfoFrameInfo *infoFrame
 
 static int32_t HdmiInfoFramePacketAudioEncoding(union HdmiInfoFrameInfo *infoFrame, uint8_t *data, uint32_t len)
 {
-    uint32_t length;
     uint8_t *buff = data;
     struct HdmiAudioInfoFrame *audio = &(infoFrame->audio);
 
-    length = HDMI_INFOFRAME_PACKET_HEADER_LEN + audio->len;
+    uint32_t length = HDMI_INFOFRAME_PACKET_HEADER_LEN + audio->len;
     if (len < length) {
         HDF_LOGE("len = %u, val is too small.", len);
         return HDF_ERR_INVALID_PARAM;
@@ -248,12 +243,11 @@ static int32_t HdmiInfoFramePacketAudioEncoding(union HdmiInfoFrameInfo *infoFra
 
 static int32_t HdmiInfoFramePacketDrmEncoding(union HdmiInfoFrameInfo *infoFrame, uint8_t *data, uint32_t len)
 {
-    uint32_t length;
     uint8_t *buff = data;
     struct HdmiDrmInfoFrame *drm = &(infoFrame->drm);
     struct HdmiStaticMetadataDescriptor1st *des = &(drm->des.type1);
 
-    length = HDMI_INFOFRAME_PACKET_HEADER_LEN + drm->len;
+    uint32_t length = HDMI_INFOFRAME_PACKET_HEADER_LEN + drm->len;
     if (len < length) {
         HDF_LOGE("len = %u, val is too small.", len);
         return HDF_ERR_INVALID_PARAM;
@@ -368,7 +362,6 @@ static int32_t HdmiInfoFrameSend(struct HdmiInfoFrame *frame, union HdmiInfoFram
 {
     uint8_t buffer[HDMI_INFOFRAME_LEN] = {0};
     struct HdmiCntlr *cntlr = NULL;
-    int32_t ret;
 
     if (frame == NULL || frame->priv == NULL || infoFrame == NULL) {
         HDF_LOGE("HdmiInfoFrameSend: input param is invalid.");
@@ -380,7 +373,7 @@ static int32_t HdmiInfoFrameSend(struct HdmiInfoFrame *frame, union HdmiInfoFram
         return HDF_ERR_NOT_SUPPORT;
     }
 
-    ret = HdmiInfoFramePacketEncoding(infoFrame, infoFrame->header.type, buffer, HDMI_INFOFRAME_LEN);
+    int32_t ret = HdmiInfoFramePacketEncoding(infoFrame, infoFrame->header.type, buffer, HDMI_INFOFRAME_LEN);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("encding infoFrame %d fail", infoFrame->header.type);
         return ret;
@@ -653,7 +646,6 @@ static void HdmiFill14Vsif(struct HdmiVsInfoFrame *vs, const struct HdmiVideoAtt
     struct HdmiVideo4kInfo *info = NULL;
     struct HdmiVs14VsifContent *vsif = &(vs->vsifContent.vsif);
     enum HdmiVic vic;
-    uint32_t cnt;
 
     vsif->oui = HDMI_IEEE_OUI_1_4;
     vic = HdmiCommonGetVic(videoAttr->timing, videoAttr->aspect, false);
@@ -661,7 +653,7 @@ static void HdmiFill14Vsif(struct HdmiVsInfoFrame *vs, const struct HdmiVideoAtt
         vic == HDMI_VIC_3840X2160P30_16_9 || vic == HDMI_VIC_4096X2160P24_256_135) &&
         videoAttr->_3dStruct == HDMI_VS_VIDEO_3D_BUTT) {
         vsif->format = HDMI_VS_VIDEO_FORMAT_4K;
-        for (cnt = 0; cnt <= HDMI_VIDEO_4K_CODES_MAX; cnt++) {
+        for (uint32_t cnt = 0; cnt <= HDMI_VIDEO_4K_CODES_MAX; cnt++) {
             info = HdmiCommonGetVideo4kInfo(cnt);
             if (info != NULL && info->timing == videoAttr->timing) {
                 vsif->vic = info->_4kVic;
@@ -681,9 +673,8 @@ static void HdmiFillVsInfoFrame(struct HdmiInfoFrame *frame, const struct HdmiVi
     bool dolbyEnable, bool hdrSupport)
 {
     struct HdmiVsInfoFrame *vs = &(frame->vs);
-    int32_t ret;
 
-    ret = memset_s(vs, sizeof(struct HdmiVsInfoFrame), 0, sizeof(struct HdmiVsInfoFrame));
+    int32_t ret = memset_s(vs, sizeof(struct HdmiVsInfoFrame), 0, sizeof(struct HdmiVsInfoFrame));
     if (ret != EOK) {
         HDF_LOGE("fill vsif, memset_s fail.");
         return;
@@ -730,7 +721,6 @@ static void HdmiFillSpdInfoFrame(struct HdmiSpdInfoFrame *spd,
                                  enum HdmiSpdSdi sdi)
 {
     uint32_t len;
-    uint32_t length;
 
     if (memset_s(spd, sizeof(struct HdmiSpdInfoFrame), 0, sizeof(struct HdmiSpdInfoFrame)) != EOK) {
         HDF_LOGE("fill spd infoFrame, memset_s fail.");
@@ -742,7 +732,7 @@ static void HdmiFillSpdInfoFrame(struct HdmiSpdInfoFrame *spd,
     spd->sdi = sdi;
 
     len = (uint32_t)strlen(vendorName);
-    length = (uint32_t)sizeof(spd->vendorName);
+    uint32_t length = (uint32_t)sizeof(spd->vendorName);
     length = (length > len) ? len : length;
     if (memcpy_s(spd->vendorName, length, vendorName, length) != EOK) {
         HDF_LOGE("fill spd infoFrame vendor name, memcpy_s fail.");
diff --git a/framework/support/platform/src/hdmi/hdmi_scdc.c b/framework/support/platform/src/hdmi/hdmi_scdc.c
index d5d242bd5b6f4271ee13b7c9d18ab981c8a427bf..182aeffcadbb9556a896cee1bf5e6739dfbfb6e8 100644
--- a/framework/support/platform/src/hdmi/hdmi_scdc.c
+++ b/framework/support/platform/src/hdmi/hdmi_scdc.c
@@ -171,13 +171,11 @@ static bool HdmiCntlrScdcSourceScrambleGet(struct HdmiCntlr *cntlr)
 
 static int32_t HdmiCntlrScdcSourceScrambleSet(struct HdmiCntlr *cntlr, bool enable)
 {
-    int32_t ret;
-
     if (cntlr == NULL || cntlr->ops == NULL || cntlr->ops->scdcSourceScrambleSet == NULL) {
         return HDF_ERR_INVALID_OBJECT;
     }
     HdmiCntlrLock(cntlr);
-    ret = cntlr->ops->scdcSourceScrambleSet(cntlr, enable);
+    int32_t ret = cntlr->ops->scdcSourceScrambleSet(cntlr, enable);
     HdmiCntlrUnlock(cntlr);
     return ret;
 }
@@ -187,13 +185,12 @@ int32_t HdmiScdcRrDisable(struct HdmiScdc *scdc)
 {
     union HdmiScdcsConfig0 cfg = {0};
     union HdmiScdcsTestConfig0 testCfg = {0};
-    int32_t ret;
 
     if (scdc == NULL) {
         return HDF_ERR_INVALID_PARAM;
     }
 
-    ret = HdmiScdcWriteConfig0(scdc, &(cfg.data));
+    int32_t ret = HdmiScdcWriteConfig0(scdc, &(cfg.data));
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("scdc write config0 fail");
         return ret;
@@ -212,13 +209,12 @@ int32_t HdmiScdcRrDisable(struct HdmiScdc *scdc)
 int32_t HdmiScdcScrambleSet(struct HdmiScdc *scdc, struct HdmiScdcScrambleCap *scramble)
 {
     union HdmiScdcsTmdsConfig cfg = {0};
-    int32_t ret;
 
     if (scdc == NULL) {
         return HDF_ERR_INVALID_PARAM;
     }
 
-    ret = HdmiCntlrScdcSourceScrambleSet((struct HdmiCntlr *)scdc->priv, scramble->sourceScramble);
+    int32_t ret = HdmiCntlrScdcSourceScrambleSet((struct HdmiCntlr *)scdc->priv, scramble->sourceScramble);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("scdc source scrambler set fail");
         return ret;
@@ -242,13 +238,12 @@ int32_t HdmiScdcScrambleGet(struct HdmiScdc *scdc, struct HdmiScdcScrambleCap *s
 {
     union HdmiScdcsScramblerStatus status = {0};
     union HdmiScdcsTmdsConfig cfg = {0};
-    int32_t ret;
 
     if (scdc == NULL) {
         return HDF_ERR_INVALID_PARAM;
     }
 
-    ret = HdmiScdcReadScramblerStatus(scdc, &(status.data));
+    int32_t ret = HdmiScdcReadScramblerStatus(scdc, &(status.data));
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("scdc read scrambler status fail");
         return ret;
@@ -270,17 +265,13 @@ int32_t HdmiScdcScrambleGet(struct HdmiScdc *scdc, struct HdmiScdcScrambleCap *s
 
 bool HdmiScdcSinkSupport(struct HdmiScdc *scdc)
 {
-    uint8_t srcVer;
-    uint8_t i;
-    int32_t ret;
-
     if (scdc == NULL) {
         return HDF_ERR_INVALID_PARAM;
     }
 
-    for (i = 0; i < HDMI_SCDC_READ_SOURCE_VERSION_TIMES; i++) {
-        srcVer = HDMI_SCDC_HDMI20_VERSION;
-        ret = HdmiScdcWriteSourceVersion(scdc, &srcVer);
+    for (uint8_t i = 0; i < HDMI_SCDC_READ_SOURCE_VERSION_TIMES; i++) {
+        uint8_t srcVer = HDMI_SCDC_HDMI20_VERSION;
+        int32_t ret = HdmiScdcWriteSourceVersion(scdc, &srcVer);
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("scdc write source version fail");
             return false;
diff --git a/framework/support/platform/src/i2s/i2s_core.c b/framework/support/platform/src/i2s/i2s_core.c
index 6cf76d740532154c3464ece0be5294f34f41550c..b1626ad5a658ad3ccb53ec27d6793cd5c4fb5558 100644
--- a/framework/support/platform/src/i2s/i2s_core.c
+++ b/framework/support/platform/src/i2s/i2s_core.c
@@ -17,8 +17,6 @@
 
 int32_t I2sCntlrOpen(struct I2sCntlr *cntlr)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("I2sCntlrOpen: cntlr is null!");
         return HDF_ERR_INVALID_PARAM;
@@ -28,15 +26,13 @@ int32_t I2sCntlrOpen(struct I2sCntlr *cntlr)
         return HDF_ERR_NOT_SUPPORT;
     }
     (void)OsalMutexLock(&(cntlr->lock));
-    ret = cntlr->method->Open(cntlr);
+    int32_t ret = cntlr->method->Open(cntlr);
     (void)OsalMutexUnlock(&(cntlr->lock));
     return ret;
 }
 
 int32_t I2sCntlrClose(struct I2sCntlr *cntlr)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("I2sCntlrClose: cntlr is null!");
         return HDF_ERR_INVALID_PARAM;
@@ -46,15 +42,13 @@ int32_t I2sCntlrClose(struct I2sCntlr *cntlr)
         return HDF_ERR_NOT_SUPPORT;
     }
     (void)OsalMutexLock(&(cntlr->lock));
-    ret = cntlr->method->Close(cntlr);
+    int32_t ret = cntlr->method->Close(cntlr);
     (void)OsalMutexUnlock(&(cntlr->lock));
     return ret;
 }
 
 int32_t I2sCntlrEnable(struct I2sCntlr *cntlr)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("I2sCntlrEnable: cntlr is null!");
         return HDF_ERR_INVALID_PARAM;
@@ -64,15 +58,13 @@ int32_t I2sCntlrEnable(struct I2sCntlr *cntlr)
         return HDF_ERR_NOT_SUPPORT;
     }
     (void)OsalMutexLock(&(cntlr->lock));
-    ret = cntlr->method->Enable(cntlr);
+    int32_t ret = cntlr->method->Enable(cntlr);
     (void)OsalMutexUnlock(&(cntlr->lock));
     return ret;
 }
 
 int32_t I2sCntlrDisable(struct I2sCntlr *cntlr)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("I2sCntlrDisable: cntlr is null!");
         return HDF_ERR_INVALID_PARAM;
@@ -82,15 +74,13 @@ int32_t I2sCntlrDisable(struct I2sCntlr *cntlr)
         return HDF_ERR_NOT_SUPPORT;
     }
     (void)OsalMutexLock(&(cntlr->lock));
-    ret = cntlr->method->Disable(cntlr);
+    int32_t ret = cntlr->method->Disable(cntlr);
     (void)OsalMutexUnlock(&(cntlr->lock));
     return ret;
 }
 
 int32_t I2sCntlrStartRead(struct I2sCntlr *cntlr)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("I2sCntlrStartRead: cntlr is null!");
         return HDF_ERR_INVALID_PARAM;
@@ -101,7 +91,7 @@ int32_t I2sCntlrStartRead(struct I2sCntlr *cntlr)
     }
 
     (void)OsalMutexLock(&(cntlr->lock));
-    ret = cntlr->method->StartRead(cntlr);
+    int32_t ret = cntlr->method->StartRead(cntlr);
     if (PlatformTraceStart() == HDF_SUCCESS) {
         unsigned int infos[I2S_TRACE_BASIC_PARAM_NUM];
         infos[PLATFORM_TRACE_UINT_PARAM_SIZE_1 - 1] = cntlr->busNum;
@@ -116,8 +106,6 @@ int32_t I2sCntlrStartRead(struct I2sCntlr *cntlr)
 
 int32_t I2sCntlrStopRead(struct I2sCntlr *cntlr)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("I2sCntlrStopRead: cntlr is null!");
         return HDF_ERR_INVALID_PARAM;
@@ -127,15 +115,13 @@ int32_t I2sCntlrStopRead(struct I2sCntlr *cntlr)
         return HDF_ERR_NOT_SUPPORT;
     }
     (void)OsalMutexLock(&(cntlr->lock));
-    ret = cntlr->method->StopRead(cntlr);
+    int32_t ret = cntlr->method->StopRead(cntlr);
     (void)OsalMutexUnlock(&(cntlr->lock));
     return ret;
 }
 
 int32_t I2sCntlrStartWrite(struct I2sCntlr *cntlr)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("I2sCntlrStartWrite: cntlr is null!");
         return HDF_ERR_INVALID_PARAM;
@@ -145,7 +131,7 @@ int32_t I2sCntlrStartWrite(struct I2sCntlr *cntlr)
         return HDF_ERR_NOT_SUPPORT;
     }
     (void)OsalMutexLock(&(cntlr->lock));
-    ret = cntlr->method->StartWrite(cntlr);
+    int32_t ret = cntlr->method->StartWrite(cntlr);
     if (PlatformTraceStart() == HDF_SUCCESS) {
         unsigned int infos[I2S_TRACE_PARAM_WRITE_NUM];
         infos[PLATFORM_TRACE_UINT_PARAM_SIZE_1 - 1] = cntlr->busNum;
@@ -161,8 +147,6 @@ int32_t I2sCntlrStartWrite(struct I2sCntlr *cntlr)
 
 int32_t I2sCntlrStopWrite(struct I2sCntlr *cntlr)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("I2sCntlrStopWrite: cntlr is null!");
         return HDF_ERR_INVALID_PARAM;
@@ -172,15 +156,13 @@ int32_t I2sCntlrStopWrite(struct I2sCntlr *cntlr)
         return HDF_ERR_NOT_SUPPORT;
     }
     (void)OsalMutexLock(&(cntlr->lock));
-    ret = cntlr->method->StopWrite(cntlr);
+    int32_t ret = cntlr->method->StopWrite(cntlr);
     (void)OsalMutexUnlock(&(cntlr->lock));
     return ret;
 }
 
 int32_t I2sCntlrSetCfg(struct I2sCntlr *cntlr, struct I2sCfg *cfg)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("I2sCntlrSetCfg: cntlr is null!");
         return HDF_ERR_INVALID_PARAM;
@@ -192,15 +174,13 @@ int32_t I2sCntlrSetCfg(struct I2sCntlr *cntlr, struct I2sCfg *cfg)
     }
 
     (void)OsalMutexLock(&(cntlr->lock));
-    ret = cntlr->method->SetCfg(cntlr, cfg);
+    int32_t ret = cntlr->method->SetCfg(cntlr, cfg);
     (void)OsalMutexUnlock(&(cntlr->lock));
     return ret;
 }
 
 int32_t I2sCntlrGetCfg(struct I2sCntlr *cntlr, struct I2sCfg *cfg)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("I2sCntlrGetCfg: cntlr is null!");
         return HDF_ERR_INVALID_PARAM;
@@ -212,15 +192,13 @@ int32_t I2sCntlrGetCfg(struct I2sCntlr *cntlr, struct I2sCfg *cfg)
     }
 
     (void)OsalMutexLock(&(cntlr->lock));
-    ret = cntlr->method->GetCfg(cntlr, cfg);
+    int32_t ret = cntlr->method->GetCfg(cntlr, cfg);
     (void)OsalMutexUnlock(&(cntlr->lock));
     return ret;
 }
 
 int32_t I2sCntlrTransfer(struct I2sCntlr *cntlr, struct I2sMsg *msg)
 {
-    int32_t ret;
-
     if (cntlr == NULL || msg == NULL) {
         HDF_LOGE("I2sCntlrTransfer: cntlr or msg is null!");
         return HDF_ERR_INVALID_PARAM;
@@ -231,7 +209,7 @@ int32_t I2sCntlrTransfer(struct I2sCntlr *cntlr, struct I2sMsg *msg)
     }
 
     (void)OsalMutexLock(&(cntlr->lock));
-    ret = cntlr->method->Transfer(cntlr, msg);
+    int32_t ret = cntlr->method->Transfer(cntlr, msg);
     (void)OsalMutexUnlock(&(cntlr->lock));
     return ret;
 }
diff --git a/framework/support/platform/src/i3c/i3c_core.c b/framework/support/platform/src/i3c/i3c_core.c
index ae0cd235556de284c9a38173156084f39593e06d..76bbd04fe1e65bf8a26aa3f7a5832fea87768421 100644
--- a/framework/support/platform/src/i3c/i3c_core.c
+++ b/framework/support/platform/src/i3c/i3c_core.c
@@ -96,14 +96,12 @@ static void I3cDeviceListPut(void)
 
 static int32_t GetAddrStatus(const struct I3cCntlr *cntlr, uint16_t addr)
 {
-    int32_t status;
-
     if (addr > I3C_ADDR_MAX) {
         HDF_LOGE("GetAddrStatus: The address 0x%x exceeds the maximum address!", addr);
         return HDF_ERR_INVALID_PARAM;
     }
 
-    status = ADDR_STATUS_MASK & ((cntlr->addrSlot[addr / ADDRS_PER_UINT16]) >>
+    int32_t status = ADDR_STATUS_MASK & ((cntlr->addrSlot[addr / ADDRS_PER_UINT16]) >>
         ((addr % ADDRS_PER_UINT16) * ADDRS_STATUS_BITS));
 
     return status;
@@ -111,10 +109,6 @@ static int32_t GetAddrStatus(const struct I3cCntlr *cntlr, uint16_t addr)
 
 static int32_t SetAddrStatus(struct I3cCntlr *cntlr, uint16_t addr, enum I3cAddrStatus status)
 {
-    uint16_t temp;
-    int32_t ret;
-    uint16_t statusMask;
-
     if (addr > I3C_ADDR_MAX) {
         HDF_LOGE("SetAddrStatus: The address 0x%x exceeds the maximum address!", addr);
         return HDF_ERR_INVALID_PARAM;
@@ -125,14 +119,14 @@ static int32_t SetAddrStatus(struct I3cCntlr *cntlr, uint16_t addr, enum I3cAddr
         return HDF_ERR_INVALID_PARAM;
     }
 
-    ret = I3cCntlrLock(cntlr);
+    int32_t ret = I3cCntlrLock(cntlr);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("SetAddrStatus: lock cntlr fail!");
         return ret;
     }
 
-    statusMask = ADDR_STATUS_MASK << ((addr % ADDRS_PER_UINT16) * ADDRS_STATUS_BITS);
-    temp = (cntlr->addrSlot[addr / (uint16_t)ADDRS_PER_UINT16]) & (uint16_t)~statusMask;
+    uint16_t statusMask = ADDR_STATUS_MASK << ((addr % ADDRS_PER_UINT16) * ADDRS_STATUS_BITS);
+    uint16_t temp = (cntlr->addrSlot[addr / (uint16_t)ADDRS_PER_UINT16]) & (uint16_t)~statusMask;
     temp |= (uint16_t)(((uint16_t)status) << ((addr % ADDRS_PER_UINT16) * ADDRS_STATUS_BITS));
     cntlr->addrSlot[addr / ADDRS_PER_UINT16] = temp;
 
@@ -143,9 +137,7 @@ static int32_t SetAddrStatus(struct I3cCntlr *cntlr, uint16_t addr, enum I3cAddr
 
 static void inline I3cInitAddrStatus(struct I3cCntlr *cntlr)
 {
-    uint16_t addr;
-
-    for (addr = 0; addr <= I3C_ADDR_MAX; addr++) {
+    for (uint16_t addr = 0; addr <= I3C_ADDR_MAX; addr++) {
         if (I3cCheckReservedAddr(addr) == I3C_ADDR_RESERVED) {
             (void)SetAddrStatus(cntlr, addr, I3C_ADDR_RESERVED);
         }
@@ -155,21 +147,19 @@ static void inline I3cInitAddrStatus(struct I3cCntlr *cntlr)
 static int32_t GetFreeAddr(struct I3cCntlr *cntlr)
 {
     enum I3cAddrStatus status;
-    int16_t count;
-    int32_t ret;
 
     if (cntlr == NULL) {
         HDF_LOGE("GetFreeAddr: cntlr is null!");
         return HDF_ERR_INVALID_PARAM;
     }
 
-    ret = I3cCntlrLock(cntlr);
+    int32_t ret = I3cCntlrLock(cntlr);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("GetFreeAddr: lock cntlr fail!");
         return ret;
     }
 
-    for (count = 0; count <= I3C_ADDR_MAX; count++) {
+    for (int16_t count = 0; count <= I3C_ADDR_MAX; count++) {
         status = (enum I3cAddrStatus)GetAddrStatus(cntlr, count);
         if (status == I3C_ADDR_FREE) {
             return (int32_t)count;
@@ -183,8 +173,6 @@ static int32_t GetFreeAddr(struct I3cCntlr *cntlr)
 
 int32_t I3cCntlrSendCccCmd(struct I3cCntlr *cntlr, struct I3cCccCmd *ccc)
 {
-    int32_t ret;
-
     if (ccc == NULL) {
         HDF_LOGE("I3cCntlrSendCccCmd: ccc is null!");
         return HDF_ERR_INVALID_PARAM;
@@ -200,7 +188,7 @@ int32_t I3cCntlrSendCccCmd(struct I3cCntlr *cntlr, struct I3cCccCmd *ccc)
         return HDF_ERR_DEVICE_BUSY;
     }
 
-    ret = cntlr->ops->sendCccCmd(cntlr, ccc);
+    int32_t ret = cntlr->ops->sendCccCmd(cntlr, ccc);
     I3cCntlrUnlock(cntlr);
 
     return ret;
@@ -248,12 +236,9 @@ struct I3cDevice *I3cGetDeviceByAddr(const struct I3cCntlr *cntlr, uint16_t addr
 
 static int32_t I3cDeviceDefineI3cDevices(struct I3cDevice *device)
 {
-    int32_t ret;
-    int32_t addr;
-
-    ret = SetAddrStatus(device->cntlr, device->addr, I3C_ADDR_I3C_DEVICE);
+    int32_t ret = SetAddrStatus(device->cntlr, device->addr, I3C_ADDR_I3C_DEVICE);
     if (ret != HDF_SUCCESS) {
-        addr = GetFreeAddr(device->cntlr);
+        int32_t addr = GetFreeAddr(device->cntlr);
         if (addr <= 0) {
             HDF_LOGE("I3cDeviceDefineI3cDevices: no free addresses left!");
             return HDF_ERR_DEVICE_BUSY;
@@ -314,14 +299,12 @@ int32_t I3cDeviceAdd(struct I3cDevice *device)
 
 void I3cDeviceRemove(struct I3cDevice *device)
 {
-    int32_t ret;
-
     if (device == NULL) {
         HDF_LOGE("I3cDeviceRemove: device is null!");
         return;
     }
 
-    ret = SetAddrStatus(device->cntlr, device->addr, I3C_ADDR_RESERVED);
+    int32_t ret = SetAddrStatus(device->cntlr, device->addr, I3C_ADDR_RESERVED);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("I3cDeviceRemove: set addr status fail!");
         return;
@@ -422,8 +405,6 @@ void I3cCntlrPut(struct I3cCntlr *cntlr)
 
 int32_t I3cCntlrAdd(struct I3cCntlr *cntlr)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("I3cCntlrAdd: cntlr is null!");
         return HDF_ERR_INVALID_OBJECT;
@@ -445,7 +426,7 @@ int32_t I3cCntlrAdd(struct I3cCntlr *cntlr)
     }
 
     I3cInitAddrStatus(cntlr);
-    ret = I3cManagerAddCntlr(cntlr);
+    int32_t ret = I3cManagerAddCntlr(cntlr);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("I3cCntlrAdd: i3c manager add cntlr fail!");
         (void)OsalSpinDestroy(&cntlr->lock);
@@ -467,8 +448,6 @@ void I3cCntlrRemove(struct I3cCntlr *cntlr)
 
 int32_t I3cCntlrTransfer(struct I3cCntlr *cntlr, struct I3cMsg *msgs, int16_t count)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("I3cCntlrTransfer: cntlr is null!");
         return HDF_ERR_INVALID_OBJECT;
@@ -484,7 +463,7 @@ int32_t I3cCntlrTransfer(struct I3cCntlr *cntlr, struct I3cMsg *msgs, int16_t co
         return HDF_ERR_DEVICE_BUSY;
     }
 
-    ret = cntlr->ops->Transfer(cntlr, msgs, count);
+    int32_t ret = cntlr->ops->Transfer(cntlr, msgs, count);
     I3cCntlrUnlock(cntlr);
 
     return ret;
@@ -492,8 +471,6 @@ int32_t I3cCntlrTransfer(struct I3cCntlr *cntlr, struct I3cMsg *msgs, int16_t co
 
 int32_t I3cCntlrI2cTransfer(struct I3cCntlr *cntlr, struct I3cMsg *msgs, int16_t count)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("I3cCntlrI2cTransfer: cntlr is null!");
         return HDF_ERR_INVALID_OBJECT;
@@ -508,7 +485,7 @@ int32_t I3cCntlrI2cTransfer(struct I3cCntlr *cntlr, struct I3cMsg *msgs, int16_t
         HDF_LOGE("I3cCntlrI2cTransfer: lock cntlr fail!");
         return HDF_ERR_DEVICE_BUSY;
     }
-    ret = cntlr->ops->i2cTransfer(cntlr, msgs, count);
+    int32_t ret = cntlr->ops->i2cTransfer(cntlr, msgs, count);
     I3cCntlrUnlock(cntlr);
 
     return ret;
@@ -516,8 +493,6 @@ int32_t I3cCntlrI2cTransfer(struct I3cCntlr *cntlr, struct I3cMsg *msgs, int16_t
 
 int32_t I3cCntlrSetConfig(struct I3cCntlr *cntlr, struct I3cConfig *config)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("I3cCntlrSetConfig: cntlr is null!");
         return HDF_ERR_INVALID_OBJECT;
@@ -538,7 +513,7 @@ int32_t I3cCntlrSetConfig(struct I3cCntlr *cntlr, struct I3cConfig *config)
         return HDF_ERR_DEVICE_BUSY;
     }
 
-    ret = cntlr->ops->setConfig(cntlr, config);
+    int32_t ret = cntlr->ops->setConfig(cntlr, config);
     cntlr->config = *config;
     I3cCntlrUnlock(cntlr);
 
@@ -547,8 +522,6 @@ int32_t I3cCntlrSetConfig(struct I3cCntlr *cntlr, struct I3cConfig *config)
 
 int32_t I3cCntlrGetConfig(struct I3cCntlr *cntlr, struct I3cConfig *config)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("I3cCntlrGetConfig: cntlr is null!");
         return HDF_ERR_INVALID_OBJECT;
@@ -569,7 +542,7 @@ int32_t I3cCntlrGetConfig(struct I3cCntlr *cntlr, struct I3cConfig *config)
         return HDF_ERR_DEVICE_BUSY;
     }
 
-    ret = cntlr->ops->getConfig(cntlr, config);
+    int32_t ret = cntlr->ops->getConfig(cntlr, config);
     cntlr->config = *config;
     I3cCntlrUnlock(cntlr);
 
@@ -580,7 +553,6 @@ int32_t I3cCntlrRequestIbi(struct I3cCntlr *cntlr, uint16_t addr, I3cIbiFunc fun
 {
     struct I3cDevice *device = NULL;
     struct I3cIbiInfo *ibi = NULL;
-    uint16_t ptr;
 
     if (cntlr == NULL || cntlr->ops == NULL || cntlr->ops->requestIbi == NULL) {
         HDF_LOGE("I3cCntlrRequestIbi: cntlr or ops or requestIbi is null!");
@@ -604,7 +576,7 @@ int32_t I3cCntlrRequestIbi(struct I3cCntlr *cntlr, uint16_t addr, I3cIbiFunc fun
         return HDF_ERR_DEVICE_BUSY;
     }
 
-    for (ptr = 0; ptr < I3C_IBI_MAX; ptr++) {
+    for (uint16_t ptr = 0; ptr < I3C_IBI_MAX; ptr++) {
         if (cntlr->ibiSlot[ptr] != NULL) {
             continue;
         }
@@ -631,7 +603,6 @@ int32_t I3cCntlrRequestIbi(struct I3cCntlr *cntlr, uint16_t addr, I3cIbiFunc fun
 int32_t I3cCntlrFreeIbi(struct I3cCntlr *cntlr, uint16_t addr)
 {
     struct I3cDevice *device = NULL;
-    uint16_t ptr;
 
     if (cntlr == NULL) {
         HDF_LOGE("I3cCntlrFreeIbi: cntlr is null!");
@@ -649,7 +620,7 @@ int32_t I3cCntlrFreeIbi(struct I3cCntlr *cntlr, uint16_t addr)
         return HDF_ERR_INVALID_OBJECT;
     }
 
-    for (ptr = 0; ptr < I3C_IBI_MAX; ptr++) {
+    for (uint16_t ptr = 0; ptr < I3C_IBI_MAX; ptr++) {
         if (cntlr->ibiSlot[ptr] == NULL || cntlr->ibiSlot[ptr] != device->ibi) {
             continue;
         }
@@ -709,7 +680,6 @@ static int32_t I3cManagerBind(struct HdfDeviceObject *device)
 
 static int32_t I3cManagerInit(struct HdfDeviceObject *device)
 {
-    int32_t ret;
     struct I3cManager *manager = NULL;
 
     HDF_LOGI("I3cManagerInit: enter!");
@@ -724,7 +694,7 @@ static int32_t I3cManagerInit(struct HdfDeviceObject *device)
         return HDF_ERR_MALLOC_FAIL;
     }
 
-    ret = OsalMutexInit(&manager->lock);
+    int32_t ret = OsalMutexInit(&manager->lock);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("I3cManagerInit: mutex init fail, ret: %d!", ret);
         OsalMemFree(manager);
diff --git a/framework/support/platform/src/pin/pin_core.c b/framework/support/platform/src/pin/pin_core.c
index 87d6a6665c186c5d5e5f505a624752ef1ddb199f..5426012fa3a98be6df83e1600ffaed52e29b6037 100644
--- a/framework/support/platform/src/pin/pin_core.c
+++ b/framework/support/platform/src/pin/pin_core.c
@@ -177,15 +177,12 @@ struct PinCntlr *PinCntlrGetByPin(const struct PinDesc *desc)
 
 static int32_t GetPinIndex(struct PinCntlr *cntlr, struct PinDesc *desc)
 {
-    uint16_t index;
-    int32_t ret;
-
-    for (index = 0; index < cntlr->pinCount; index++) {
+    for (uint16_t index = 0; index < cntlr->pinCount; index++) {
         if (cntlr->pins[index].pinName == NULL) {
             HDF_LOGE("GetPinIndex: cntlr->pin[index].pinName is null!");
             break;
         }
-        ret = strcmp(cntlr->pins[index].pinName, desc->pinName);
+        int32_t ret = strcmp(cntlr->pins[index].pinName, desc->pinName);
         if (ret == 0) {
             HDF_LOGI("GetPinIndex: get pin index:%hu success!", index);
             return (int32_t)index;
@@ -202,9 +199,6 @@ void PinCntlrPutPin(const struct PinDesc *desc)
 
 int32_t PinCntlrSetPinPull(struct PinCntlr *cntlr, struct PinDesc *desc, enum PinPullType pullType)
 {
-    int32_t ret;
-    uint32_t index;
-
     if (cntlr == NULL) {
         HDF_LOGE("PinCntlrSetPinPull: cntlr is null!!");
         return HDF_ERR_INVALID_OBJECT;
@@ -220,14 +214,14 @@ int32_t PinCntlrSetPinPull(struct PinCntlr *cntlr, struct PinDesc *desc, enum Pi
         return HDF_ERR_INVALID_PARAM;
     }
 
-    index = (uint32_t)GetPinIndex(cntlr, desc);
+    uint32_t index = (uint32_t)GetPinIndex(cntlr, desc);
     if (index < HDF_SUCCESS) {
         HDF_LOGE("PinCntlrSetPinPull: get pin index fail!");
         return HDF_ERR_INVALID_PARAM;
     }
 
     (void)OsalSpinLockIrqSave(&cntlr->spin, &g_pinmanager->irqSave);
-    ret = cntlr->method->SetPinPull(cntlr, index, pullType);
+    int32_t ret = cntlr->method->SetPinPull(cntlr, index, pullType);
     if (PlatformTraceStart() == HDF_SUCCESS) {
         unsigned int infos[PIN_TRACE_BASIC_PARAM_NUM];
         infos[PLATFORM_TRACE_UINT_PARAM_SIZE_1 - 1] = cntlr->number;
@@ -242,9 +236,6 @@ int32_t PinCntlrSetPinPull(struct PinCntlr *cntlr, struct PinDesc *desc, enum Pi
 
 int32_t PinCntlrGetPinPull(struct PinCntlr *cntlr, struct PinDesc *desc, enum PinPullType *pullType)
 {
-    int32_t ret;
-    uint32_t index;
-
     if (cntlr == NULL) {
         HDF_LOGE("PinCntlrGetPinPull: cntlr is null!");
         return HDF_ERR_INVALID_OBJECT;
@@ -265,14 +256,14 @@ int32_t PinCntlrGetPinPull(struct PinCntlr *cntlr, struct PinDesc *desc, enum Pi
         return HDF_ERR_INVALID_PARAM;
     }
 
-    index = (uint32_t)GetPinIndex(cntlr, desc);
+    uint32_t index = (uint32_t)GetPinIndex(cntlr, desc);
     if (index < HDF_SUCCESS) {
         HDF_LOGE("PinCntlrGetPinPull: get pin index fail!");
         return HDF_ERR_INVALID_PARAM;
     }
 
     (void)OsalSpinLockIrqSave(&cntlr->spin, &g_pinmanager->irqSave);
-    ret = cntlr->method->GetPinPull(cntlr, index, pullType);
+    int32_t ret = cntlr->method->GetPinPull(cntlr, index, pullType);
     if (PlatformTraceStart() == HDF_SUCCESS) {
         unsigned int infos[PIN_TRACE_PARAM_GET_NUM];
         infos[PLATFORM_TRACE_UINT_PARAM_SIZE_1 - 1] = cntlr->number;
@@ -288,9 +279,6 @@ int32_t PinCntlrGetPinPull(struct PinCntlr *cntlr, struct PinDesc *desc, enum Pi
 
 int32_t PinCntlrSetPinStrength(struct PinCntlr *cntlr, struct PinDesc *desc, uint32_t strength)
 {
-    int32_t ret;
-    uint32_t index;
-
     if (cntlr == NULL) {
         HDF_LOGE("PinCntlrSetPinStrength: cntlr is null!");
         return HDF_ERR_INVALID_OBJECT;
@@ -306,23 +294,20 @@ int32_t PinCntlrSetPinStrength(struct PinCntlr *cntlr, struct PinDesc *desc, uin
         return HDF_ERR_INVALID_PARAM;
     }
 
-    index = (uint32_t)GetPinIndex(cntlr, desc);
+    uint32_t index = (uint32_t)GetPinIndex(cntlr, desc);
     if (index < HDF_SUCCESS) {
         HDF_LOGE("PinCntlrSetPinStrength: get pin index fail!");
         return HDF_ERR_INVALID_PARAM;
     }
 
     (void)OsalSpinLockIrqSave(&cntlr->spin, &g_pinmanager->irqSave);
-    ret = cntlr->method->SetPinStrength(cntlr, index, strength);
+    int32_t ret = cntlr->method->SetPinStrength(cntlr, index, strength);
     (void)OsalSpinUnlockIrqRestore(&cntlr->spin, &g_pinmanager->irqSave);
     return ret;
 }
 
 int32_t PinCntlrGetPinStrength(struct PinCntlr *cntlr, struct PinDesc *desc, uint32_t *strength)
 {
-    int32_t ret;
-    uint32_t index;
-
     if (cntlr == NULL) {
         HDF_LOGE("PinCntlrGetPinStrength: cntlr is null!");
         return HDF_ERR_INVALID_OBJECT;
@@ -343,14 +328,14 @@ int32_t PinCntlrGetPinStrength(struct PinCntlr *cntlr, struct PinDesc *desc, uin
         return HDF_ERR_INVALID_PARAM;
     }
 
-    index = (uint32_t)GetPinIndex(cntlr, desc);
+    uint32_t index = (uint32_t)GetPinIndex(cntlr, desc);
     if (index < HDF_SUCCESS) {
         HDF_LOGE("PinCntlrGetPinStrength: get pin index fail!");
         return HDF_ERR_INVALID_PARAM;
     }
 
     (void)OsalSpinLockIrqSave(&cntlr->spin, &g_pinmanager->irqSave);
-    ret = cntlr->method->GetPinStrength(cntlr, index, strength);
+    int32_t ret = cntlr->method->GetPinStrength(cntlr, index, strength);
     (void)OsalSpinUnlockIrqRestore(&cntlr->spin, &g_pinmanager->irqSave);
 
     return ret;
@@ -358,9 +343,6 @@ int32_t PinCntlrGetPinStrength(struct PinCntlr *cntlr, struct PinDesc *desc, uin
 
 int32_t PinCntlrSetPinFunc(struct PinCntlr *cntlr, struct PinDesc *desc, const char *funcName)
 {
-    int32_t ret;
-    uint32_t index;
-
     if (cntlr == NULL) {
         HDF_LOGE("PinCntlrSetPinFunc: cntlr is null!");
         return HDF_ERR_INVALID_OBJECT;
@@ -381,23 +363,20 @@ int32_t PinCntlrSetPinFunc(struct PinCntlr *cntlr, struct PinDesc *desc, const c
         return HDF_ERR_INVALID_PARAM;
     }
 
-    index = (uint32_t)GetPinIndex(cntlr, desc);
+    uint32_t index = (uint32_t)GetPinIndex(cntlr, desc);
     if (index < HDF_SUCCESS) {
         HDF_LOGE("PinCntlrSetPinFunc: get pin index fail!");
         return HDF_ERR_INVALID_PARAM;
     }
 
     (void)OsalSpinLockIrqSave(&cntlr->spin, &g_pinmanager->irqSave);
-    ret = cntlr->method->SetPinFunc(cntlr, index, funcName);
+    int32_t ret = cntlr->method->SetPinFunc(cntlr, index, funcName);
     (void)OsalSpinUnlockIrqRestore(&cntlr->spin, &g_pinmanager->irqSave);
     return ret;
 }
 
 int32_t PinCntlrGetPinFunc(struct PinCntlr *cntlr, struct PinDesc *desc, const char **funcName)
 {
-    int32_t ret;
-    uint32_t index;
-
     if (cntlr == NULL) {
         HDF_LOGE("PinCntlrGetPinFunc: cntlr is null!");
         return HDF_ERR_INVALID_OBJECT;
@@ -418,14 +397,14 @@ int32_t PinCntlrGetPinFunc(struct PinCntlr *cntlr, struct PinDesc *desc, const c
         return HDF_ERR_INVALID_PARAM;
     }
 
-    index = (uint32_t)GetPinIndex(cntlr, desc);
+    uint32_t index = (uint32_t)GetPinIndex(cntlr, desc);
     if (index < HDF_SUCCESS) {
         HDF_LOGE("PinCntlrGetPinFunc: get pin index fail!");
         return HDF_ERR_INVALID_PARAM;
     }
 
     (void)OsalSpinLockIrqSave(&cntlr->spin, &g_pinmanager->irqSave);
-    ret = cntlr->method->GetPinFunc(cntlr, index, funcName);
+    int32_t ret = cntlr->method->GetPinFunc(cntlr, index, funcName);
     (void)OsalSpinUnlockIrqRestore(&cntlr->spin, &g_pinmanager->irqSave);
     return ret;
 }
@@ -489,7 +468,6 @@ static int32_t PinIoPut(struct HdfSBuf *data, struct HdfSBuf *reply)
 
 static int32_t PinIoSetPull(struct HdfSBuf *data, struct HdfSBuf *reply)
 {
-    int32_t ret;
     uint32_t pullType;
     DevHandle handle = NULL;
 
@@ -509,7 +487,7 @@ static int32_t PinIoSetPull(struct HdfSBuf *data, struct HdfSBuf *reply)
         return HDF_ERR_IO;
     }
 
-    ret = PinSetPull(handle, pullType);
+    int32_t ret = PinSetPull(handle, pullType);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("PinIoSetPull: pin set pull fail, ret: %d!", ret);
         return ret;
@@ -519,7 +497,6 @@ static int32_t PinIoSetPull(struct HdfSBuf *data, struct HdfSBuf *reply)
 
 static int32_t PinIoGetPull(struct HdfSBuf *data, struct HdfSBuf *reply)
 {
-    int32_t ret;
     uint32_t pullType;
     DevHandle handle = NULL;
 
@@ -533,7 +510,7 @@ static int32_t PinIoGetPull(struct HdfSBuf *data, struct HdfSBuf *reply)
         HDF_LOGE("PinIoGetPull: get handle fail!");
         return HDF_ERR_INVALID_PARAM;
     }
-    ret = PinGetPull(handle, &pullType);
+    int32_t ret = PinGetPull(handle, &pullType);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("PinIoGetPull: pin get pull fail, ret: %d!", ret);
         return ret;
@@ -548,7 +525,6 @@ static int32_t PinIoGetPull(struct HdfSBuf *data, struct HdfSBuf *reply)
 
 static int32_t PinIoSetStrength(struct HdfSBuf *data, struct HdfSBuf *reply)
 {
-    int32_t ret;
     uint32_t strength;
     DevHandle handle = NULL;
 
@@ -569,7 +545,7 @@ static int32_t PinIoSetStrength(struct HdfSBuf *data, struct HdfSBuf *reply)
         return HDF_ERR_IO;
     }
 
-    ret = PinSetStrength(handle, strength);
+    int32_t ret = PinSetStrength(handle, strength);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("PinIoSetStrength: pin set strength fail, ret: %d!", ret);
         return ret;
@@ -579,7 +555,6 @@ static int32_t PinIoSetStrength(struct HdfSBuf *data, struct HdfSBuf *reply)
 
 static int32_t PinIoGetStrength(struct HdfSBuf *data, struct HdfSBuf *reply)
 {
-    int32_t ret;
     uint32_t strength;
     DevHandle handle = NULL;
 
@@ -593,7 +568,7 @@ static int32_t PinIoGetStrength(struct HdfSBuf *data, struct HdfSBuf *reply)
         HDF_LOGE("PinIoGetStrength: get handle fail!");
         return HDF_ERR_INVALID_PARAM;
     }
-    ret = PinGetStrength(handle, &strength);
+    int32_t ret = PinGetStrength(handle, &strength);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("PinIoGetStrength: pin get strength fail, ret: %d!", ret);
         return ret;
@@ -608,7 +583,6 @@ static int32_t PinIoGetStrength(struct HdfSBuf *data, struct HdfSBuf *reply)
 
 static int32_t PinIoSetFunc(struct HdfSBuf *data, struct HdfSBuf *reply)
 {
-    int32_t ret;
     DevHandle handle = NULL;
     const char *funcNameData = NULL;
 
@@ -630,7 +604,7 @@ static int32_t PinIoSetFunc(struct HdfSBuf *data, struct HdfSBuf *reply)
         return HDF_ERR_IO;
     }
 
-    ret = PinSetFunc(handle, funcNameData);
+    int32_t ret = PinSetFunc(handle, funcNameData);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("PinIoSetFunc: pin set func fail, ret: %d!", ret);
         return ret;
@@ -640,7 +614,6 @@ static int32_t PinIoSetFunc(struct HdfSBuf *data, struct HdfSBuf *reply)
 
 static int32_t PinIoGetFunc(struct HdfSBuf *data, struct HdfSBuf *reply)
 {
-    int32_t ret;
     DevHandle handle = NULL;
     char *funcName = NULL;
 
@@ -654,7 +627,7 @@ static int32_t PinIoGetFunc(struct HdfSBuf *data, struct HdfSBuf *reply)
         HDF_LOGE("PinIoGetFunc: get handle fail!");
         return HDF_ERR_INVALID_PARAM;
     }
-    ret = PinGetFunc(handle, (const char **)&funcName);
+    int32_t ret = PinGetFunc(handle, (const char **)&funcName);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("PinIoGetFunc: pin get func fail, ret: %d!", ret);
         return ret;
diff --git a/framework/support/platform/src/pin/pin_if_u.c b/framework/support/platform/src/pin/pin_if_u.c
index 134b0e052403821509ea4f183dfbfcf1227a9092..928b529e7ed689886da842d3fec7817d6767daf7 100644
--- a/framework/support/platform/src/pin/pin_if_u.c
+++ b/framework/support/platform/src/pin/pin_if_u.c
@@ -88,7 +88,6 @@ static struct HdfIoService *PinManagerServiceGet(void)
 
 DevHandle PinGet(const char *pinName)
 {
-    int32_t ret;
     const char *copyName = NULL;
     struct HdfIoService *service = NULL;
     struct HdfSBuf *data = NULL;
@@ -116,7 +115,7 @@ DevHandle PinGet(const char *pinName)
         return NULL;
     }
 
-    ret = service->dispatcher->Dispatch(&service->object, PIN_IO_GET, data, NULL);
+    int32_t ret = service->dispatcher->Dispatch(&service->object, PIN_IO_GET, data, NULL);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("PinGet: PIN_IO_GET service process fail, ret: %d!", ret);
         HdfSbufRecycle(data);
@@ -136,7 +135,6 @@ DevHandle PinGet(const char *pinName)
 
 void PinPut(DevHandle handle)
 {
-    int32_t ret;
     struct HdfIoService *service = NULL;
     struct HdfSBuf *data = NULL;
 
@@ -165,7 +163,7 @@ void PinPut(DevHandle handle)
         return;
     }
 
-    ret = service->dispatcher->Dispatch(&service->object, PIN_IO_PUT, data, NULL);
+    int32_t ret = service->dispatcher->Dispatch(&service->object, PIN_IO_PUT, data, NULL);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("PinPut: PIN_IO_PUT service process fail, ret: %d!", ret);
     }
@@ -175,7 +173,6 @@ void PinPut(DevHandle handle)
 
 int32_t PinSetPull(DevHandle handle, enum PinPullType pullType)
 {
-    int32_t ret;
     struct HdfIoService *service = NULL;
     struct HdfSBuf *data = NULL;
 
@@ -208,7 +205,7 @@ int32_t PinSetPull(DevHandle handle, enum PinPullType pullType)
         return HDF_ERR_IO;
     }
 
-    ret = service->dispatcher->Dispatch(&service->object, PIN_IO_SET_PULL, data, NULL);
+    int32_t ret = service->dispatcher->Dispatch(&service->object, PIN_IO_SET_PULL, data, NULL);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("PinSetPull: PIN_IO_SET_PULL service process fail, ret: %d!", ret);
     }
@@ -218,7 +215,6 @@ int32_t PinSetPull(DevHandle handle, enum PinPullType pullType)
 
 int32_t PinGetPull(DevHandle handle, enum PinPullType *pullType)
 {
-    int32_t ret;
     struct HdfIoService *service = NULL;
     struct HdfSBuf *reply = NULL;
     struct HdfSBuf *data = NULL;
@@ -254,7 +250,7 @@ int32_t PinGetPull(DevHandle handle, enum PinPullType *pullType)
         return HDF_ERR_IO;
     }
 
-    ret = service->dispatcher->Dispatch(&service->object, PIN_IO_GET_PULL, data, reply);
+    int32_t ret = service->dispatcher->Dispatch(&service->object, PIN_IO_GET_PULL, data, reply);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("PinGetPull: PIN_IO_GET_PULL service process fail, ret: %d!", ret);
         HdfSbufRecycle(reply);
@@ -274,7 +270,6 @@ int32_t PinGetPull(DevHandle handle, enum PinPullType *pullType)
 
 int32_t PinSetStrength(DevHandle handle, uint32_t strength)
 {
-    int32_t ret;
     struct HdfIoService *service = NULL;
     struct HdfSBuf *data = NULL;
 
@@ -307,7 +302,7 @@ int32_t PinSetStrength(DevHandle handle, uint32_t strength)
         return HDF_ERR_IO;
     }
 
-    ret = service->dispatcher->Dispatch(&service->object, PIN_IO_SET_STRENGTH, data, NULL);
+    int32_t ret = service->dispatcher->Dispatch(&service->object, PIN_IO_SET_STRENGTH, data, NULL);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("PinSetStrength: PIN_IO_SET_STRENGTH service process fail, ret: %d!", ret);
     }
@@ -317,7 +312,6 @@ int32_t PinSetStrength(DevHandle handle, uint32_t strength)
 
 int32_t PinGetStrength(DevHandle handle, uint32_t *strength)
 {
-    int32_t ret;
     struct HdfIoService *service = NULL;
     struct HdfSBuf *reply = NULL;
     struct HdfSBuf *data = NULL;
@@ -353,7 +347,7 @@ int32_t PinGetStrength(DevHandle handle, uint32_t *strength)
         return HDF_ERR_IO;
     }
 
-    ret = service->dispatcher->Dispatch(&service->object, PIN_IO_GET_STRENGTH, data, reply);
+    int32_t ret = service->dispatcher->Dispatch(&service->object, PIN_IO_GET_STRENGTH, data, reply);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("PinGetStrength: PIN_IO_GET_STRENGTH service process fail, ret: %d!", ret);
         HdfSbufRecycle(reply);
@@ -373,7 +367,6 @@ int32_t PinGetStrength(DevHandle handle, uint32_t *strength)
 
 int32_t PinSetFunc(DevHandle handle, const char *funcName)
 {
-    int32_t ret;
     struct HdfIoService *service = NULL;
     struct HdfSBuf *data = NULL;
 
@@ -406,7 +399,7 @@ int32_t PinSetFunc(DevHandle handle, const char *funcName)
         return HDF_ERR_IO;
     }
 
-    ret = service->dispatcher->Dispatch(&service->object, PIN_IO_SET_FUNC, data, NULL);
+    int32_t ret = service->dispatcher->Dispatch(&service->object, PIN_IO_SET_FUNC, data, NULL);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("PinSetFunc: PIN_IO_SET_FUNC service process fail, ret: %d!", ret);
     }
@@ -439,7 +432,6 @@ static int32_t CopyFuncName(const char *pinName, const char *tempName, const cha
 
 int32_t PinGetFunc(DevHandle handle, const char **funcName)
 {
-    int32_t ret;
     struct HdfIoService *service = NULL;
     struct HdfSBuf *reply = NULL;
     struct HdfSBuf *data = NULL;
@@ -476,7 +468,7 @@ int32_t PinGetFunc(DevHandle handle, const char **funcName)
         return HDF_ERR_IO;
     }
 
-    ret = service->dispatcher->Dispatch(&service->object, PIN_IO_GET_FUNC, data, reply);
+    int32_t ret = service->dispatcher->Dispatch(&service->object, PIN_IO_GET_FUNC, data, reply);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("PinGetFunc: PIN_IO_GET_FUNC service process fail, ret: %d!", ret);
         HdfSbufRecycle(data);
diff --git a/framework/support/platform/src/pwm/pwm_core.c b/framework/support/platform/src/pwm/pwm_core.c
index 291298802426ef34b9c75387567e2bc1eb0fd673..c0164e8f8d84740d1c8d57eec108d851b779b9ee 100644
--- a/framework/support/platform/src/pwm/pwm_core.c
+++ b/framework/support/platform/src/pwm/pwm_core.c
@@ -14,8 +14,6 @@
 
 int32_t PwmDeviceGet(struct PwmDev *pwm)
 {
-    int32_t ret;
-
     if (pwm == NULL) {
         HDF_LOGE("PwmDeviceGet: pwm is null!\n");
         return HDF_ERR_INVALID_PARAM;
@@ -28,7 +26,7 @@ int32_t PwmDeviceGet(struct PwmDev *pwm)
         return HDF_ERR_DEVICE_BUSY;
     }
     if (pwm->method != NULL && pwm->method->open != NULL) {
-        ret = pwm->method->open(pwm);
+        int32_t ret = pwm->method->open(pwm);
         if (ret != HDF_SUCCESS) {
             (void)OsalSpinUnlock(&(pwm->lock));
             HDF_LOGE("PwmDeviceGet: open fail, ret: %d!", ret);
@@ -43,15 +41,13 @@ int32_t PwmDeviceGet(struct PwmDev *pwm)
 
 int32_t PwmDevicePut(struct PwmDev *pwm)
 {
-    int32_t ret;
-
     if (pwm == NULL) {
         HDF_LOGE("PwmDevicePut: pwm is null!\n");
         return HDF_ERR_INVALID_PARAM;
     }
 
     if (pwm->method != NULL && pwm->method->close != NULL) {
-        ret = pwm->method->close(pwm);
+        int32_t ret = pwm->method->close(pwm);
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("PwmDevicePut: close fail, ret: %d!", ret);
             return ret;
@@ -65,8 +61,6 @@ int32_t PwmDevicePut(struct PwmDev *pwm)
 
 int32_t PwmDeviceSetConfig(struct PwmDev *pwm, struct PwmConfig *config)
 {
-    int32_t ret;
-
     if (pwm == NULL || config == NULL) {
         HDF_LOGE("PwmDeviceSetConfig: pwm or config is null!\n");
         return HDF_ERR_INVALID_PARAM;
@@ -82,7 +76,7 @@ int32_t PwmDeviceSetConfig(struct PwmDev *pwm, struct PwmConfig *config)
         return HDF_ERR_NOT_SUPPORT;
     }
 
-    ret = pwm->method->setConfig(pwm, config);
+    int32_t ret = pwm->method->setConfig(pwm, config);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("PwmDeviceSetConfig: set config fail, ret: %d!", ret);
         return ret;
@@ -152,14 +146,13 @@ static int32_t PwmUserSetConfig(struct PwmDev *pwm, struct HdfSBuf *data)
 
 static int32_t PwmUserGetConfig(struct PwmDev *pwm, struct HdfSBuf *reply)
 {
-    int32_t ret;
     struct PwmConfig config;
 
     if (reply == NULL) {
         HDF_LOGE("PwmUserGetConfig: reply is null!");
         return HDF_ERR_INVALID_PARAM;
     }
-    ret = PwmDeviceGetConfig(pwm, &config);
+    int32_t ret = PwmDeviceGetConfig(pwm, &config);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("PwmUserGetConfig: get config fail!");
         return ret;
diff --git a/framework/support/platform/src/rtc/rtc_base.c b/framework/support/platform/src/rtc/rtc_base.c
index 5a092801e14e3d7a3b8092ba603cb03818e3cc94..481920171aab0896369651596f80e42882c4b32a 100644
--- a/framework/support/platform/src/rtc/rtc_base.c
+++ b/framework/support/platform/src/rtc/rtc_base.c
@@ -14,7 +14,6 @@
 uint8_t RtcGetMonthDays(const uint8_t isLeapYear, const uint8_t month)
 {
     uint8_t days;
-    uint8_t oddMonth;
 
     if (IS_INVALID_MONTH(month) || (isLeapYear > RTC_TRUE)) {
         return 0;
@@ -23,7 +22,7 @@ uint8_t RtcGetMonthDays(const uint8_t isLeapYear, const uint8_t month)
     if (month == RTC_FEBRUARY) {
         days = RTC_TWO_MONTH_DAY + isLeapYear;
     } else {
-        oddMonth = (month >= RTC_AUGUST) ? (month - RTC_UNIT_DIFF) : month;
+        uint8_t oddMonth = (month >= RTC_AUGUST) ? (month - RTC_UNIT_DIFF) : month;
         days = (oddMonth & RTC_ODD_MONTH_MASK) ? RTC_GREAT_MONTH_DAY : RTC_SMALL_MONTH_DAY;
     }
     return days;
@@ -52,23 +51,19 @@ uint8_t RtcIsInvalid(const struct RtcTime *time)
 
 uint8_t RtcGetWeekDay(const struct RtcTime *time)
 {
-    uint32_t days;
-    int8_t month;
-    uint16_t year;
-
     if ((time == NULL) || IS_INVALID_MONTH(time->month) || IS_INVALID_YEAR(time->year) ||
         (RtcIsInvalidDay(time->day, time->month, time->year) == RTC_TRUE)) {
         HDF_LOGE("RtcGetWeekDay: time is invalid!");
         return RTC_FALSE;
     }
 
-    days = time->day - RTC_UNIT_DIFF;
-    month = time->month;
+    uint32_t days = time->day - RTC_UNIT_DIFF;
+    int8_t month = time->month;
     while (--month >= RTC_JANUARY) {
         days += RtcGetMonthDays(IS_LEAP_YEAR(time->year), month);
     }
 
-    year = time->year;
+    uint16_t year = time->year;
     while (--year >= RTC_BEGIN_YEAR) {
         days += RTC_YEAR_DAYS(year);
     }
@@ -79,7 +74,6 @@ uint8_t RtcGetWeekDay(const struct RtcTime *time)
 #ifndef __KERNEL__
 uint64_t RtcTimeToTimestamp(const struct RtcTime *time)
 {
-    uint64_t seconds;
     uint32_t days;
     uint16_t year;
     int8_t month;
@@ -95,7 +89,7 @@ uint64_t RtcTimeToTimestamp(const struct RtcTime *time)
         return 0;
     }
 
-    seconds = ((uint64_t)time->hour * RTC_MAX_MINUTE + time->minute) * RTC_MAX_SECOND + time->second;
+    uint64_t seconds = ((uint64_t)time->hour * RTC_MAX_MINUTE + time->minute) * RTC_MAX_SECOND + time->second;
     days = time->day - RTC_UNIT_DIFF;
     month = time->month;
     year = time->year;
diff --git a/framework/support/platform/src/spi/spi_core.c b/framework/support/platform/src/spi/spi_core.c
index dec5a87a32e3cea8713f31d71416ea3d4fe42d0a..e6d64f2d22c586527f533f153a5c710502148e9c 100644
--- a/framework/support/platform/src/spi/spi_core.c
+++ b/framework/support/platform/src/spi/spi_core.c
@@ -19,8 +19,6 @@
 
 int32_t SpiCntlrOpen(struct SpiCntlr *cntlr, uint32_t csNum)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("SpiCntlrOpen: cntlr is null!");
         return HDF_ERR_INVALID_PARAM;
@@ -31,15 +29,13 @@ int32_t SpiCntlrOpen(struct SpiCntlr *cntlr, uint32_t csNum)
     }
     (void)OsalMutexLock(&(cntlr->lock));
     cntlr->curCs = csNum;
-    ret = cntlr->method->Open(cntlr);
+    int32_t ret = cntlr->method->Open(cntlr);
     (void)OsalMutexUnlock(&(cntlr->lock));
     return ret;
 }
 
 int32_t SpiCntlrClose(struct SpiCntlr *cntlr, uint32_t csNum)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("SpiCntlrClose: cntlr is null!");
         return HDF_ERR_INVALID_PARAM;
@@ -50,15 +46,13 @@ int32_t SpiCntlrClose(struct SpiCntlr *cntlr, uint32_t csNum)
     }
     (void)OsalMutexLock(&(cntlr->lock));
     cntlr->curCs = csNum;
-    ret = cntlr->method->Close(cntlr);
+    int32_t ret = cntlr->method->Close(cntlr);
     (void)OsalMutexUnlock(&(cntlr->lock));
     return ret;
 }
 
 int32_t SpiCntlrTransfer(struct SpiCntlr *cntlr, uint32_t csNum, struct SpiMsg *msg, uint32_t count)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("SpiCntlrTransfer: cntlr is null!");
         return HDF_ERR_INVALID_PARAM;
@@ -70,15 +64,13 @@ int32_t SpiCntlrTransfer(struct SpiCntlr *cntlr, uint32_t csNum, struct SpiMsg *
 
     (void)OsalMutexLock(&(cntlr->lock));
     cntlr->curCs = csNum;
-    ret = cntlr->method->Transfer(cntlr, msg, count);
+    int32_t ret = cntlr->method->Transfer(cntlr, msg, count);
     (void)OsalMutexUnlock(&(cntlr->lock));
     return ret;
 }
 
 int32_t SpiCntlrSetCfg(struct SpiCntlr *cntlr, uint32_t csNum, struct SpiCfg *cfg)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("SpiCntlrSetCfg: cntlr is null!");
         return HDF_ERR_INVALID_PARAM;
@@ -91,7 +83,7 @@ int32_t SpiCntlrSetCfg(struct SpiCntlr *cntlr, uint32_t csNum, struct SpiCfg *cf
 
     (void)OsalMutexLock(&(cntlr->lock));
     cntlr->curCs = csNum;
-    ret = cntlr->method->SetCfg(cntlr, cfg);
+    int32_t ret = cntlr->method->SetCfg(cntlr, cfg);
     if (PlatformTraceStart() == HDF_SUCCESS) {
         unsigned int infos[SPI_TRACE_BASIC_PARAM_NUM];
         infos[PLATFORM_TRACE_UINT_PARAM_SIZE_1 - 1] = cntlr->busNum;
@@ -107,8 +99,6 @@ int32_t SpiCntlrSetCfg(struct SpiCntlr *cntlr, uint32_t csNum, struct SpiCfg *cf
 
 int32_t SpiCntlrGetCfg(struct SpiCntlr *cntlr, uint32_t csNum, struct SpiCfg *cfg)
 {
-    int32_t ret;
-
     if (cntlr == NULL) {
         HDF_LOGE("SpiCntlrGetCfg: cntlr is null!");
         return HDF_ERR_INVALID_PARAM;
@@ -121,7 +111,7 @@ int32_t SpiCntlrGetCfg(struct SpiCntlr *cntlr, uint32_t csNum, struct SpiCfg *cf
 
     (void)OsalMutexLock(&(cntlr->lock));
     cntlr->curCs = csNum;
-    ret = cntlr->method->GetCfg(cntlr, cfg);
+    int32_t ret = cntlr->method->GetCfg(cntlr, cfg);
     if (PlatformTraceStart() == HDF_SUCCESS) {
         unsigned int infos[SPI_TRACE_PARAM_GET_NUM];
         infos[PLATFORM_TRACE_UINT_PARAM_SIZE_1 - 1] = cntlr->busNum;
@@ -139,13 +129,12 @@ int32_t SpiCntlrGetCfg(struct SpiCntlr *cntlr, uint32_t csNum, struct SpiCfg *cf
 static int32_t SpiMsgsRwProcess(
     struct HdfSBuf *data, uint32_t count, uint8_t *tmpFlag, struct SpiMsg *msgs, uint32_t *lenReply)
 {
-    int32_t i;
     uint32_t len;
     uint8_t *buf = NULL;
     uint32_t rbufLen;
     struct SpiUserMsg *userMsg = NULL;
 
-    for (i = 0; i < count; i++) {
+    for (int32_t i = 0; i < count; i++) {
         if ((!HdfSbufReadBuffer(data, (const void **)&userMsg, &len)) || (userMsg == NULL) ||
             (len != sizeof(struct SpiUserMsg))) {
             HDF_LOGE("SpiMsgsRwProcess: read msg[%d] userMsg fail!", i);
@@ -230,9 +219,7 @@ static int32_t SpiTransferRebuildMsgs(struct HdfSBuf *data, struct SpiMsg **ppms
 
 static int32_t SpiTransferWriteBackMsgs(struct HdfSBuf *reply, struct SpiMsg *msgs, uint32_t count)
 {
-    uint32_t i;
-
-    for (i = 0; i < count; i++) {
+    for (uint32_t i = 0; i < count; i++) {
         if (msgs[i].rbuf == NULL) {
             continue;
         }
@@ -248,7 +235,6 @@ static int32_t SpiTransferWriteBackMsgs(struct HdfSBuf *reply, struct SpiMsg *ms
 
 static int32_t SpiIoTransfer(struct SpiCntlr *cntlr, uint32_t csNum, struct HdfSBuf *data, struct HdfSBuf *reply)
 {
-    int32_t ret;
     uint32_t count;
     struct SpiMsg *msgs = NULL;
     uint8_t *bufReply = NULL;
@@ -258,7 +244,7 @@ static int32_t SpiIoTransfer(struct SpiCntlr *cntlr, uint32_t csNum, struct HdfS
         return HDF_ERR_INVALID_PARAM;
     }
 
-    ret = SpiTransferRebuildMsgs(data, &msgs, &count, &bufReply);
+    int32_t ret = SpiTransferRebuildMsgs(data, &msgs, &count, &bufReply);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("SpiIoTransfer: rebuild msgs fail, ret: %d!", ret);
         goto EXIT;
@@ -302,10 +288,9 @@ static int32_t SpiIoSetConfig(struct SpiCntlr *cntlr, uint32_t csNum, struct Hdf
 
 static int32_t SpiIoGetConfig(struct SpiCntlr *cntlr, uint32_t csNum, struct HdfSBuf *reply)
 {
-    int32_t ret;
     struct SpiCfg cfg;
 
-    ret = SpiCntlrGetCfg(cntlr, csNum, &cfg);
+    int32_t ret = SpiCntlrGetCfg(cntlr, csNum, &cfg);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("SpiIoGetConfig: get cfg fail!");
         return ret;
diff --git a/framework/support/platform/src/timer/timer_core.c b/framework/support/platform/src/timer/timer_core.c
index 6a7cb8e2d3bb8d3e9676830e7f00feca5ced586f..090df814582815e1a7a99c64268ca308fc71d4cc 100644
--- a/framework/support/platform/src/timer/timer_core.c
+++ b/framework/support/platform/src/timer/timer_core.c
@@ -182,7 +182,6 @@ int32_t TimerCntrlStop(struct TimerCntrl *cntrl)
 static int32_t TimerIoOpen(struct HdfSBuf *data, struct HdfSBuf *reply)
 {
     int16_t number;
-    uint32_t handle;
 
     if ((data == NULL) || (reply == NULL)) {
         HDF_LOGE("TimerIoOpen: param invalid!");
@@ -203,7 +202,7 @@ static int32_t TimerIoOpen(struct HdfSBuf *data, struct HdfSBuf *reply)
         return HDF_FAILURE;
     }
 
-    handle = (uint32_t)(number + TIMER_HANDLE_SHIFT);
+    uint32_t handle = (uint32_t)(number + TIMER_HANDLE_SHIFT);
     if (!HdfSbufWriteUint32(reply, handle)) {
         HDF_LOGE("TimerIoOpen: write handle fail!");
         return HDF_ERR_IO;
@@ -214,7 +213,6 @@ static int32_t TimerIoOpen(struct HdfSBuf *data, struct HdfSBuf *reply)
 static int32_t TimerIoClose(struct HdfSBuf *data, struct HdfSBuf *reply)
 {
     uint32_t handle;
-    int16_t number;
 
     (void)reply;
     if (data == NULL) {
@@ -227,7 +225,7 @@ static int32_t TimerIoClose(struct HdfSBuf *data, struct HdfSBuf *reply)
         return HDF_ERR_IO;
     }
 
-    number = (int16_t)(handle - TIMER_HANDLE_SHIFT);
+    int16_t number = (int16_t)(handle - TIMER_HANDLE_SHIFT);
     if (number < 0) {
         HDF_LOGE("TimerIoClose: number[%d] invalid!", number);
         return HDF_ERR_INVALID_PARAM;
@@ -238,7 +236,6 @@ static int32_t TimerIoClose(struct HdfSBuf *data, struct HdfSBuf *reply)
 static int32_t TimerIoStart(struct HdfSBuf *data, struct HdfSBuf *reply)
 {
     uint32_t handle;
-    int16_t number;
 
     (void)reply;
     if (data == NULL) {
@@ -250,7 +247,7 @@ static int32_t TimerIoStart(struct HdfSBuf *data, struct HdfSBuf *reply)
         return HDF_ERR_IO;
     }
 
-    number = (int16_t)(handle - TIMER_HANDLE_SHIFT);
+    int16_t number = (int16_t)(handle - TIMER_HANDLE_SHIFT);
     if (number < 0) {
         HDF_LOGE("TimerIoStart: number[%d] is invalid!", number);
         return HDF_ERR_INVALID_PARAM;
@@ -261,7 +258,6 @@ static int32_t TimerIoStart(struct HdfSBuf *data, struct HdfSBuf *reply)
 static int32_t TimerIoStop(struct HdfSBuf *data, struct HdfSBuf *reply)
 {
     uint32_t handle;
-    int16_t number;
 
     (void)reply;
     if (data == NULL) {
@@ -273,7 +269,7 @@ static int32_t TimerIoStop(struct HdfSBuf *data, struct HdfSBuf *reply)
         return HDF_ERR_IO;
     }
 
-    number = (int16_t)(handle - TIMER_HANDLE_SHIFT);
+    int16_t number = (int16_t)(handle - TIMER_HANDLE_SHIFT);
     if (number < 0) {
         HDF_LOGE("TimerIoStop: number[%d] is invalid!", number);
         return HDF_ERR_INVALID_PARAM;
@@ -284,7 +280,6 @@ static int32_t TimerIoStop(struct HdfSBuf *data, struct HdfSBuf *reply)
 static int32_t TimerIoCb(uint32_t number)
 {
     uint32_t handle = number + TIMER_HANDLE_SHIFT;
-    int32_t ret;
     struct HdfSBuf *data = NULL;
 
     data = HdfSbufObtainDefaultSize();
@@ -297,7 +292,7 @@ static int32_t TimerIoCb(uint32_t number)
         HdfSbufRecycle(data);
         return HDF_ERR_IO;
     }
-    ret = HdfDeviceSendEvent(g_timerManager->device, PLATFORM_LISTENER_EVENT_TIMER_NOTIFY, data);
+    int32_t ret = HdfDeviceSendEvent(g_timerManager->device, PLATFORM_LISTENER_EVENT_TIMER_NOTIFY, data);
     HdfSbufRecycle(data);
     HDF_LOGD("TimerIoCb: set service info done, ret = %d %d", ret, handle);
     return HDF_SUCCESS;
@@ -307,7 +302,6 @@ static int32_t TimerIoSet(struct HdfSBuf *data, struct HdfSBuf *reply)
 {
     uint32_t len;
     uint32_t handle;
-    int16_t number;
     struct TimerConfig *cfg = NULL;
 
     (void)reply;
@@ -325,7 +319,7 @@ static int32_t TimerIoSet(struct HdfSBuf *data, struct HdfSBuf *reply)
         return HDF_ERR_IO;
     }
 
-    number = (int16_t)(handle - TIMER_HANDLE_SHIFT);
+    int16_t number = (int16_t)(handle - TIMER_HANDLE_SHIFT);
     if (number < 0) {
         HDF_LOGE("TimerIoSet: number[%d] is invalid!", number);
         return HDF_ERR_INVALID_PARAM;
@@ -337,7 +331,6 @@ static int32_t TimerIoSetOnce(struct HdfSBuf *data, struct HdfSBuf *reply)
 {
     uint32_t len;
     uint32_t handle;
-    int16_t number;
     struct TimerConfig *cfg = NULL;
 
     (void)reply;
@@ -355,7 +348,7 @@ static int32_t TimerIoSetOnce(struct HdfSBuf *data, struct HdfSBuf *reply)
         return HDF_ERR_IO;
     }
 
-    number = (int16_t)(handle - TIMER_HANDLE_SHIFT);
+    int16_t number = (int16_t)(handle - TIMER_HANDLE_SHIFT);
     if (number < 0) {
         HDF_LOGE("TimerIoSetOnce: number[%d] is invalid!", number);
         return HDF_ERR_INVALID_PARAM;
@@ -368,7 +361,6 @@ static int32_t TimerIoGet(struct HdfSBuf *data, struct HdfSBuf *reply)
     int32_t ret = HDF_SUCCESS;
     struct TimerConfig cfg;
     uint32_t handle;
-    int16_t number;
 
     if ((data == NULL) || (reply == NULL)) {
         HDF_LOGE("TimerIoGet: data or reply is null!");
@@ -380,7 +372,7 @@ static int32_t TimerIoGet(struct HdfSBuf *data, struct HdfSBuf *reply)
         return HDF_ERR_IO;
     }
 
-    number = (int16_t)(handle - TIMER_HANDLE_SHIFT);
+    int16_t number = (int16_t)(handle - TIMER_HANDLE_SHIFT);
     if (number < 0) {
         HDF_LOGE("TimerIoGet: number[%d] is invalid!", number);
         return HDF_ERR_INVALID_PARAM;
@@ -524,7 +516,6 @@ int32_t TimerCntrlRemoveByNumber(const uint32_t number)
 
 static int32_t TimerManagerBind(struct HdfDeviceObject *device)
 {
-    int32_t ret;
     struct TimerManager *manager = NULL;
 
     CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_OBJECT);
@@ -535,7 +526,7 @@ static int32_t TimerManagerBind(struct HdfDeviceObject *device)
         return HDF_ERR_MALLOC_FAIL;
     }
 
-    ret = OsalMutexInit(&manager->lock);
+    int32_t ret = OsalMutexInit(&manager->lock);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("TimerManagerBind: mutex init fail, ret: %d", ret);
         OsalMemFree(manager);
diff --git a/framework/support/platform/test/fuzztest/gpio_fuzzer/gpio_fuzzer.cpp b/framework/support/platform/test/fuzztest/gpio_fuzzer/gpio_fuzzer.cpp
index 537d3f777285de9daa364b0135d91e58c50d68f1..e2e9fbf47cfc4da0fb1e64bb02816430823ae1d3 100644
--- a/framework/support/platform/test/fuzztest/gpio_fuzzer/gpio_fuzzer.cpp
+++ b/framework/support/platform/test/fuzztest/gpio_fuzzer/gpio_fuzzer.cpp
@@ -22,7 +22,7 @@ constexpr int32_t MAX = 2;
 constexpr uint16_t GPIO_TEST_NUM = 3;
 }
 
-struct AllParameters {
+struct GpioAllParameters {
     uint16_t descVal;
     uint16_t descDir;
     uint16_t descMode;
@@ -39,7 +39,7 @@ namespace OHOS {
 static bool GpioFuzzTest(const uint8_t *data, size_t size)
 {
     int32_t number;
-    const struct AllParameters *params = reinterpret_cast<const struct AllParameters *>(data);
+    const struct GpioAllParameters *params = reinterpret_cast<const struct GpioAllParameters *>(data);
 
     number = randNum(MIN, MAX);
     switch (static_cast<ApiTestCmd>(number)) {
@@ -68,7 +68,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
         return 0;
     }
 
-    if (size < sizeof(struct AllParameters)) {
+    if (size < sizeof(struct GpioAllParameters)) {
         HDF_LOGE("LLVMFuzzerTestOneInput: gpio fuzz test size is small!");
         return 0;
     }
diff --git a/framework/support/platform/test/fuzztest/i2c_fuzzer/i2c_fuzzer.cpp b/framework/support/platform/test/fuzztest/i2c_fuzzer/i2c_fuzzer.cpp
index b4756afb001fb2fbb142f43a6479f7b581f0395e..1c72545fdc5c5b6c810c2ec85ba342af6aff60f2 100644
--- a/framework/support/platform/test/fuzztest/i2c_fuzzer/i2c_fuzzer.cpp
+++ b/framework/support/platform/test/fuzztest/i2c_fuzzer/i2c_fuzzer.cpp
@@ -15,7 +15,7 @@ constexpr int32_t BUS_NUM = 6;
 constexpr uint16_t BUF_LEN = 7;
 }
 
-struct AllParameters {
+struct I2cAllParameters {
     uint16_t addr;
     uint16_t flags;
     uint8_t buf[BUF_LEN];
@@ -25,7 +25,7 @@ namespace OHOS {
 static bool I2cFuzzTest(const uint8_t *data, size_t size)
 {
     DevHandle handle = nullptr;
-    const struct AllParameters *params = reinterpret_cast<const struct AllParameters *>(data);
+    const struct I2cAllParameters *params = reinterpret_cast<const struct I2cAllParameters *>(data);
     struct I2cMsg msg;
 
     handle = I2cOpen(BUS_NUM);
@@ -64,7 +64,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
         return 0;
     }
 
-    if (size < sizeof(struct AllParameters)) {
+    if (size < sizeof(struct I2cAllParameters)) {
         HDF_LOGE("LLVMFuzzerTestOneInput: i2c fuzz test size is small!");
         return 0;
     }
diff --git a/framework/support/platform/test/fuzztest/pwm_fuzzer/pwm_fuzzer.cpp b/framework/support/platform/test/fuzztest/pwm_fuzzer/pwm_fuzzer.cpp
index a515c1ed1ebbb193cf4185034f852774d1a1789c..1e1c2933a4b9620faa1b364c1d4b87efa59fc88f 100644
--- a/framework/support/platform/test/fuzztest/pwm_fuzzer/pwm_fuzzer.cpp
+++ b/framework/support/platform/test/fuzztest/pwm_fuzzer/pwm_fuzzer.cpp
@@ -22,7 +22,7 @@ constexpr int32_t MAX = 2;
 constexpr int32_t PWM_FUZZ_NUM = 1;
 }
 
-struct AllParameters {
+struct PwmAllParameters {
     uint32_t descPer;
     uint32_t descDuty;
     uint8_t descPolar;
@@ -33,7 +33,7 @@ static bool PwmFuzzTest(const uint8_t *data, size_t size)
 {
     int32_t number;
     DevHandle handle = nullptr;
-    const struct AllParameters *params = reinterpret_cast<const struct AllParameters *>(data);
+    const struct PwmAllParameters *params = reinterpret_cast<const struct PwmAllParameters *>(data);
 
     number = randNum(MIN, MAX);
     handle = PwmOpen(PWM_FUZZ_NUM);
@@ -68,7 +68,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
         return 0;
     }
 
-    if (size < sizeof(struct AllParameters)) {
+    if (size < sizeof(struct PwmAllParameters)) {
         HDF_LOGE("LLVMFuzzerTestOneInput: pwm fuzz test size is small!");
         return 0;
     }
diff --git a/framework/support/platform/test/fuzztest/rtc_fuzzer/rtc_fuzzer.cpp b/framework/support/platform/test/fuzztest/rtc_fuzzer/rtc_fuzzer.cpp
index ae3075099f9b281ed8a89d85077a8ea0e42ccdf6..648e2033b514f0ece6b1e0ee8882e13f02b2e562 100644
--- a/framework/support/platform/test/fuzztest/rtc_fuzzer/rtc_fuzzer.cpp
+++ b/framework/support/platform/test/fuzztest/rtc_fuzzer/rtc_fuzzer.cpp
@@ -22,7 +22,7 @@ constexpr int32_t MAX = 4;
 constexpr uint8_t RTC_USER_INDEX = 8;
 }
 
-struct AllParameters {
+struct RtcAllParameters {
     uint32_t desFreq;
     uint8_t desValue;
     uint8_t desEnable;
@@ -35,7 +35,7 @@ static bool RtcFuzzTest(const uint8_t *data, size_t size)
 {
     int32_t number;
     DevHandle handle = nullptr;
-    const struct AllParameters *params = reinterpret_cast<const struct AllParameters *>(data);
+    const struct RtcAllParameters *params = reinterpret_cast<const struct RtcAllParameters *>(data);
 
     number = randNum(MIN, MAX);
     handle = RtcOpen();
@@ -76,7 +76,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
         return 0;
     }
 
-    if (size < sizeof(struct AllParameters)) {
+    if (size < sizeof(struct RtcAllParameters)) {
         HDF_LOGE("LLVMFuzzerTestOneInput: rtc fuzz test size is small!");
         return 0;
     }
diff --git a/framework/support/platform/test/fuzztest/spi_fuzzer/spi_fuzzer.cpp b/framework/support/platform/test/fuzztest/spi_fuzzer/spi_fuzzer.cpp
index 03a837174a9499bd66129a7736ee9959c929ce52..35c9b24ec0e8f06c99408397bedb48d8050d3949 100644
--- a/framework/support/platform/test/fuzztest/spi_fuzzer/spi_fuzzer.cpp
+++ b/framework/support/platform/test/fuzztest/spi_fuzzer/spi_fuzzer.cpp
@@ -24,7 +24,7 @@ constexpr int32_t CS_TEST_NUM = 0;
 constexpr uint32_t SPI_BUF_SIZE = 8;
 }
 
-struct AllParameters {
+struct SpiAllParameters {
     uint32_t descSpeed;
     uint16_t descDelay;
     uint8_t descKeep;
@@ -62,7 +62,7 @@ static bool SpiFuzzTest(const uint8_t *data, size_t size)
     struct SpiCfg cfg;
     DevHandle handle = nullptr;
     struct SpiDevInfo info;
-    const struct AllParameters *params = reinterpret_cast<const struct AllParameters *>(data);
+    const struct SpiAllParameters *params = reinterpret_cast<const struct SpiAllParameters *>(data);
 
     info.busNum = BUS_TEST_NUM;
     info.csNum = CS_TEST_NUM;
@@ -113,7 +113,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
         return 0;
     }
 
-    if (size < sizeof(struct AllParameters)) {
+    if (size < sizeof(struct SpiAllParameters)) {
         HDF_LOGE("LLVMFuzzerTestOneInput: spi fuzz test size is small!");
         return 0;
     }
diff --git a/framework/support/platform/test/fuzztest/uart_fuzzer/uart_fuzzer.cpp b/framework/support/platform/test/fuzztest/uart_fuzzer/uart_fuzzer.cpp
index c8e5367fb822a88b5685f6ff74d7b1501bd6c897..80cc8c4b813525d297cb2cf6012337484ff0a69c 100644
--- a/framework/support/platform/test/fuzztest/uart_fuzzer/uart_fuzzer.cpp
+++ b/framework/support/platform/test/fuzztest/uart_fuzzer/uart_fuzzer.cpp
@@ -22,7 +22,7 @@ constexpr int32_t MAX = 2;
 constexpr int32_t UART_FUZZ_PORT = 1;
 }
 
-struct AllParameters {
+struct UartAllParameters {
     uint32_t desBaudRate;
     struct UartAttribute paraAttribute;
     uint32_t paraMode;
@@ -33,7 +33,7 @@ static bool UartFuzzTest(const uint8_t *data, size_t size)
 {
     int32_t number;
     DevHandle handle = nullptr;
-    const struct AllParameters *params = reinterpret_cast<const struct AllParameters *>(data);
+    const struct UartAllParameters *params = reinterpret_cast<const struct UartAllParameters *>(data);
 
     number = randNum(MIN, MAX);
     handle = UartOpen(UART_FUZZ_PORT);
@@ -68,7 +68,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
         return 0;
     }
 
-    if (size < sizeof(struct AllParameters)) {
+    if (size < sizeof(struct UartAllParameters)) {
         HDF_LOGE("LLVMFuzzerTestOneInput: uart fuzz test size is small!");
         return 0;
     }
diff --git a/framework/test/unittest/platform/common/adc_test.c b/framework/test/unittest/platform/common/adc_test.c
index 188befc18aa81362299985b47f5465382aa4b1cb..9bcc23f19618985a7368cd910dd34e2f294f7612 100644
--- a/framework/test/unittest/platform/common/adc_test.c
+++ b/framework/test/unittest/platform/common/adc_test.c
@@ -80,7 +80,6 @@ static int32_t AdcTestGetConfig(struct AdcTestConfig *config)
 
 static struct AdcTester *AdcTesterGet(void)
 {
-    int32_t ret;
     static struct AdcTester tester;
     static bool hasInit = false;
 
@@ -88,7 +87,7 @@ static struct AdcTester *AdcTesterGet(void)
     if (hasInit) {
         return &tester;
     }
-    ret = AdcTestGetConfig(&tester.config);
+    int32_t ret = AdcTestGetConfig(&tester.config);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("AdcTesterGet: read config fail, ret: %d!", ret);
         return NULL;
@@ -107,7 +106,6 @@ static int32_t AdcTestRead(void)
 {
     struct AdcTester *tester = NULL;
     uint32_t value[TEST_ADC_VAL_NUM];
-    int32_t ret;
     int i;
 
     HDF_LOGI("AdcTestRead: enter!");
@@ -118,7 +116,7 @@ static int32_t AdcTestRead(void)
     }
     for (i = 0; i < TEST_ADC_VAL_NUM; i++) {
         value[i] = 0;
-        ret = AdcRead(tester->handle, tester->config.channel, &value[i]);
+        int32_t ret = AdcRead(tester->handle, tester->config.channel, &value[i]);
         if (ret != HDF_SUCCESS || value[i] >= (1U << tester->config.dataWidth)) {
             HDF_LOGE("AdcTestRead: read value fail, ret: %d!", ret);
             return HDF_ERR_IO;
@@ -135,7 +133,6 @@ static int AdcTestThreadFunc(void *param)
     struct AdcTester *tester = NULL;
     uint32_t val;
     int i;
-    int32_t ret;
 
     HDF_LOGI("AdcTestThreadFunc: enter!");
     tester = AdcTesterGet();
@@ -146,7 +143,7 @@ static int AdcTestThreadFunc(void *param)
     }
 
     for (i = 0; i < ADC_TEST_WAIT_TIMES; i++) {
-        ret = AdcRead(tester->handle, tester->config.channel, &val);
+        int32_t ret = AdcRead(tester->handle, tester->config.channel, &val);
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("AdcTestThreadFunc: adc read fail, ret: %d!", ret);
             *((int32_t *)param) = 1;
@@ -162,7 +159,6 @@ static int AdcTestThreadFunc(void *param)
 static int32_t AdcTestStartThread(struct OsalThread *thread1, struct OsalThread *thread2,
     const int32_t *count1, const int32_t *count2)
 {
-    int32_t ret;
     uint32_t time = 0;
     struct OsalThreadParam cfg1;
     struct OsalThreadParam cfg2;
@@ -178,7 +174,7 @@ static int32_t AdcTestStartThread(struct OsalThread *thread1, struct OsalThread
     cfg1.priority = cfg2.priority = OSAL_THREAD_PRI_DEFAULT;
     cfg1.stackSize = cfg2.stackSize = ADC_TEST_STACK_SIZE;
 
-    ret = OsalThreadStart(thread1, &cfg1);
+    int32_t ret = OsalThreadStart(thread1, &cfg1);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("AdcTestStartThread: start test thread1 fail, ret: %d!", ret);
         return ret;
@@ -202,13 +198,12 @@ static int32_t AdcTestStartThread(struct OsalThread *thread1, struct OsalThread
 
 static int32_t AdcTestMultiThread(void)
 {
-    int32_t ret;
     struct OsalThread thread1;
     struct OsalThread thread2;
     int32_t count1 = 0;
     int32_t count2 = 0;
 
-    ret = OsalThreadCreate(&thread1, (OsalThreadEntry)AdcTestThreadFunc, (void *)&count1);
+    int32_t ret = OsalThreadCreate(&thread1, (OsalThreadEntry)AdcTestThreadFunc, (void *)&count1);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("AdcTestMultiThread: create test thread1 fail, ret: %d!", ret);
         return ret;
@@ -258,11 +253,7 @@ static int32_t AdcIfPerformanceTest(void)
     return HDF_SUCCESS;
 #endif
     struct AdcTester *tester = NULL;
-    uint64_t startMs;
-    uint64_t endMs;
-    uint64_t useTime;    // ms
     uint32_t val;
-    int32_t ret;
 
     tester = AdcTesterGet();
     if (tester == NULL || tester->handle == NULL) {
@@ -270,11 +261,11 @@ static int32_t AdcIfPerformanceTest(void)
         return HDF_ERR_INVALID_OBJECT;
     }
 
-    startMs = OsalGetSysTimeMs();
-    ret = AdcRead(tester->handle, tester->config.channel, &val);
+    uint64_t startMs = OsalGetSysTimeMs();
+    int32_t ret = AdcRead(tester->handle, tester->config.channel, &val);
     if (ret == HDF_SUCCESS) {
-        endMs = OsalGetSysTimeMs();
-        useTime = endMs - startMs;
+        uint64_t endMs = OsalGetSysTimeMs();
+        uint64_t useTime = endMs - startMs;
         HDF_LOGI("AdcIfPerformanceTest: ----->interface performance test:[start - end] < 1ms[%{pubilc}s]\r\n",
             useTime < 1 ? "yes" : "no");
         return HDF_SUCCESS;
diff --git a/framework/test/unittest/platform/common/dac_test.c b/framework/test/unittest/platform/common/dac_test.c
index 56eba4aaf9d0b64fd98eedf4aaf2a39563e97f53..2dcab72c7f0b184202905a276be625bb65c22b3e 100644
--- a/framework/test/unittest/platform/common/dac_test.c
+++ b/framework/test/unittest/platform/common/dac_test.c
@@ -99,7 +99,6 @@ static int32_t DacTestWrite(void)
 {
     struct DacTester *tester = NULL;
     uint32_t value[TEST_DAC_VAL_NUM];
-    int32_t ret;
     int i;
 
     tester = DacTesterGet();
@@ -109,7 +108,7 @@ static int32_t DacTestWrite(void)
     }
     for (i = 0; i < TEST_DAC_VAL_NUM; i++) {
         value[i] = i;
-        ret = DacWrite(tester->handle, tester->config.channel, value[i]);
+        int32_t ret = DacWrite(tester->handle, tester->config.channel, value[i]);
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("DacTestWrite: write value fail:%u, ret: %d!", value[i], ret);
             return HDF_ERR_IO;
@@ -124,7 +123,6 @@ static int DacTestThreadFunc(void *param)
     struct DacTester *tester = NULL;
     uint32_t val;
     uint32_t i;
-    int32_t ret;
 
     tester = DacTesterGet();
     if (tester == NULL) {
@@ -134,7 +132,7 @@ static int DacTestThreadFunc(void *param)
     }
     for (i = 0; i < DAC_TEST_WAIT_TIMES; i++) {
         val = i;
-        ret = DacWrite(tester->handle, tester->config.channel, val);
+        int32_t ret = DacWrite(tester->handle, tester->config.channel, val);
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("DacTestThreadFunc: DacWrite fail, ret: %d!", ret);
             *((int32_t *)param) = 1;
diff --git a/framework/test/unittest/platform/common/gpio_test.c b/framework/test/unittest/platform/common/gpio_test.c
index 34798ba7e5f2b16f8ba95c8d7cb5bfb752bc3554..a4e3eab46591f5a6fb1a52715858c58ab5354924 100644
--- a/framework/test/unittest/platform/common/gpio_test.c
+++ b/framework/test/unittest/platform/common/gpio_test.c
@@ -543,11 +543,10 @@ int32_t GpioTestExecute(int cmd)
 void GpioTestExecuteAll(void)
 {
     int32_t i;
-    int32_t ret;
     int32_t fails = 0;
 
     for (i = 0; i < GPIO_TEST_MAX; i++) {
-        ret = GpioTestExecute(i);
+        int32_t ret = GpioTestExecute(i);
         fails += (ret != HDF_SUCCESS) ? 1 : 0;
     }
 
diff --git a/framework/test/unittest/platform/common/i2c_test.c b/framework/test/unittest/platform/common/i2c_test.c
index 7d7ee1e5577b784d79b0b8c1e017f864f5824cff..2b0e9f2674bd0996c96c15b4612e28205dbeba87 100644
--- a/framework/test/unittest/platform/common/i2c_test.c
+++ b/framework/test/unittest/platform/common/i2c_test.c
@@ -340,9 +340,6 @@ static int32_t I2cTestPeformance(void)
     // liteos the accuracy of the obtained time is too large and inaccurate.
     return HDF_SUCCESS;
 #endif
-    uint64_t startMs;
-    uint64_t endMs;
-    uint64_t useTime;    // ms
     struct I2cTester *tester = NULL;
     DevHandle handle = NULL;
 
@@ -352,12 +349,12 @@ static int32_t I2cTestPeformance(void)
         return HDF_ERR_INVALID_OBJECT;
     }
 
-    startMs = OsalGetSysTimeMs();
+    uint64_t startMs = OsalGetSysTimeMs();
     handle = I2cOpen(tester->config.busNum);
-    endMs = OsalGetSysTimeMs();
+    uint64_t endMs = OsalGetSysTimeMs();
 
     if (handle != NULL) {
-        useTime = endMs - startMs;
+        uint64_t useTime = endMs - startMs;
         HDF_LOGI("I2cTestPeformance: ----->interface performance test:[start - end] < 1ms[%s]\r\n",
             useTime < 1 ? "yes" : "no");
         I2cClose(handle);
@@ -442,14 +439,13 @@ int32_t I2cTestExecute(int cmd)
 void I2cTestExecuteAll(void)
 {
     int32_t i;
-    int32_t ret;
     int32_t fails = 0;
 
     /* setup env for all test cases */
     (void)I2cTestExecute(I2C_TEST_CMD_SETUP_ALL);
 
     for (i = 0; i <= I2C_TEST_CMD_RELIABILITY; i++) {
-        ret = I2cTestExecute(i);
+        int32_t ret = I2cTestExecute(i);
         fails += (ret != HDF_SUCCESS) ? 1 : 0;
     }
 
diff --git a/framework/test/unittest/platform/common/i3c_test.c b/framework/test/unittest/platform/common/i3c_test.c
index 6a5a0246cb99eaeee95d02a8bdfe4717c143361e..5b93f6d198a0e98c755ca39dea256fea3e258018 100644
--- a/framework/test/unittest/platform/common/i3c_test.c
+++ b/framework/test/unittest/platform/common/i3c_test.c
@@ -445,7 +445,6 @@ static struct I3cTestEntry g_multiThreadEntry[] = {
 static int32_t I3cTestMultiThread(void *param)
 {
     uint32_t i;
-    int32_t ret;
 
     for (i = 0; i < sizeof(g_multiThreadEntry) / sizeof(g_multiThreadEntry[0]); i++) {
         if (g_multiThreadEntry[i].func == NULL) {
@@ -453,7 +452,7 @@ static int32_t I3cTestMultiThread(void *param)
             return HDF_FAILURE;
         }
         HDF_LOGI("I3cTestMultiThread: =================calling func %u =========================", i);
-        ret = I3cTestThreadFunc((OsalThreadEntry)g_multiThreadEntry[i].func);
+        int32_t ret = I3cTestThreadFunc((OsalThreadEntry)g_multiThreadEntry[i].func);
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("I3cTestMultiThread: Multithreading test fail: %u", i);
             return ret;
diff --git a/framework/test/unittest/platform/common/platform_device_test.c b/framework/test/unittest/platform/common/platform_device_test.c
index bc8868ab9ab01eab83e37d0d6343858c9a5416b5..448268e99222b72c7247b58d4f83fb89d38e129a 100644
--- a/framework/test/unittest/platform/common/platform_device_test.c
+++ b/framework/test/unittest/platform/common/platform_device_test.c
@@ -317,11 +317,10 @@ int PlatformDeviceTestExecute(int cmd)
 void PlatformDeviceTestExecuteAll(void)
 {
     int32_t i;
-    int32_t ret;
     int32_t fails = 0;
 
     for (i = 0; i < PLAT_DEVICE_TEST_CMD_MAX; i++) {
-        ret = PlatformDeviceTestExecute(i);
+        int32_t ret = PlatformDeviceTestExecute(i);
         fails += (ret != HDF_SUCCESS) ? 1 : 0;
     }
 
diff --git a/framework/test/unittest/platform/common/platform_event_test.c b/framework/test/unittest/platform/common/platform_event_test.c
index bdb0194f7ff7f17d9bece48275e03c525e69bc8e..39b240d63ef4d619536f7cf256224d4e6b6821c7 100644
--- a/framework/test/unittest/platform/common/platform_event_test.c
+++ b/framework/test/unittest/platform/common/platform_event_test.c
@@ -237,11 +237,10 @@ int PlatformEventTestExecute(int cmd)
 void PlatformEventTestExecuteAll(void)
 {
     int32_t i;
-    int32_t ret;
     int32_t fails = 0;
 
     for (i = 0; i < PLAT_EVENT_TEST_CMD_MAX; i++) {
-        ret = PlatformEventTestExecute(i);
+        int32_t ret = PlatformEventTestExecute(i);
         fails += (ret != HDF_SUCCESS) ? 1 : 0;
     }
 
diff --git a/framework/test/unittest/platform/common/platform_manager_test.c b/framework/test/unittest/platform/common/platform_manager_test.c
index e1e77cc194fa2d2447548e9342cc16f8d57920ad..fdef2e5429b07d406137b200a4c40be09ddf7699 100644
--- a/framework/test/unittest/platform/common/platform_manager_test.c
+++ b/framework/test/unittest/platform/common/platform_manager_test.c
@@ -194,13 +194,12 @@ static int32_t PlatformManagerTestGetDevice(struct PlatformManager *manager)
 
 static int32_t PlatformManagerTestReliability(struct PlatformManager *manager)
 {
-    int32_t ret;
     struct PlatformDevice *device = g_platDevices[0];
     int32_t number = device->number;
 
     PLAT_LOGD("PlatformManagerTestReliability: enter!");
     // should not add success when manager is NULL
-    ret = PlatformManagerAddDevice(NULL, device);
+    int32_t ret = PlatformManagerAddDevice(NULL, device);
     CHECK_NE_RETURN(ret, HDF_SUCCESS, HDF_FAILURE);
 
     // should not add success when device is NULL
@@ -284,11 +283,10 @@ int PlatformManagerTestExecute(int cmd)
 void PlatformManagerTestExecuteAll(void)
 {
     int32_t i;
-    int32_t ret;
     int32_t fails = 0;
 
     for (i = 0; i < PLAT_MANAGER_TEST_CMD_MAX; i++) {
-        ret = PlatformManagerTestExecute(i);
+        int32_t ret = PlatformManagerTestExecute(i);
         fails += (ret != HDF_SUCCESS) ? 1 : 0;
     }
 
diff --git a/framework/test/unittest/platform/common/platform_queue_test.c b/framework/test/unittest/platform/common/platform_queue_test.c
index ddb90c842e58d3e18353c19a2d6cc0222f864aeb..ca8c8630d4e1ce1b4deae1a91a4c4e9d5852be9f 100644
--- a/framework/test/unittest/platform/common/platform_queue_test.c
+++ b/framework/test/unittest/platform/common/platform_queue_test.c
@@ -165,11 +165,10 @@ int PlatformQueueTestExecute(int cmd)
 void PlatformQueueTestExecuteAll(void)
 {
     int32_t i;
-    int32_t ret;
     int32_t fails = 0;
 
     for (i = 0; i < PLAT_QUEUE_TEST_CMD_MAX; i++) {
-        ret = PlatformQueueTestExecute(i);
+        int32_t ret = PlatformQueueTestExecute(i);
         fails += (ret != HDF_SUCCESS) ? 1 : 0;
     }
 
diff --git a/framework/test/unittest/platform/common/spi_test.c b/framework/test/unittest/platform/common/spi_test.c
index 5049f5e67086dc8bec93040e3820f5a063d8e0c8..8abbc15fc65a5e0b83343e8f5a15713950bd2ad8 100644
--- a/framework/test/unittest/platform/common/spi_test.c
+++ b/framework/test/unittest/platform/common/spi_test.c
@@ -489,18 +489,14 @@ static int32_t SpiIfPerformanceTest(struct SpiTester *tester)
     }
     return HDF_SUCCESS;
 #endif
-    int32_t ret;
     struct SpiCfg cfg = {0};
-    uint64_t startMs;
-    uint64_t endMs;
-    uint64_t useTime;    // ms
 
-    startMs = OsalGetSysTimeMs();
-    ret = SpiGetCfg(tester->handle, &cfg);
-    endMs = OsalGetSysTimeMs();
+    uint64_t startMs = OsalGetSysTimeMs();
+    int32_t ret = SpiGetCfg(tester->handle, &cfg);
+    uint64_t endMs = OsalGetSysTimeMs();
 
     if (ret == HDF_SUCCESS) {
-        useTime = endMs - startMs;
+        uint64_t useTime = endMs - startMs;
         HDF_LOGI("SpiIfPerformanceTest: ----->interface performance test:[start - end] < 1ms[%s]\r\n",
             useTime < 1 ? "yes" : "no");
         return HDF_SUCCESS;
diff --git a/framework/test/unittest/platform/config/can_test_config.c b/framework/test/unittest/platform/config/can_test_config.c
index f42bc80010ae9b0f290b53a358a7218cb18aad5e..455717f7b303569aac1690cf23b0d7656f54902d 100644
--- a/framework/test/unittest/platform/config/can_test_config.c
+++ b/framework/test/unittest/platform/config/can_test_config.c
@@ -75,7 +75,6 @@ static int32_t CanTestReadConfig(struct CanTestConfig *config, const struct Devi
 
 static int32_t CanTestBind(struct HdfDeviceObject *device)
 {
-    int32_t ret;
     static struct IDeviceIoService service;
 
     if (device == NULL) {
@@ -87,7 +86,7 @@ static int32_t CanTestBind(struct HdfDeviceObject *device)
         HDF_LOGI("CanTestBind: property not configed, using default!");
         CanTestSetDftConfig(&g_config);
     } else {
-        ret = CanTestReadConfig(&g_config, device->property);
+        int32_t ret = CanTestReadConfig(&g_config, device->property);
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("CanTestBind: read config fail, ret: %d!", ret);
             return ret;
diff --git a/framework/test/unittest/platform/virtual/i3c_virtual.c b/framework/test/unittest/platform/virtual/i3c_virtual.c
index 07514bea5a2206279339860825bac9bd26bae17b..56072367b493c025bead3e294cb2c4415e93645b 100644
--- a/framework/test/unittest/platform/virtual/i3c_virtual.c
+++ b/framework/test/unittest/platform/virtual/i3c_virtual.c
@@ -368,7 +368,6 @@ static int32_t VirtualI3cParseAndInit(struct HdfDeviceObject *device, const stru
 
 static int32_t VirtualI3cInit(struct HdfDeviceObject *device)
 {
-    int32_t ret;
     const struct DeviceResourceNode *childNode = NULL;
 
     HDF_LOGD("VirtualI3cInit: enter!");
@@ -378,7 +377,7 @@ static int32_t VirtualI3cInit(struct HdfDeviceObject *device)
     }
 
     DEV_RES_NODE_FOR_EACH_CHILD_NODE(device->property, childNode) {
-        ret = VirtualI3cParseAndInit(device, childNode);
+        int32_t ret = VirtualI3cParseAndInit(device, childNode);
         if (ret != HDF_SUCCESS) {
             break;
         }
diff --git a/framework/test/unittest/platform/virtual/pin_virtual.c b/framework/test/unittest/platform/virtual/pin_virtual.c
index f96180665f0ac34c06372c43e0954a2369b5d7f4..e7da8ce4833b17ea91d0c3e808a085aa2e6077c4 100644
--- a/framework/test/unittest/platform/virtual/pin_virtual.c
+++ b/framework/test/unittest/platform/virtual/pin_virtual.c
@@ -114,7 +114,6 @@ static int32_t VirtualPinGetStrength(struct PinCntlr *cntlr, uint32_t index, uin
 
 static int32_t VirtualPinSetFunc(struct PinCntlr *cntlr, uint32_t index, const char *funcName)
 {
-    int ret;
     uint32_t funcNum;
     struct VirtualPinCntlr *virtual = NULL;
 
@@ -131,7 +130,7 @@ static int32_t VirtualPinSetFunc(struct PinCntlr *cntlr, uint32_t index, const c
     virtual = (struct VirtualPinCntlr *)cntlr;
 
     for (funcNum = 0; funcNum < VIRTUAL_PIN_FUNC_MAX; funcNum++) {
-        ret = strcmp(funcName, virtual->desc[index].func[funcNum]);
+        int ret = strcmp(funcName, virtual->desc[index].func[funcNum]);
         if (ret == 0) {
             virtual->desc[index].curFunc = virtual->desc[index].func[funcNum];
             return HDF_SUCCESS;
diff --git a/framework/test/unittest/platform/virtual/regulator_linux_current_virtual_driver.c b/framework/test/unittest/platform/virtual/regulator_linux_current_virtual_driver.c
index 89a2208797f385639285a908dcd995a9d28a5443..94baf4ffd0154fb8e5b5e78546a1345bd02d3b12 100644
--- a/framework/test/unittest/platform/virtual/regulator_linux_current_virtual_driver.c
+++ b/framework/test/unittest/platform/virtual/regulator_linux_current_virtual_driver.c
@@ -64,7 +64,7 @@ enum RegulatorStatus {
 };
 
 static int g_virStatus = VIR_REGULATOR_STATUS_OFF;
-static int VirtualCurrentRegulatorEnable(struct regulator_dev *rdev)
+static int VirtualCurrentRegulatorEnable(const struct regulator_dev *rdev)
 {
     if (rdev == NULL) {
         HDF_LOGE("VirtualCurrentRegulatorEnable: rdev is null!");
@@ -75,7 +75,7 @@ static int VirtualCurrentRegulatorEnable(struct regulator_dev *rdev)
     return HDF_SUCCESS;
 }
 
-static int VirtualCurrentRegulatorDisable(struct regulator_dev *rdev)
+static int VirtualCurrentRegulatorDisable(const struct regulator_dev *rdev)
 {
     if (rdev == NULL) {
         HDF_LOGE("VirtualCurrentRegulatorDisable: rdev is null!");
@@ -86,7 +86,7 @@ static int VirtualCurrentRegulatorDisable(struct regulator_dev *rdev)
     return HDF_SUCCESS;
 }
 
-static int VirtualCurrentRegulatorIsEnabled(struct regulator_dev *rdev)
+static int VirtualCurrentRegulatorIsEnabled(const struct regulator_dev *rdev)
 {
     if (rdev == NULL) {
         HDF_LOGE("VirtualCurrentRegulatorIsEnabled: rdev is null!");
@@ -114,7 +114,7 @@ static int VirtualCurrentRegulatorSetCurrent(struct regulator_dev *rdev, int min
 }
 
 #define VIRTUAL_CURRENT_VAL_500 500
-static int VirtualCurrentRegulatorGetCurrent(struct regulator_dev *rdev)
+static int VirtualCurrentRegulatorGetCurrent(const struct regulator_dev *rdev)
 {
     if (rdev == NULL) {
         HDF_LOGE("VirtualCurrentRegulatorGetCurrent: rdev is null!");
diff --git a/framework/test/unittest/platform/virtual/regulator_linux_voltage_virtual_driver.c b/framework/test/unittest/platform/virtual/regulator_linux_voltage_virtual_driver.c
index ac5ed7698f2e8ef35e3bd9e3598f3b8d0135c733..155419a08c72b5b2e7c77a516d8a04fc0c7ea212 100644
--- a/framework/test/unittest/platform/virtual/regulator_linux_voltage_virtual_driver.c
+++ b/framework/test/unittest/platform/virtual/regulator_linux_voltage_virtual_driver.c
@@ -64,7 +64,7 @@ enum RegulatorStatus {
 };
 
 static int g_virStatus = VIR_REGULATOR_STATUS_OFF;
-static int VirtualVoltageRegulatorEnable(struct regulator_dev *rdev)
+static int VirtualVoltageRegulatorEnable(const struct regulator_dev *rdev)
 {
     if (rdev == NULL) {
         HDF_LOGE("VirtualVoltageRegulatorEnable: rdev is null!");
@@ -75,7 +75,7 @@ static int VirtualVoltageRegulatorEnable(struct regulator_dev *rdev)
     return HDF_SUCCESS;
 }
 
-static int VirtualVoltageRegulatorDisable(struct regulator_dev *rdev)
+static int VirtualVoltageRegulatorDisable(const struct regulator_dev *rdev)
 {
     if (rdev == NULL) {
         HDF_LOGE("VirtualVoltageRegulatorDisable: rdev is null!");
@@ -86,7 +86,7 @@ static int VirtualVoltageRegulatorDisable(struct regulator_dev *rdev)
     return HDF_SUCCESS;
 }
 
-static int VirtualVoltageRegulatorIsEnabled(struct regulator_dev *rdev)
+static int VirtualVoltageRegulatorIsEnabled(const struct regulator_dev *rdev)
 {
     if (rdev == NULL) {
         HDF_LOGE("VirtualVoltageRegulatorIsEnabled: rdev is null!");
@@ -115,7 +115,7 @@ static int VirtualVoltageRegulatorSetVoltage(struct regulator_dev *rdev, int min
 }
 
 #define VIRTUAL_VOLTAGE_VAL_500 500
-static int VirtualVoltageRegulatorGetVoltage(struct regulator_dev *rdev)
+static int VirtualVoltageRegulatorGetVoltage(const struct regulator_dev *rdev)
 {
     if (rdev == NULL) {
         HDF_LOGE("VirtualVoltageRegulatorGetVoltage: rdev is null!");
diff --git a/framework/test/unittest/platform/virtual/regulator_virtual.c b/framework/test/unittest/platform/virtual/regulator_virtual.c
index 7c17c548540a19d6eb3fc7c04dc8164e4fdd8429..74148fa75faea8f9cde172d1c6ca9e44ff979b68 100644
--- a/framework/test/unittest/platform/virtual/regulator_virtual.c
+++ b/framework/test/unittest/platform/virtual/regulator_virtual.c
@@ -257,7 +257,6 @@ static int32_t VirtualRegulatorParseAndInit(struct HdfDeviceObject *device, cons
 
 static int32_t VirtualRegulatorInit(struct HdfDeviceObject *device)
 {
-    int32_t ret;
     const struct DeviceResourceNode *childNode = NULL;
 
     if (device == NULL || device->property == NULL) {
@@ -266,7 +265,7 @@ static int32_t VirtualRegulatorInit(struct HdfDeviceObject *device)
     }
 
     DEV_RES_NODE_FOR_EACH_CHILD_NODE(device->property, childNode) {
-        ret = VirtualRegulatorParseAndInit(device, childNode);
+        int32_t ret = VirtualRegulatorParseAndInit(device, childNode);
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("VirtualRegulatorInit: VirtualRegulatorParseAndInit fail, ret: %d!", ret);
             return ret;
diff --git a/framework/test/unittest/platform/virtual/spi_virtual.c b/framework/test/unittest/platform/virtual/spi_virtual.c
index beca6f684781f18aaa2d7311f7e521abce41e420..1fd3d65a7a0acb0d32c3293a012a36f07659143d 100644
--- a/framework/test/unittest/platform/virtual/spi_virtual.c
+++ b/framework/test/unittest/platform/virtual/spi_virtual.c
@@ -176,7 +176,6 @@ static bool VirtualSpiReadFifo(struct VirtualSpi *virtual, uint8_t *rx, uint32_t
 
 static int32_t VirtualSpiTxRx(struct VirtualSpi *virtual, const struct SpiMsg *msg)
 {
-    int32_t ret;
     uint32_t tmpLen;
     uint32_t len;
     const uint8_t *tx = msg->wbuf;
@@ -195,7 +194,7 @@ static int32_t VirtualSpiTxRx(struct VirtualSpi *virtual, const struct SpiMsg *m
         }
         tx = (tx == NULL) ? NULL : (tx + tmpLen);
         if (tmpLen == burstSize) {
-            ret = OsalSemWait((struct OsalSem *)(&virtual->sem), WAIT_TIMEOUT);
+            int32_t ret = OsalSemWait((struct OsalSem *)(&virtual->sem), WAIT_TIMEOUT);
             if (ret != HDF_SUCCESS) {
                 HDF_LOGE("VirtualSpiTxRx: sem wait timeout, ret: %d!", ret);
                 return ret;
@@ -256,15 +255,13 @@ static int32_t VirtualSpiGetCfg(struct SpiCntlr *cntlr, struct SpiCfg *cfg)
 
 static int32_t VirtualSpiTransferOneMessage(struct VirtualSpi *virtual, struct SpiMsg *msg)
 {
-    int32_t ret;
-
     if (msg == NULL || (msg->rbuf == NULL && msg->wbuf == NULL)) {
         HDF_LOGE("VirtualSpiTransferOneMessage: invalid parameter!");
         return HDF_ERR_INVALID_PARAM;
     }
     virtual->speed = (msg->speed) == 0 ? DEFAULT_SPEED : msg->speed;
 
-    ret = RingBufferConfig(virtual);
+    int32_t ret = RingBufferConfig(virtual);
     if (ret != HDF_SUCCESS) {
         return ret;
     }
@@ -274,7 +271,6 @@ static int32_t VirtualSpiTransferOneMessage(struct VirtualSpi *virtual, struct S
 
 static int32_t VirtualSpiTransfer(struct SpiCntlr *cntlr, struct SpiMsg *msg, uint32_t count)
 {
-    int32_t ret;
     uint32_t i;
     struct VirtualSpi *virtual = NULL;
 
@@ -293,7 +289,7 @@ static int32_t VirtualSpiTransfer(struct SpiCntlr *cntlr, struct SpiMsg *msg, ui
         return HDF_FAILURE;
     }
     for (i = 0; i < count; i++) {
-        ret = VirtualSpiTransferOneMessage(virtual, &(msg[i]));
+        int32_t ret = VirtualSpiTransferOneMessage(virtual, &(msg[i]));
         if (ret != 0) {
             HDF_LOGE("VirtualSpiTransfer: transfer error, ret: %d!", ret);
             return ret;
@@ -371,7 +367,6 @@ static int32_t SpiGetCfgFromHcs(struct VirtualSpi *virtual, const struct DeviceR
 
 static int32_t VirtualSpiInit(struct SpiCntlr *cntlr, const struct HdfDeviceObject *device)
 {
-    int32_t ret;
     struct VirtualSpi *virtual = NULL;
 
     if (device->property == NULL) {
@@ -384,7 +379,7 @@ static int32_t VirtualSpiInit(struct SpiCntlr *cntlr, const struct HdfDeviceObje
         HDF_LOGE("VirtualSpiInit: OsalMemCalloc error!");
         return HDF_FAILURE;
     }
-    ret = SpiGetCfgFromHcs(virtual, device->property);
+    int32_t ret = SpiGetCfgFromHcs(virtual, device->property);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("VirtualSpiInit: SpiGetCfgFromHcs error, ret: %d!", ret);
         OsalMemFree(virtual);
@@ -417,7 +412,6 @@ static int32_t VirtualSpiDeviceBind(struct HdfDeviceObject *device)
 
 static int32_t VirtualSpiDeviceInit(struct HdfDeviceObject *device)
 {
-    int32_t ret;
     struct SpiCntlr *cntlr = NULL;
 
     if (device == NULL) {
@@ -430,7 +424,7 @@ static int32_t VirtualSpiDeviceInit(struct HdfDeviceObject *device)
         return HDF_FAILURE;
     }
 
-    ret = VirtualSpiInit(cntlr, device);
+    int32_t ret = VirtualSpiInit(cntlr, device);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("VirtualSpiDeviceInit: error init, ret: %d!", ret);
         return ret;