diff --git a/components/drivers/spi/spi_msd.c b/components/drivers/spi/spi_msd.c
index cd278df0c2bfa8068d918dd7dd7acd1b549bfaed..fce48de1faf77e56781a6f2c268f6c6348581523 100644
--- a/components/drivers/spi/spi_msd.c
+++ b/components/drivers/spi/spi_msd.c
@@ -23,9 +23,9 @@
 //#define MSD_TRACE
 
 #ifdef MSD_TRACE
-#define MSD_DEBUG(...)         rt_kprintf("[MSD] %d ", rt_tick_get()); rt_kprintf(__VA_ARGS__);
+    #define MSD_DEBUG(...)         rt_kprintf("[MSD] %d ", rt_tick_get()); rt_kprintf(__VA_ARGS__);
 #else
-#define MSD_DEBUG(...)
+    #define MSD_DEBUG(...)
 #endif /* #ifdef MSD_TRACE */
 
 #define DUMMY                 0xFF
@@ -40,23 +40,23 @@ static struct msd_device  _msd_device;
 /* function define */
 static rt_bool_t rt_tick_timeout(rt_tick_t tick_start, rt_tick_t tick_long);
 
-static rt_err_t MSD_take_owner(struct rt_spi_device* spi_device);
-static void MSD_take_cs(struct rt_spi_device* device);
-static void MSD_release_cs(struct rt_spi_device* device);
+static rt_err_t MSD_take_owner(struct rt_spi_device *spi_device);
+static void MSD_take_cs(struct rt_spi_device *device);
+static void MSD_release_cs(struct rt_spi_device *device);
 
-static rt_err_t _wait_token(struct rt_spi_device* device, uint8_t token);
-static rt_err_t _wait_ready(struct rt_spi_device* device);
-static rt_size_t rt_msd_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size);
-static rt_size_t rt_msd_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size);
-static rt_size_t rt_msd_sdhc_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size);
-static rt_size_t rt_msd_sdhc_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size);
+static rt_err_t _wait_token(struct rt_spi_device *device, uint8_t token);
+static rt_err_t _wait_ready(struct rt_spi_device *device);
+static rt_size_t rt_msd_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size);
+static rt_size_t rt_msd_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
+static rt_size_t rt_msd_sdhc_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
+static rt_size_t rt_msd_sdhc_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size);
 
-static rt_err_t MSD_take_owner(struct rt_spi_device* spi_device)
+static rt_err_t MSD_take_owner(struct rt_spi_device *spi_device)
 {
     rt_err_t result;
 
     result = rt_mutex_take(&(spi_device->bus->lock), RT_WAITING_FOREVER);
-    if(result == RT_EOK)
+    if (result == RT_EOK)
     {
         if (spi_device->bus->owner != spi_device)
         {
@@ -73,7 +73,7 @@ static rt_err_t MSD_take_owner(struct rt_spi_device* spi_device)
     return result;
 }
 
-static void MSD_take_cs(struct rt_spi_device* device)
+static void MSD_take_cs(struct rt_spi_device *device)
 {
     struct rt_spi_message message;
 
@@ -88,7 +88,7 @@ static void MSD_take_cs(struct rt_spi_device* device)
     device->bus->ops->xfer(device, &message);
 }
 
-static void MSD_release_cs(struct rt_spi_device* device)
+static void MSD_release_cs(struct rt_spi_device *device)
 {
     struct rt_spi_message message;
 
@@ -109,7 +109,7 @@ static rt_bool_t rt_tick_timeout(rt_tick_t tick_start, rt_tick_t tick_long)
     rt_tick_t tick_now = rt_tick_get();
     rt_bool_t result = RT_FALSE;
 
-    if(tick_end >= tick_start)
+    if (tick_end >= tick_start)
     {
         if (tick_now >= tick_end)
         {
@@ -122,7 +122,7 @@ static rt_bool_t rt_tick_timeout(rt_tick_t tick_start, rt_tick_t tick_long)
     }
     else
     {
-        if ((tick_now < tick_start ) && (tick_now >= tick_end) )
+        if ((tick_now < tick_start) && (tick_now >= tick_end))
         {
             result = RT_TRUE;
         }
@@ -137,7 +137,7 @@ static rt_bool_t rt_tick_timeout(rt_tick_t tick_start, rt_tick_t tick_long)
 
 static uint8_t crc7(const uint8_t *buf, int len)
 {
-    unsigned char	i, j, crc, ch, ch2, ch3;
+    unsigned char   i, j, crc, ch, ch2, ch3;
 
     crc = 0;
 
@@ -167,12 +167,12 @@ static uint8_t crc7(const uint8_t *buf, int len)
 }
 
 static rt_err_t _send_cmd(
-    struct rt_spi_device* device,
+    struct rt_spi_device *device,
     uint8_t cmd,
     uint32_t arg,
     uint8_t crc,
     response_type type,
-    uint8_t * response
+    uint8_t *response
 )
 {
     struct rt_spi_message message;
@@ -187,10 +187,10 @@ static rt_err_t _send_cmd(
     cmd_buffer[4] = (uint8_t)(arg >> 8);
     cmd_buffer[5] = (uint8_t)(arg);
 
-    if(crc == 0x00)
+    if (crc == 0x00)
     {
         crc = crc7(&cmd_buffer[1], 5);
-        crc = (crc<<1) | 0x01;
+        crc = (crc << 1) | 0x01;
     }
     cmd_buffer[6] = (crc);
 
@@ -207,7 +207,7 @@ static rt_err_t _send_cmd(
     /* transfer message */
     device->bus->ops->xfer(device, &message);
 
-    for(i=CARD_NCR; i<(CARD_NCR_MAX+1); i++)
+    for (i = CARD_NCR; i < (CARD_NCR_MAX + 1); i++)
     {
         uint8_t send = DUMMY;
 
@@ -220,28 +220,28 @@ static rt_err_t _send_cmd(
         /* transfer message */
         device->bus->ops->xfer(device, &message);
 
-        if(0 == (response[0] & 0x80))
+        if (0 == (response[0] & 0x80))
         {
             break;
         }
     } /* wait response */
 
-    if((CARD_NCR_MAX+1) == i)
+    if ((CARD_NCR_MAX + 1) == i)
     {
         return RT_ERROR;//fail
     }
 
     //recieve other byte
-    if(type == response_r1)
+    if (type == response_r1)
     {
         return RT_EOK;
     }
-    else if(type == response_r1b)
+    else if (type == response_r1b)
     {
         rt_tick_t tick_start = rt_tick_get();
         uint8_t recv;
 
-        while(1)
+        while (1)
         {
             /* initial message */
             message.send_buf = RT_NULL;
@@ -252,33 +252,33 @@ static rt_err_t _send_cmd(
             /* transfer message */
             device->bus->ops->xfer(device, &message);
 
-            if(recv == DUMMY)
+            if (recv == DUMMY)
             {
                 return RT_EOK;
             }
 
-            if(rt_tick_timeout(tick_start, rt_tick_from_millisecond(2000)))
+            if (rt_tick_timeout(tick_start, rt_tick_from_millisecond(2000)))
             {
                 return RT_ETIMEOUT;
             }
         }
     }
-    else if(type == response_r2)
+    else if (type == response_r2)
     {
         /* initial message */
         message.send_buf = RT_NULL;
-        message.recv_buf = response+1;
+        message.recv_buf = response + 1;
         message.length = 1;
         message.cs_take = message.cs_release = 0;
 
         /* transfer message */
         device->bus->ops->xfer(device, &message);
     }
-    else if((type == response_r3) || (type == response_r7))
+    else if ((type == response_r3) || (type == response_r7))
     {
         /* initial message */
         message.send_buf = RT_NULL;
-        message.recv_buf = response+1;
+        message.recv_buf = response + 1;
         message.length = 4;
         message.cs_take = message.cs_release = 0;
 
@@ -293,7 +293,7 @@ static rt_err_t _send_cmd(
     return RT_EOK;
 }
 
-static rt_err_t _wait_token(struct rt_spi_device* device, uint8_t token)
+static rt_err_t _wait_token(struct rt_spi_device *device, uint8_t token)
 {
     struct rt_spi_message message;
     rt_tick_t tick_start;
@@ -309,17 +309,17 @@ static rt_err_t _wait_token(struct rt_spi_device* device, uint8_t token)
     message.length = 1;
     message.cs_take = message.cs_release = 0;
 
-    while(1)
+    while (1)
     {
         /* transfer message */
         device->bus->ops->xfer(device, &message);
 
-        if(recv == token)
+        if (recv == token)
         {
             return RT_EOK;
         }
 
-        if(rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_WAIT_TOKEN_TIMES)))
+        if (rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_WAIT_TOKEN_TIMES)))
         {
             MSD_DEBUG("[err] wait data start token timeout!\r\n");
             return RT_ETIMEOUT;
@@ -327,7 +327,7 @@ static rt_err_t _wait_token(struct rt_spi_device* device, uint8_t token)
     } /* wati token */
 }
 
-static rt_err_t _wait_ready(struct rt_spi_device* device)
+static rt_err_t _wait_ready(struct rt_spi_device *device)
 {
     struct rt_spi_message message;
     rt_tick_t tick_start;
@@ -342,17 +342,17 @@ static rt_err_t _wait_ready(struct rt_spi_device* device)
     message.length = 1;
     message.cs_take = message.cs_release = 0;
 
-    while(1)
+    while (1)
     {
         /* transfer message */
         device->bus->ops->xfer(device, &message);
 
-        if(recv == DUMMY)
+        if (recv == DUMMY)
         {
             return RT_EOK;
         }
 
-        if(rt_tick_timeout(tick_start, rt_tick_from_millisecond(1000)))
+        if (rt_tick_timeout(tick_start, rt_tick_from_millisecond(1000)))
         {
             MSD_DEBUG("[err] wait ready timeout!\r\n");
             return RT_ETIMEOUT;
@@ -360,14 +360,14 @@ static rt_err_t _wait_ready(struct rt_spi_device* device)
     }
 }
 
-static rt_err_t _read_block(struct rt_spi_device* device, void * buffer, uint32_t block_size)
+static rt_err_t _read_block(struct rt_spi_device *device, void *buffer, uint32_t block_size)
 {
     struct rt_spi_message message;
     rt_err_t result;
 
     /* wati token */
     result = _wait_token(device, MSD_TOKEN_READ_START);
-    if(result != RT_EOK)
+    if (result != RT_EOK)
     {
         return result;
     }
@@ -401,7 +401,7 @@ static rt_err_t _read_block(struct rt_spi_device* device, void * buffer, uint32_
     return RT_EOK;
 }
 
-static rt_err_t _write_block(struct rt_spi_device* device, const void * buffer, uint32_t block_size, uint8_t token)
+static rt_err_t _write_block(struct rt_spi_device *device, const void *buffer, uint32_t block_size, uint8_t token)
 {
     struct rt_spi_message message;
     uint8_t send_buffer[16];
@@ -449,7 +449,7 @@ static rt_err_t _write_block(struct rt_spi_device* device, const void * buffer,
 
 //        response = 0x0E & recv_buffer[2];
         response = MSD_GET_DATA_RESPONSE(recv_buffer[2]);
-        if(response != MSD_DATA_OK)
+        if (response != MSD_DATA_OK)
         {
             MSD_DEBUG("[err] write block fail! data response : 0x%02X\r\n", response);
             return RT_ERROR;
@@ -463,13 +463,13 @@ static rt_err_t _write_block(struct rt_spi_device* device, const void * buffer,
 /* RT-Thread Device Driver Interface */
 static rt_err_t rt_msd_init(rt_device_t dev)
 {
-    struct msd_device * msd = (struct msd_device *)dev;
+    struct msd_device *msd = (struct msd_device *)dev;
     uint8_t response[MSD_RESPONSE_MAX_LEN];
     rt_err_t result = RT_EOK;
     rt_tick_t tick_start;
     uint32_t OCR;
 
-    if(msd->spi_device == RT_NULL)
+    if (msd->spi_device == RT_NULL)
     {
         MSD_DEBUG("[err] the SPI SD device has no SPI!\r\n");
         return RT_EIO;
@@ -480,7 +480,7 @@ static rt_err_t rt_msd_init(rt_device_t dev)
         struct rt_spi_configuration cfg;
         cfg.data_width = 8;
         cfg.mode = RT_SPI_MODE_0 | RT_SPI_MSB; /* SPI Compatible Modes 0 */
-        cfg.max_hz = 1000*400; /* 400kbit/s */
+        cfg.max_hz = 1000 * 400; /* 400kbit/s */
         rt_spi_configure(msd->spi_device, &cfg);
     } /* config spi */
 
@@ -518,18 +518,18 @@ static rt_err_t rt_msd_init(rt_device_t dev)
         {
             tick_start = rt_tick_get();
 
-            while(1)
+            while (1)
             {
                 MSD_take_cs(msd->spi_device);
                 result = _send_cmd(msd->spi_device, GO_IDLE_STATE, 0x00, 0x95, response_r1, response);
                 MSD_release_cs(msd->spi_device);
 
-                if((result == RT_EOK) && (response[0] == MSD_IN_IDLE_STATE))
+                if ((result == RT_EOK) && (response[0] == MSD_IN_IDLE_STATE))
                 {
                     break;
                 }
 
-                if(rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES)))
+                if (rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES)))
                 {
                     MSD_DEBUG("[err] SD card goto IDLE mode timeout!\r\n");
                     result = RT_ETIMEOUT;
@@ -550,12 +550,12 @@ static rt_err_t rt_msd_init(rt_device_t dev)
                 result = _send_cmd(msd->spi_device, SEND_IF_COND, 0x01AA, 0x87, response_r7, response);
                 MSD_release_cs(msd->spi_device);
 
-                if(result == RT_EOK)
+                if (result == RT_EOK)
                 {
                     MSD_DEBUG("[info] CMD8 response : 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\r\n",
                               response[0], response[1], response[2], response[3], response[4]);
 
-                    if(response[0] & (1<<2))
+                    if (response[0] & (1 << 2))
                     {
                         /* illegal command, SD V1.x or MMC card */
                         MSD_DEBUG("[info] CMD8 is illegal command.\r\n");
@@ -570,7 +570,7 @@ static rt_err_t rt_msd_init(rt_device_t dev)
                         msd->card_type = MSD_CARD_TYPE_SD_V2_X;
                     }
 
-                    if((0xAA == response[4]) && (0x00 == response[3]))
+                    if ((0xAA == response[4]) && (0x00 == response[3]))
                     {
                         /* SD2.0 not support current voltage */
                         MSD_DEBUG("[err] VCA = 0, SD2.0 not surpport current operation voltage range\r\n");
@@ -580,7 +580,7 @@ static rt_err_t rt_msd_init(rt_device_t dev)
                 }
                 else
                 {
-                    if(rt_tick_timeout(tick_start, rt_tick_from_millisecond(200)))
+                    if (rt_tick_timeout(tick_start, rt_tick_from_millisecond(200)))
                     {
                         MSD_DEBUG("[err] CMD8 SEND_IF_COND timeout!\r\n");
                         result = RT_ETIMEOUT;
@@ -588,29 +588,29 @@ static rt_err_t rt_msd_init(rt_device_t dev)
                     }
                 }
             }
-            while(0xAA != response[4]);
+            while (0xAA != response[4]);
         } /* CMD8 */
 
         /* Ver1.X SD Memory Card or MMC card */
-        if(msd->card_type == MSD_CARD_TYPE_SD_V1_X)
+        if (msd->card_type == MSD_CARD_TYPE_SD_V1_X)
         {
             rt_bool_t is_sd_v1_x = RT_FALSE;
             rt_tick_t tick_start;
 
             /* try SD Ver1.x */
-            while(1)
+            while (1)
             {
                 MSD_take_cs(msd->spi_device);
 
                 result = _send_cmd(msd->spi_device, READ_OCR, 0x00, 0x00, response_r3, response);
-                if(result != RT_EOK)
+                if (result != RT_EOK)
                 {
                     MSD_release_cs(msd->spi_device);
                     MSD_DEBUG("[info] It maybe SD1.x or MMC But it is Not response to CMD58!\r\n");
                     goto _exit;
                 }
 
-                if(0 != (response[0]&0xFE))
+                if (0 != (response[0] & 0xFE))
                 {
                     MSD_release_cs(msd->spi_device);
                     MSD_DEBUG("[info] It look CMD58 as illegal command so it is not SD card!\r\n");
@@ -619,12 +619,12 @@ static rt_err_t rt_msd_init(rt_device_t dev)
                 MSD_release_cs(msd->spi_device);
 
                 OCR = response[1];
-                OCR = (OCR<<8) + response[2];
-                OCR = (OCR<<8) + response[3];
-                OCR = (OCR<<8) + response[4];
+                OCR = (OCR << 8) + response[2];
+                OCR = (OCR << 8) + response[3];
+                OCR = (OCR << 8) + response[4];
                 MSD_DEBUG("[info] OCR is 0x%08X\r\n", OCR);
 
-                if( 0 == (OCR & (0x1 << 15)))
+                if (0 == (OCR & (0x1 << 15)))
                 {
                     MSD_DEBUG(("[err] SD 1.x But not surpport current voltage\r\n"));
                     result = RT_ERROR;
@@ -635,9 +635,9 @@ static rt_err_t rt_msd_init(rt_device_t dev)
                 tick_start = rt_tick_get();
 
                 /* try CMD55 + ACMD41 */
-                while(1)
+                while (1)
                 {
-                    if(rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES_ACMD41)))
+                    if (rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES_ACMD41)))
                     {
                         MSD_release_cs(msd->spi_device);
                         MSD_DEBUG("[info] try CMD55 + ACMD41 timeout! mabey MMC card!\r\n");
@@ -648,13 +648,13 @@ static rt_err_t rt_msd_init(rt_device_t dev)
 
                     /* CMD55 APP_CMD */
                     result = _send_cmd(msd->spi_device, APP_CMD, 0x00, 0x00, response_r1, response);
-                    if(result != RT_EOK)
+                    if (result != RT_EOK)
                     {
                         MSD_release_cs(msd->spi_device);
                         continue;
                     }
 
-                    if(0 != (response[0]&0xFE))
+                    if (0 != (response[0] & 0xFE))
                     {
                         MSD_release_cs(msd->spi_device);
                         MSD_DEBUG("[info] Not SD card2 , may be MMC\r\n");
@@ -663,20 +663,20 @@ static rt_err_t rt_msd_init(rt_device_t dev)
 
                     /* ACMD41 SD_SEND_OP_COND */
                     result = _send_cmd(msd->spi_device, SD_SEND_OP_COND, 0x00, 0x00, response_r1, response);
-                    if(result != RT_EOK)
+                    if (result != RT_EOK)
                     {
                         MSD_release_cs(msd->spi_device);
                         continue;
                     }
 
-                    if(0 != (response[0]&0xFE))
+                    if (0 != (response[0] & 0xFE))
                     {
                         MSD_release_cs(msd->spi_device);
                         MSD_DEBUG("[info] Not SD card4 , may be MMC\r\n");
                         break;
                     }
 
-                    if(0 == (response[0]&0xFF))
+                    if (0 == (response[0] & 0xFF))
                     {
                         MSD_release_cs(msd->spi_device);
                         is_sd_v1_x = RT_TRUE;
@@ -689,7 +689,7 @@ static rt_err_t rt_msd_init(rt_device_t dev)
             } /* try SD Ver1.x */
 
             /* try MMC */
-            if(is_sd_v1_x != RT_TRUE)
+            if (is_sd_v1_x != RT_TRUE)
             {
                 uint32_t i;
 
@@ -707,7 +707,7 @@ static rt_err_t rt_msd_init(rt_device_t dev)
                     message.length = sizeof(send_buffer);
                     message.cs_take = message.cs_release = 0;
 
-                    for(i=0; i<10; i++)
+                    for (i = 0; i < 10; i++)
                     {
                         /* transfer message */
                         msd->spi_device->bus->ops->xfer(msd->spi_device, &message);
@@ -716,18 +716,18 @@ static rt_err_t rt_msd_init(rt_device_t dev)
 
                 /* send CMD0 goto IDLE state */
                 tick_start = rt_tick_get();
-                while(1)
+                while (1)
                 {
                     MSD_take_cs(msd->spi_device);
                     result = _send_cmd(msd->spi_device, GO_IDLE_STATE, 0x00, 0x95, response_r1, response);
                     MSD_release_cs(msd->spi_device);
 
-                    if((result == RT_EOK) && (response[0] == MSD_IN_IDLE_STATE))
+                    if ((result == RT_EOK) && (response[0] == MSD_IN_IDLE_STATE))
                     {
                         break;
                     }
 
-                    if(rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES)))
+                    if (rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES)))
                     {
                         MSD_DEBUG("[err] SD card goto IDLE mode timeout!\r\n");
                         result = RT_ETIMEOUT;
@@ -737,20 +737,20 @@ static rt_err_t rt_msd_init(rt_device_t dev)
 
                 /* send CMD1 */
                 tick_start = rt_tick_get();
-                while(1)
+                while (1)
                 {
                     MSD_take_cs(msd->spi_device);
                     result = _send_cmd(msd->spi_device, SEND_OP_COND, 0x00, 0x00, response_r1, response);
                     MSD_release_cs(msd->spi_device);
 
-                    if((result == RT_EOK) && (response[0] == MSD_RESPONSE_NO_ERROR))
+                    if ((result == RT_EOK) && (response[0] == MSD_RESPONSE_NO_ERROR))
                     {
                         MSD_DEBUG("[info] It is MMC card!!!\r\n");
                         msd->card_type = MSD_CARD_TYPE_MMC;
                         break;
                     }
 
-                    if(rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES)))
+                    if (rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES)))
                     {
                         MSD_DEBUG("[err] SD card goto IDLE mode timeout!\r\n");
                         result = RT_ETIMEOUT;
@@ -759,19 +759,19 @@ static rt_err_t rt_msd_init(rt_device_t dev)
                 } /* send CMD1 */
             } /* try MMC */
         }
-        else if(msd->card_type == MSD_CARD_TYPE_SD_V2_X)
+        else if (msd->card_type == MSD_CARD_TYPE_SD_V2_X)
         {
             MSD_take_cs(msd->spi_device);
 
             result = _send_cmd(msd->spi_device, READ_OCR, 0x00, 0x00, response_r3, response);
-            if(result != RT_EOK)
+            if (result != RT_EOK)
             {
                 MSD_release_cs(msd->spi_device);
                 MSD_DEBUG("[err] It maybe SD2.0 But it is Not response to CMD58!\r\n");
                 goto _exit;
             }
 
-            if((response[0] & 0xFE) != 0)
+            if ((response[0] & 0xFE) != 0)
             {
                 MSD_release_cs(msd->spi_device);
                 MSD_DEBUG("[err] It look CMD58 as illegal command so it is not SD card!\r\n");
@@ -782,12 +782,12 @@ static rt_err_t rt_msd_init(rt_device_t dev)
             MSD_release_cs(msd->spi_device);
 
             OCR = response[1];
-            OCR = (OCR<<8) + response[2];
-            OCR = (OCR<<8) + response[3];
-            OCR = (OCR<<8) + response[4];
+            OCR = (OCR << 8) + response[2];
+            OCR = (OCR << 8) + response[3];
+            OCR = (OCR << 8) + response[4];
             MSD_DEBUG("[info] OCR is 0x%08X\r\n", OCR);
 
-            if( 0 == (OCR & (0x1 << 15)))
+            if (0 == (OCR & (0x1 << 15)))
             {
                 MSD_DEBUG(("[err] SD 1.x But not surpport current voltage\r\n"));
                 result = RT_ERROR;
@@ -801,7 +801,7 @@ static rt_err_t rt_msd_init(rt_device_t dev)
             do
             {
                 MSD_take_cs(msd->spi_device);
-                if(rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES_ACMD41)))
+                if (rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES_ACMD41)))
                 {
                     MSD_release_cs(msd->spi_device);
                     MSD_DEBUG("[err] SD Ver2.x or later try CMD55 + ACMD41 timeout!\r\n");
@@ -812,13 +812,13 @@ static rt_err_t rt_msd_init(rt_device_t dev)
                 /* CMD55 APP_CMD */
                 result = _send_cmd(msd->spi_device, APP_CMD, 0x00, 0x65, response_r1, response);
 //                if((result != RT_EOK) || (response[0] == 0x01))
-                if(result != RT_EOK)
+                if (result != RT_EOK)
                 {
                     MSD_release_cs(msd->spi_device);
                     continue;
                 }
 
-                if((response[0] & 0xFE) != 0)
+                if ((response[0] & 0xFE) != 0)
                 {
                     MSD_release_cs(msd->spi_device);
                     MSD_DEBUG("[err] Not SD ready!\r\n");
@@ -828,7 +828,7 @@ static rt_err_t rt_msd_init(rt_device_t dev)
 
                 /* ACMD41 SD_SEND_OP_COND */
                 result = _send_cmd(msd->spi_device, SD_SEND_OP_COND, 0x40000000, 0x77, response_r1, response);
-                if(result != RT_EOK)
+                if (result != RT_EOK)
                 {
                     MSD_release_cs(msd->spi_device);
                     MSD_DEBUG("[err] ACMD41 fail!\r\n");
@@ -836,28 +836,28 @@ static rt_err_t rt_msd_init(rt_device_t dev)
                     goto _exit;
                 }
 
-                if((response[0] & 0xFE) != 0)
+                if ((response[0] & 0xFE) != 0)
                 {
                     MSD_release_cs(msd->spi_device);
                     MSD_DEBUG("[info] Not SD card4 , response : 0x%02X\r\n", response[0]);
 //                    break;
                 }
             }
-            while(response[0] != MSD_RESPONSE_NO_ERROR);
+            while (response[0] != MSD_RESPONSE_NO_ERROR);
             MSD_release_cs(msd->spi_device);
             /* try CMD55 + ACMD41 */
 
             /* --Read OCR again */
             MSD_take_cs(msd->spi_device);
             result = _send_cmd(msd->spi_device, READ_OCR, 0x00, 0x00, response_r3, response);
-            if(result != RT_EOK)
+            if (result != RT_EOK)
             {
                 MSD_release_cs(msd->spi_device);
                 MSD_DEBUG("[err] It maybe SD2.0 But it is Not response to 2nd CMD58!\r\n");
                 goto _exit;
             }
 
-            if((response[0] & 0xFE) != 0)
+            if ((response[0] & 0xFE) != 0)
             {
                 MSD_release_cs(msd->spi_device);
                 MSD_DEBUG("[err] It look 2nd CMD58 as illegal command so it is not SD card!\r\n");
@@ -867,12 +867,12 @@ static rt_err_t rt_msd_init(rt_device_t dev)
             MSD_release_cs(msd->spi_device);
 
             OCR = response[1];
-            OCR = (OCR<<8) + response[2];
-            OCR = (OCR<<8) + response[3];
-            OCR = (OCR<<8) + response[4];
+            OCR = (OCR << 8) + response[2];
+            OCR = (OCR << 8) + response[3];
+            OCR = (OCR << 8) + response[4];
             MSD_DEBUG("[info] OCR 2nd read is 0x%08X\r\n", OCR);
 
-            if((OCR & 0x40000000) != 0)
+            if ((OCR & 0x40000000) != 0)
             {
                 MSD_DEBUG("[info] It is SD2.0 SDHC Card!!!\r\n");
                 msd->card_type = MSD_CARD_TYPE_SD_SDHC;
@@ -890,7 +890,7 @@ static rt_err_t rt_msd_init(rt_device_t dev)
         }
     } /* init SD card */
 
-    if(msd->card_type == MSD_CARD_TYPE_SD_SDHC)
+    if (msd->card_type == MSD_CARD_TYPE_SD_SDHC)
     {
         dev->read  = rt_msd_sdhc_read;
         dev->write = rt_msd_sdhc_write;
@@ -911,7 +911,7 @@ static rt_err_t rt_msd_init(rt_device_t dev)
         result = _send_cmd(msd->spi_device, CRC_ON_OFF, 0x00, 0x91, response_r1, response);
 #endif
         MSD_release_cs(msd->spi_device);
-        if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
+        if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
         {
             MSD_DEBUG("[err] CMD59 CRC_ON_OFF fail! response : 0x%02X\r\n", response[0]);
             result = RT_ERROR;
@@ -925,7 +925,7 @@ static rt_err_t rt_msd_init(rt_device_t dev)
         MSD_take_cs(msd->spi_device);
         result = _send_cmd(msd->spi_device, SET_BLOCKLEN, SECTOR_SIZE, 0x00, response_r1, response);
         MSD_release_cs(msd->spi_device);
-        if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
+        if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
         {
             MSD_DEBUG("[err] CMD16 SET_BLOCKLEN fail! response : 0x%02X\r\n", response[0]);
             result = RT_ERROR;
@@ -943,14 +943,14 @@ static rt_err_t rt_msd_init(rt_device_t dev)
 //        result = _send_cmd(msd->spi_device, SEND_CSD, 0x00, 0xAF, response_r1, response);
         result = _send_cmd(msd->spi_device, SEND_CSD, 0x00, 0x00, response_r1, response);
 
-        if(result != RT_EOK)
+        if (result != RT_EOK)
         {
             MSD_release_cs(msd->spi_device);
             MSD_DEBUG("[err] CMD9 SEND_CSD timeout!\r\n");
             goto _exit;
         }
 
-        if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
+        if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
         {
             MSD_release_cs(msd->spi_device);
             MSD_DEBUG("[err] CMD9 SEND_CSD fail! response : 0x%02X\r\n", response[0]);
@@ -960,7 +960,7 @@ static rt_err_t rt_msd_init(rt_device_t dev)
 
         result = _read_block(msd->spi_device, CSD_buffer, MSD_CSD_LEN);
         MSD_release_cs(msd->spi_device);
-        if(result != RT_EOK)
+        if (result != RT_EOK)
         {
             MSD_DEBUG("[err] read CSD fail!\r\n");
             goto _exit;
@@ -981,27 +981,27 @@ static rt_err_t rt_msd_init(rt_device_t dev)
             CSD_STRUCTURE = tmp8 >> 6;
 
             /* MMC CSD Analyze. */
-            if(msd->card_type == MSD_CARD_TYPE_MMC)
+            if (msd->card_type == MSD_CARD_TYPE_MMC)
             {
                 uint8_t C_SIZE_MULT;
                 uint8_t READ_BL_LEN;
 
-                if(CSD_STRUCTURE > 2)
+                if (CSD_STRUCTURE > 2)
                 {
                     MSD_DEBUG("[err] bad CSD Version : %d\r\n", CSD_STRUCTURE);
                     result = RT_ERROR;
                     goto _exit;
                 }
 
-                if(CSD_STRUCTURE == 0)
+                if (CSD_STRUCTURE == 0)
                 {
                     MSD_DEBUG("[info] CSD version No. 1.0\r\n");
                 }
-                else if(CSD_STRUCTURE == 1)
+                else if (CSD_STRUCTURE == 1)
                 {
                     MSD_DEBUG("[info] CSD version No. 1.1\r\n");
                 }
-                else if(CSD_STRUCTURE == 2)
+                else if (CSD_STRUCTURE == 2)
                 {
                     MSD_DEBUG("[info] CSD version No. 1.2\r\n");
                 }
@@ -1009,65 +1009,65 @@ static rt_err_t rt_msd_init(rt_device_t dev)
                 /* get TRAN_SPEED 8bit [103:96] */
                 tmp8 = CSD_buffer[3];
                 tmp8 &= 0x03; /* [2:0] transfer rate unit.*/
-                if(tmp8 == 0)
+                if (tmp8 == 0)
                 {
                     msd->max_clock = 100 * 1000; /* 0=100kbit/s. */
                 }
-                else if(tmp8 == 1)
+                else if (tmp8 == 1)
                 {
                     msd->max_clock = 1 * 1000 * 1000; /* 1=1Mbit/s. */
                 }
-                else if(tmp8 == 2)
+                else if (tmp8 == 2)
                 {
                     msd->max_clock = 10 * 1000 * 1000; /* 2=10Mbit/s. */
                 }
-                else if(tmp8 == 3)
+                else if (tmp8 == 3)
                 {
                     msd->max_clock = 100 * 1000 * 1000; /* 3=100Mbit/s. */
                 }
-                if(tmp8 == 0)
+                if (tmp8 == 0)
                 {
-                    MSD_DEBUG("[info] TRAN_SPEED: 0x%02X, %dkbit/s.\r\n", tmp8, msd->max_clock/1000);
+                    MSD_DEBUG("[info] TRAN_SPEED: 0x%02X, %dkbit/s.\r\n", tmp8, msd->max_clock / 1000);
                 }
                 else
                 {
-                    MSD_DEBUG("[info] TRAN_SPEED: 0x%02X, %dMbit/s.\r\n", tmp8, msd->max_clock/1000/1000);
+                    MSD_DEBUG("[info] TRAN_SPEED: 0x%02X, %dMbit/s.\r\n", tmp8, msd->max_clock / 1000 / 1000);
                 }
 
                 /* get READ_BL_LEN 4bit [83:80] */
                 tmp8 = CSD_buffer[5] & 0x0F; /* 0b00001111; */
-                READ_BL_LEN = tmp8;		     /* 4 bit */
+                READ_BL_LEN = tmp8;          /* 4 bit */
                 MSD_DEBUG("[info] CSD : READ_BL_LEN : %d %dbyte\r\n", READ_BL_LEN, (1 << READ_BL_LEN));
 
                 /* get C_SIZE 12bit [73:62] */
                 tmp16 = CSD_buffer[6] & 0x03; /* get [73:72] 0b00000011 */
-                tmp16 = tmp16<<8;
+                tmp16 = tmp16 << 8;
                 tmp16 += CSD_buffer[7];       /* get [71:64] */
-                tmp16 = tmp16<<2;
+                tmp16 = tmp16 << 2;
                 tmp8 = CSD_buffer[8] & 0xC0;  /* get [63:62] 0b11000000 */
-                tmp8 = tmp8>>6;
+                tmp8 = tmp8 >> 6;
                 tmp16 = tmp16 + tmp8;
-                C_SIZE = tmp16;				//12 bit
+                C_SIZE = tmp16;             //12 bit
                 MSD_DEBUG("[info] CSD : C_SIZE : %d\r\n", C_SIZE);
 
                 /* get C_SIZE_MULT 3bit [49:47] */
                 tmp8 = CSD_buffer[9] & 0x03;//0b00000011;
-                tmp8 = tmp8<<1;
-                tmp8 = tmp8 + ((CSD_buffer[10] & 0x80/*0b10000000*/)>>7);
-                C_SIZE_MULT = tmp8;			// 3 bit
+                tmp8 = tmp8 << 1;
+                tmp8 = tmp8 + ((CSD_buffer[10] & 0x80/*0b10000000*/) >> 7);
+                C_SIZE_MULT = tmp8;         // 3 bit
                 MSD_DEBUG("[info] CSD : C_SIZE_MULT : %d\r\n", C_SIZE_MULT);
 
                 /* memory capacity = BLOCKNR * BLOCK_LEN */
                 /* BLOCKNR = (C_SIZE+1) * MULT */
                 /* MULT = 2^(C_SIZE_MULT+2) */
                 /* BLOCK_LEN = 2^READ_BL_LEN */
-                card_capacity = (1 << READ_BL_LEN) * ((C_SIZE + 1) * (1 << (C_SIZE_MULT+2)));
+                card_capacity = (1 << READ_BL_LEN) * ((C_SIZE + 1) * (1 << (C_SIZE_MULT + 2)));
                 msd->geometry.sector_count = card_capacity / msd->geometry.bytes_per_sector;
-                MSD_DEBUG("[info] card capacity : %d Mbyte\r\n", card_capacity/(1024*1024));
+                MSD_DEBUG("[info] card capacity : %d Mbyte\r\n", card_capacity / (1024 * 1024));
             }
             else /* SD CSD Analyze. */
             {
-                if(CSD_STRUCTURE == 0)
+                if (CSD_STRUCTURE == 0)
                 {
                     uint8_t C_SIZE_MULT;
                     uint8_t READ_BL_LEN;
@@ -1076,11 +1076,11 @@ static rt_err_t rt_msd_init(rt_device_t dev)
 
                     /* get TRAN_SPEED 8bit [103:96] */
                     tmp8 = CSD_buffer[3];
-                    if(tmp8 == 0x32)
+                    if (tmp8 == 0x32)
                     {
                         msd->max_clock = 1000 * 1000 * 10; /* 10Mbit/s. */
                     }
-                    else if(tmp8 == 0x5A)
+                    else if (tmp8 == 0x5A)
                     {
                         msd->max_clock = 1000 * 1000 * 50; /* 50Mbit/s. */
                     }
@@ -1088,60 +1088,60 @@ static rt_err_t rt_msd_init(rt_device_t dev)
                     {
                         msd->max_clock = 1000 * 1000 * 1; /* 1Mbit/s default. */
                     }
-                    MSD_DEBUG("[info] TRAN_SPEED: 0x%02X, %dMbit/s.\r\n", tmp8, msd->max_clock/1000/1000);
+                    MSD_DEBUG("[info] TRAN_SPEED: 0x%02X, %dMbit/s.\r\n", tmp8, msd->max_clock / 1000 / 1000);
 
                     /* get READ_BL_LEN 4bit [83:80] */
                     tmp8 = CSD_buffer[5] & 0x0F; /* 0b00001111; */
-                    READ_BL_LEN = tmp8;		     /* 4 bit */
+                    READ_BL_LEN = tmp8;          /* 4 bit */
                     MSD_DEBUG("[info] CSD : READ_BL_LEN : %d %dbyte\r\n", READ_BL_LEN, (1 << READ_BL_LEN));
 
                     /* get C_SIZE 12bit [73:62] */
                     tmp16 = CSD_buffer[6] & 0x03; /* get [73:72] 0b00000011 */
-                    tmp16 = tmp16<<8;
+                    tmp16 = tmp16 << 8;
                     tmp16 += CSD_buffer[7];       /* get [71:64] */
-                    tmp16 = tmp16<<2;
+                    tmp16 = tmp16 << 2;
                     tmp8 = CSD_buffer[8] & 0xC0;  /* get [63:62] 0b11000000 */
-                    tmp8 = tmp8>>6;
+                    tmp8 = tmp8 >> 6;
                     tmp16 = tmp16 + tmp8;
-                    C_SIZE = tmp16;				//12 bit
+                    C_SIZE = tmp16;             //12 bit
                     MSD_DEBUG("[info] CSD : C_SIZE : %d\r\n", C_SIZE);
 
                     /* get C_SIZE_MULT 3bit [49:47] */
                     tmp8 = CSD_buffer[9] & 0x03;//0b00000011;
-                    tmp8 = tmp8<<1;
-                    tmp8 = tmp8 + ((CSD_buffer[10] & 0x80/*0b10000000*/)>>7);
-                    C_SIZE_MULT = tmp8;			// 3 bit
+                    tmp8 = tmp8 << 1;
+                    tmp8 = tmp8 + ((CSD_buffer[10] & 0x80/*0b10000000*/) >> 7);
+                    C_SIZE_MULT = tmp8;         // 3 bit
                     MSD_DEBUG("[info] CSD : C_SIZE_MULT : %d\r\n", C_SIZE_MULT);
 
                     /* memory capacity = BLOCKNR * BLOCK_LEN */
                     /* BLOCKNR = (C_SIZE+1) * MULT */
                     /* MULT = 2^(C_SIZE_MULT+2) */
                     /* BLOCK_LEN = 2^READ_BL_LEN */
-                    card_capacity = (1 << READ_BL_LEN) * ((C_SIZE + 1) * (1 << (C_SIZE_MULT+2)));
+                    card_capacity = (1 << READ_BL_LEN) * ((C_SIZE + 1) * (1 << (C_SIZE_MULT + 2)));
                     msd->geometry.sector_count = card_capacity / msd->geometry.bytes_per_sector;
-                    MSD_DEBUG("[info] card capacity : %d Mbyte\r\n", card_capacity/(1024*1024));
+                    MSD_DEBUG("[info] card capacity : %d Mbyte\r\n", card_capacity / (1024 * 1024));
                 }
-                else if(CSD_STRUCTURE == 1)
+                else if (CSD_STRUCTURE == 1)
                 {
                     MSD_DEBUG("[info] CSD Version 2.0\r\n");
 
                     /* get TRAN_SPEED 8bit [103:96] */
                     tmp8 = CSD_buffer[3];
-                    if(tmp8 == 0x32)
+                    if (tmp8 == 0x32)
                     {
                         msd->max_clock = 1000 * 1000 * 10; /* 10Mbit/s. */
                     }
-                    else if(tmp8 == 0x5A)
+                    else if (tmp8 == 0x5A)
                     {
                         msd->max_clock = 1000 * 1000 * 50; /* 50Mbit/s. */
                     }
-                    else if(tmp8 == 0x0B)
+                    else if (tmp8 == 0x0B)
                     {
                         msd->max_clock = 1000 * 1000 * 100; /* 100Mbit/s. */
                         /* UHS50 Card sets TRAN_SPEED to 0Bh (100Mbit/sec), */
                         /* for both SDR50 and DDR50 modes. */
                     }
-                    else if(tmp8 == 0x2B)
+                    else if (tmp8 == 0x2B)
                     {
                         msd->max_clock = 1000 * 1000 * 200; /* 200Mbit/s. */
                         /* UHS104 Card sets TRAN_SPEED to 2Bh (200Mbit/sec). */
@@ -1150,13 +1150,13 @@ static rt_err_t rt_msd_init(rt_device_t dev)
                     {
                         msd->max_clock = 1000 * 1000 * 1; /* 1Mbit/s default. */
                     }
-                    MSD_DEBUG("[info] TRAN_SPEED: 0x%02X, %dMbit/s.\r\n", tmp8, msd->max_clock/1000/1000);
+                    MSD_DEBUG("[info] TRAN_SPEED: 0x%02X, %dMbit/s.\r\n", tmp8, msd->max_clock / 1000 / 1000);
 
                     /* get C_SIZE 22bit [69:48] */
                     tmp32 = CSD_buffer[7] & 0x3F; /* 0b00111111 */
-                    tmp32 = tmp32<<8;
+                    tmp32 = tmp32 << 8;
                     tmp32 += CSD_buffer[8];
-                    tmp32 = tmp32<<8;
+                    tmp32 = tmp32 << 8;
                     tmp32 += CSD_buffer[9];
                     C_SIZE = tmp32;
                     MSD_DEBUG("[info] CSD : C_SIZE : %d\r\n", C_SIZE);
@@ -1164,7 +1164,7 @@ static rt_err_t rt_msd_init(rt_device_t dev)
                     /* memory capacity = (C_SIZE+1) * 512K byte */
                     card_capacity = (C_SIZE + 1) / 2; /* unit : Mbyte */
                     msd->geometry.sector_count = card_capacity * 1024; /* 1 Mbyte = 512 byte X 2048 */
-                    MSD_DEBUG("[info] card capacity : %d.%d Gbyte\r\n", card_capacity/1024, (card_capacity%1024)*100/1024);
+                    MSD_DEBUG("[info] card capacity : %d.%d Gbyte\r\n", card_capacity / 1024, (card_capacity % 1024) * 100 / 1024);
                 }
                 else
                 {
@@ -1205,9 +1205,9 @@ static rt_err_t rt_msd_close(rt_device_t dev)
     return RT_EOK;
 }
 
-static rt_size_t rt_msd_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)
+static rt_size_t rt_msd_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
 {
-    struct msd_device * msd = (struct msd_device *)dev;
+    struct msd_device *msd = (struct msd_device *)dev;
     uint8_t response[MSD_RESPONSE_MAX_LEN];
     rt_err_t result = RT_EOK;
 
@@ -1229,12 +1229,12 @@ static rt_size_t rt_msd_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_siz
     } /* config spi */
 
     /* SINGLE_BLOCK? */
-    if(size == 1)
+    if (size == 1)
     {
         MSD_take_cs(msd->spi_device);
 
         result = _send_cmd(msd->spi_device, READ_SINGLE_BLOCK, pos * msd->geometry.bytes_per_sector, 0x00, response_r1, response);
-        if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
+        if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
         {
             MSD_DEBUG("[err] read SINGLE_BLOCK #%d fail!\r\n", pos);
             size = 0;
@@ -1242,32 +1242,32 @@ static rt_size_t rt_msd_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_siz
         }
 
         result = _read_block(msd->spi_device, buffer, msd->geometry.bytes_per_sector);
-        if(result != RT_EOK)
+        if (result != RT_EOK)
         {
             MSD_DEBUG("[err] read SINGLE_BLOCK #%d fail!\r\n", pos);
             size = 0;
         }
     }
-    else if(size > 1)
+    else if (size > 1)
     {
         uint32_t i;
 
         MSD_take_cs(msd->spi_device);
 
         result = _send_cmd(msd->spi_device, READ_MULTIPLE_BLOCK, pos * msd->geometry.bytes_per_sector, 0x00, response_r1, response);
-        if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
+        if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
         {
             MSD_DEBUG("[err] read READ_MULTIPLE_BLOCK #%d fail!\r\n", pos);
             size = 0;
             goto _exit;
         }
 
-        for(i=0; i<size; i++)
+        for (i = 0; i < size; i++)
         {
             result = _read_block(msd->spi_device,
                                  (uint8_t *)buffer + msd->geometry.bytes_per_sector * i,
                                  msd->geometry.bytes_per_sector);
-            if(result != RT_EOK)
+            if (result != RT_EOK)
             {
                 MSD_DEBUG("[err] read READ_MULTIPLE_BLOCK #%d fail!\r\n", pos);
                 size = i;
@@ -1277,7 +1277,7 @@ static rt_size_t rt_msd_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_siz
 
         /* send CMD12 stop transfer */
         result = _send_cmd(msd->spi_device, STOP_TRANSMISSION, 0x00, 0x00, response_r1b, response);
-        if(result != RT_EOK)
+        if (result != RT_EOK)
         {
             MSD_DEBUG("[err] read READ_MULTIPLE_BLOCK, send stop token fail!\r\n");
         }
@@ -1291,9 +1291,9 @@ _exit:
     return size;
 }
 
-static rt_size_t rt_msd_sdhc_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)
+static rt_size_t rt_msd_sdhc_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
 {
-    struct msd_device * msd = (struct msd_device *)dev;
+    struct msd_device *msd = (struct msd_device *)dev;
     uint8_t response[MSD_RESPONSE_MAX_LEN];
     rt_err_t result = RT_EOK;
 
@@ -1315,12 +1315,12 @@ static rt_size_t rt_msd_sdhc_read(rt_device_t dev, rt_off_t pos, void* buffer, r
     } /* config spi */
 
     /* SINGLE_BLOCK? */
-    if(size == 1)
+    if (size == 1)
     {
         MSD_take_cs(msd->spi_device);
 
         result = _send_cmd(msd->spi_device, READ_SINGLE_BLOCK, pos, 0x00, response_r1, response);
-        if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
+        if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
         {
             MSD_DEBUG("[err] read SINGLE_BLOCK #%d fail!\r\n", pos);
             size = 0;
@@ -1328,32 +1328,32 @@ static rt_size_t rt_msd_sdhc_read(rt_device_t dev, rt_off_t pos, void* buffer, r
         }
 
         result = _read_block(msd->spi_device, buffer, msd->geometry.bytes_per_sector);
-        if(result != RT_EOK)
+        if (result != RT_EOK)
         {
             MSD_DEBUG("[err] read SINGLE_BLOCK #%d fail!\r\n", pos);
             size = 0;
         }
     }
-    else if(size > 1)
+    else if (size > 1)
     {
         uint32_t i;
 
         MSD_take_cs(msd->spi_device);
 
         result = _send_cmd(msd->spi_device, READ_MULTIPLE_BLOCK, pos, 0x00, response_r1, response);
-        if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
+        if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
         {
             MSD_DEBUG("[err] read READ_MULTIPLE_BLOCK #%d fail!\r\n", pos);
             size = 0;
             goto _exit;
         }
 
-        for(i=0; i<size; i++)
+        for (i = 0; i < size; i++)
         {
             result = _read_block(msd->spi_device,
                                  (uint8_t *)buffer + msd->geometry.bytes_per_sector * i,
                                  msd->geometry.bytes_per_sector);
-            if(result != RT_EOK)
+            if (result != RT_EOK)
             {
                 MSD_DEBUG("[err] read READ_MULTIPLE_BLOCK #%d fail!\r\n", pos);
                 size = i;
@@ -1363,7 +1363,7 @@ static rt_size_t rt_msd_sdhc_read(rt_device_t dev, rt_off_t pos, void* buffer, r
 
         /* send CMD12 stop transfer */
         result = _send_cmd(msd->spi_device, STOP_TRANSMISSION, 0x00, 0x00, response_r1b, response);
-        if(result != RT_EOK)
+        if (result != RT_EOK)
         {
             MSD_DEBUG("[err] read READ_MULTIPLE_BLOCK, send stop token fail!\r\n");
         }
@@ -1377,9 +1377,9 @@ _exit:
     return size;
 }
 
-static rt_size_t rt_msd_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size)
+static rt_size_t rt_msd_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
 {
-    struct msd_device * msd = (struct msd_device *)dev;
+    struct msd_device *msd = (struct msd_device *)dev;
     uint8_t response[MSD_RESPONSE_MAX_LEN];
     rt_err_t result;
 
@@ -1402,11 +1402,11 @@ static rt_size_t rt_msd_write (rt_device_t dev, rt_off_t pos, const void* buffer
     } /* config spi */
 
     /* SINGLE_BLOCK? */
-    if(size == 1)
+    if (size == 1)
     {
         MSD_take_cs(msd->spi_device);
         result = _send_cmd(msd->spi_device, WRITE_BLOCK, pos * msd->geometry.bytes_per_sector, 0x00, response_r1, response);
-        if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
+        if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
         {
             MSD_DEBUG("[err] CMD WRITE_BLOCK fail!\r\n");
             size = 0;
@@ -1414,13 +1414,13 @@ static rt_size_t rt_msd_write (rt_device_t dev, rt_off_t pos, const void* buffer
         }
 
         result = _write_block(msd->spi_device, buffer, msd->geometry.bytes_per_sector, MSD_TOKEN_WRITE_SINGLE_START);
-        if(result != RT_EOK)
+        if (result != RT_EOK)
         {
             MSD_DEBUG("[err] write SINGLE_BLOCK #%d fail!\r\n", pos);
             size = 0;
         }
     }
-    else if(size > 1)
+    else if (size > 1)
     {
         struct rt_spi_message message;
         uint32_t i;
@@ -1428,11 +1428,11 @@ static rt_size_t rt_msd_write (rt_device_t dev, rt_off_t pos, const void* buffer
         MSD_take_cs(msd->spi_device);
 
 #ifdef MSD_USE_PRE_ERASED
-        if(msd->card_type != MSD_CARD_TYPE_MMC)
+        if (msd->card_type != MSD_CARD_TYPE_MMC)
         {
             /* CMD55 APP_CMD */
             result = _send_cmd(msd->spi_device, APP_CMD, 0x00, 0x00, response_r1, response);
-            if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
+            if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
             {
                 MSD_DEBUG("[err] CMD55 APP_CMD fail!\r\n");
                 size = 0;
@@ -1441,7 +1441,7 @@ static rt_size_t rt_msd_write (rt_device_t dev, rt_off_t pos, const void* buffer
 
             /* ACMD23 Pre-erased */
             result = _send_cmd(msd->spi_device, SET_WR_BLK_ERASE_COUNT, size, 0x00, response_r1, response);
-            if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
+            if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
             {
                 MSD_DEBUG("[err] ACMD23 SET_BLOCK_COUNT fail!\r\n");
                 size = 0;
@@ -1451,7 +1451,7 @@ static rt_size_t rt_msd_write (rt_device_t dev, rt_off_t pos, const void* buffer
 #endif
 
         result = _send_cmd(msd->spi_device, WRITE_MULTIPLE_BLOCK, pos * msd->geometry.bytes_per_sector, 0x00, response_r1, response);
-        if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
+        if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
         {
             MSD_DEBUG("[err] CMD WRITE_MULTIPLE_BLOCK fail!\r\n");
             size = 0;
@@ -1459,13 +1459,13 @@ static rt_size_t rt_msd_write (rt_device_t dev, rt_off_t pos, const void* buffer
         }
 
         /* write all block */
-        for(i=0; i<size; i++)
+        for (i = 0; i < size; i++)
         {
             result = _write_block(msd->spi_device,
                                   (const uint8_t *)buffer + msd->geometry.bytes_per_sector * i,
                                   msd->geometry.bytes_per_sector,
                                   MSD_TOKEN_WRITE_MULTIPLE_START);
-            if(result != RT_EOK)
+            if (result != RT_EOK)
             {
                 MSD_DEBUG("[err] write SINGLE_BLOCK #%d fail!\r\n", pos);
                 size = i;
@@ -1492,7 +1492,7 @@ static rt_size_t rt_msd_write (rt_device_t dev, rt_off_t pos, const void* buffer
 
         /* wait ready */
         result = _wait_ready(msd->spi_device);
-        if(result != RT_EOK)
+        if (result != RT_EOK)
         {
             MSD_DEBUG("[warning] wait WRITE_MULTIPLE_BLOCK stop token ready timeout!\r\n");
         }
@@ -1506,9 +1506,9 @@ _exit:
     return size;
 }
 
-static rt_size_t rt_msd_sdhc_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size)
+static rt_size_t rt_msd_sdhc_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
 {
-    struct msd_device * msd = (struct msd_device *)dev;
+    struct msd_device *msd = (struct msd_device *)dev;
     uint8_t response[MSD_RESPONSE_MAX_LEN];
     rt_err_t result;
 
@@ -1530,11 +1530,11 @@ static rt_size_t rt_msd_sdhc_write (rt_device_t dev, rt_off_t pos, const void* b
     } /* config spi */
 
     /* SINGLE_BLOCK? */
-    if(size == 1)
+    if (size == 1)
     {
         MSD_take_cs(msd->spi_device);
         result = _send_cmd(msd->spi_device, WRITE_BLOCK, pos, 0x00, response_r1, response);
-        if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
+        if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
         {
             MSD_DEBUG("[err] CMD WRITE_BLOCK fail!\r\n");
             size = 0;
@@ -1542,13 +1542,13 @@ static rt_size_t rt_msd_sdhc_write (rt_device_t dev, rt_off_t pos, const void* b
         }
 
         result = _write_block(msd->spi_device, buffer, msd->geometry.bytes_per_sector, MSD_TOKEN_WRITE_SINGLE_START);
-        if(result != RT_EOK)
+        if (result != RT_EOK)
         {
             MSD_DEBUG("[err] write SINGLE_BLOCK #%d fail!\r\n", pos);
             size = 0;
         }
     }
-    else if(size > 1)
+    else if (size > 1)
     {
         struct rt_spi_message message;
         uint32_t i;
@@ -1558,7 +1558,7 @@ static rt_size_t rt_msd_sdhc_write (rt_device_t dev, rt_off_t pos, const void* b
 #ifdef MSD_USE_PRE_ERASED
         /* CMD55 APP_CMD */
         result = _send_cmd(msd->spi_device, APP_CMD, 0x00, 0x00, response_r1, response);
-        if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
+        if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
         {
             MSD_DEBUG("[err] CMD55 APP_CMD fail!\r\n");
             size = 0;
@@ -1567,7 +1567,7 @@ static rt_size_t rt_msd_sdhc_write (rt_device_t dev, rt_off_t pos, const void* b
 
         /* ACMD23 Pre-erased */
         result = _send_cmd(msd->spi_device, SET_WR_BLK_ERASE_COUNT, size, 0x00, response_r1, response);
-        if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
+        if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
         {
             MSD_DEBUG("[err] ACMD23 SET_BLOCK_COUNT fail!\r\n");
             size = 0;
@@ -1576,7 +1576,7 @@ static rt_size_t rt_msd_sdhc_write (rt_device_t dev, rt_off_t pos, const void* b
 #endif
 
         result = _send_cmd(msd->spi_device, WRITE_MULTIPLE_BLOCK, pos, 0x00, response_r1, response);
-        if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
+        if ((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR))
         {
             MSD_DEBUG("[err] CMD WRITE_MULTIPLE_BLOCK fail!\r\n");
             size = 0;
@@ -1584,13 +1584,13 @@ static rt_size_t rt_msd_sdhc_write (rt_device_t dev, rt_off_t pos, const void* b
         }
 
         /* write all block */
-        for(i=0; i<size; i++)
+        for (i = 0; i < size; i++)
         {
             result = _write_block(msd->spi_device,
                                   (const uint8_t *)buffer + msd->geometry.bytes_per_sector * i,
                                   msd->geometry.bytes_per_sector,
                                   MSD_TOKEN_WRITE_MULTIPLE_START);
-            if(result != RT_EOK)
+            if (result != RT_EOK)
             {
                 MSD_DEBUG("[err] write MULTIPLE_BLOCK #%d fail!\r\n", pos);
                 size = i;
@@ -1616,7 +1616,7 @@ static rt_size_t rt_msd_sdhc_write (rt_device_t dev, rt_off_t pos, const void* b
         }
 
         result = _wait_ready(msd->spi_device);
-        if(result != RT_EOK)
+        if (result != RT_EOK)
         {
             MSD_DEBUG("[warning] wait WRITE_MULTIPLE_BLOCK stop token ready timeout!\r\n");
         }
@@ -1632,7 +1632,7 @@ _exit:
 
 static rt_err_t rt_msd_control(rt_device_t dev, int cmd, void *args)
 {
-    struct msd_device * msd = (struct msd_device *)dev;
+    struct msd_device *msd = (struct msd_device *)dev;
 
     RT_ASSERT(dev != RT_NULL);
 
@@ -1651,13 +1651,13 @@ static rt_err_t rt_msd_control(rt_device_t dev, int cmd, void *args)
     return RT_EOK;
 }
 
-rt_err_t msd_init(const char * sd_device_name, const char * spi_device_name)
+rt_err_t msd_init(const char *sd_device_name, const char *spi_device_name)
 {
     rt_err_t result = RT_EOK;
-    struct rt_spi_device * spi_device;
+    struct rt_spi_device *spi_device;
 
     spi_device = (struct rt_spi_device *)rt_device_find(spi_device_name);
-    if(spi_device == RT_NULL)
+    if (spi_device == RT_NULL)
     {
         MSD_DEBUG("spi device %s not found!\r\n", spi_device_name);
         return -RT_ENOSYS;