Merge pull request #4737 from mysterywolf/3,1,xformatv3.1.5

[lts 3.1.x] format codes

5 files changed, 241 insertions, 241 deletions

diff --git a/components/drivers/sdio/block_dev.c b/components/drivers/sdio/block_dev.c
index 602acb9aa7..f2ce09a83f 100644
--- a/components/drivers/sdio/block_dev.c
+++ b/components/drivers/sdio/block_dev.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -76,7 +76,7 @@ rt_int32_t mmcsd_num_wr_blocks(struct rt_mmcsd_card *card)
     timeout_us += data.timeout_clks * 1000 /
         (card->host->io_cfg.clock / 1000);
 
-    if (timeout_us > 100000) 
+    if (timeout_us > 100000)
     {
         data.timeout_ns = 100000000;
         data.timeout_clks = 0;
@@ -119,9 +119,9 @@ static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card,
     rt_memset(&data, 0, sizeof(struct rt_mmcsd_data));
     req.cmd = &cmd;
     req.data = &data;
-    
+
     cmd.arg = sector;
-    if (!(card->flags & CARD_FLAG_SDHC)) 
+    if (!(card->flags & CARD_FLAG_SDHC))
     {
         cmd.arg <<= 9;
     }
@@ -130,7 +130,7 @@ static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card,
     data.blksize = SECTOR_SIZE;
     data.blks  = blks;
 
-    if (blks > 1) 
+    if (blks > 1)
     {
         if (!controller_is_spi(card->host) || !dir)
         {
@@ -149,7 +149,7 @@ static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card,
         w_cmd = WRITE_BLOCK;
     }
 
-    if (!dir) 
+    if (!dir)
     {
         cmd.cmd_code = r_cmd;
         data.flags |= DATA_DIR_READ;
@@ -164,9 +164,9 @@ static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card,
     data.buf = buf;
     mmcsd_send_request(host, &req);
 
-    if (!controller_is_spi(card->host) && dir != 0) 
+    if (!controller_is_spi(card->host) && dir != 0)
     {
-        do 
+        do
         {
             rt_int32_t err;
 
@@ -174,7 +174,7 @@ static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card,
             cmd.arg = card->rca << 16;
             cmd.flags = RESP_R1 | CMD_AC;
             err = mmcsd_send_cmd(card->host, &cmd, 5);
-            if (err) 
+            if (err)
             {
                 LOG_E("error %d requesting status", err);
                 break;
@@ -190,7 +190,7 @@ static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card,
 
     mmcsd_host_unlock(host);
 
-    if (cmd.err || data.err || stop.err) 
+    if (cmd.err || data.err || stop.err)
     {
         LOG_E("mmcsd request blocks error");
         LOG_E("%d,%d,%d, 0x%08x,0x%08x",
@@ -264,7 +264,7 @@ static rt_size_t rt_mmcsd_read(rt_device_t dev,
     rt_sem_release(part->lock);
 
     /* the length of reading must align to SECTOR SIZE */
-    if (err) 
+    if (err)
     {
         rt_set_errno(-EIO);
         return 0;
@@ -305,7 +305,7 @@ static rt_size_t rt_mmcsd_write(rt_device_t dev,
     rt_sem_release(part->lock);
 
     /* the length of reading must align to SECTOR SIZE */
-    if (err) 
+    if (err)
     {
         rt_set_errno(-EIO);
 
@@ -330,7 +330,7 @@ static rt_int32_t mmcsd_set_blksize(struct rt_mmcsd_card *card)
     err = mmcsd_send_cmd(card->host, &cmd, 5);
     mmcsd_host_unlock(card->host);
 
-    if (err) 
+    if (err)
     {
         LOG_E("MMCSD: unable to set block size to %d: %d", cmd.arg, err);
 
@@ -341,7 +341,7 @@ static rt_int32_t mmcsd_set_blksize(struct rt_mmcsd_card *card)
 }
 
 #ifdef RT_USING_DEVICE_OPS
-const static struct rt_device_ops mmcsd_blk_ops = 
+const static struct rt_device_ops mmcsd_blk_ops =
 {
     rt_mmcsd_init,
     rt_mmcsd_open,
@@ -362,7 +362,7 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
     struct mmcsd_blk_device *blk_dev = RT_NULL;
 
     err = mmcsd_set_blksize(card);
-    if(err) 
+    if(err)
     {
         return err;
     }
@@ -384,15 +384,15 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
         for (i = 0; i < RT_MMCSD_MAX_PARTITION; i++)
         {
             blk_dev = rt_calloc(1, sizeof(struct mmcsd_blk_device));
-            if (!blk_dev) 
+            if (!blk_dev)
             {
                 LOG_E("mmcsd:malloc memory failed!");
                 break;
             }
 
-            blk_dev->max_req_size = BLK_MIN((card->host->max_dma_segs * 
-                                             card->host->max_seg_size) >> 9, 
-                                            (card->host->max_blk_count * 
+            blk_dev->max_req_size = BLK_MIN((card->host->max_dma_segs *
+                                             card->host->max_seg_size) >> 9,
+                                            (card->host->max_blk_count *
                                              card->host->max_blk_size) >> 9);
 
             /* get the first partition */
@@ -402,7 +402,7 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
                 rt_snprintf(dname, 4, "sd%d",  i);
                 rt_snprintf(sname, 8, "sem_sd%d",  i);
                 blk_dev->part.lock = rt_sem_create(sname, 1, RT_IPC_FLAG_FIFO);
-    
+
                 /* register mmcsd device */
                 blk_dev->dev.type = RT_Device_Class_Block;
 #ifdef RT_USING_DEVICE_OPS
@@ -418,11 +418,11 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
                 blk_dev->dev.user_data = blk_dev;
 
                 blk_dev->card = card;
-                
+
                 blk_dev->geometry.bytes_per_sector = 1<<9;
                 blk_dev->geometry.block_size = card->card_blksize;
                 blk_dev->geometry.sector_count = blk_dev->part.size;
-    
+
                 rt_device_register(&blk_dev->dev, dname,
                     RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE);
                 rt_list_insert_after(&blk_devices, &blk_dev->list);
@@ -435,7 +435,7 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
                     blk_dev->part.offset = 0;
                     blk_dev->part.size   = 0;
                     blk_dev->part.lock = rt_sem_create("sem_sd0", 1, RT_IPC_FLAG_FIFO);
-    
+
                     /* register mmcsd device */
                     blk_dev->dev.type  = RT_Device_Class_Block;
 #ifdef RT_USING_DEVICE_OPS
@@ -454,9 +454,9 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
 
                     blk_dev->geometry.bytes_per_sector = 1<<9;
                     blk_dev->geometry.block_size = card->card_blksize;
-                    blk_dev->geometry.sector_count = 
+                    blk_dev->geometry.sector_count =
                         card->card_capacity * (1024 / 512);
-    
+
                     rt_device_register(&blk_dev->dev, "sd0",
                         RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE);
                     rt_list_insert_after(&blk_devices, &blk_dev->list);
@@ -472,9 +472,9 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
 #ifdef RT_USING_DFS_MNTTABLE
             if (blk_dev)
             {
-            	LOG_I("try to mount file system!");
-            	/* try to mount file system on this block device */
-            	dfs_mount_device(&(blk_dev->dev));
+                LOG_I("try to mount file system!");
+                /* try to mount file system on this block device */
+                dfs_mount_device(&(blk_dev->dev));
             }
 #endif
         }
@@ -484,10 +484,10 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
         LOG_E("read mmcsd first sector failed");
         err = -RT_ERROR;
     }
-    
+
     /* release sector buffer */
     rt_free(sector);
-    
+
     return err;
 }
 
@@ -499,15 +499,15 @@ void rt_mmcsd_blk_remove(struct rt_mmcsd_card *card)
     for (l = (&blk_devices)->next, n = l->next; l != &blk_devices; l = n)
     {
         blk_dev = (struct mmcsd_blk_device *)rt_list_entry(l, struct mmcsd_blk_device, list);
-        if (blk_dev->card == card) 
+        if (blk_dev->card == card)
         {
-        	/* unmount file system */
-        	const char * mounted_path = dfs_filesystem_get_mounted_path(&(blk_dev->dev));
-        	if (mounted_path)
-        	{
+            /* unmount file system */
+            const char * mounted_path = dfs_filesystem_get_mounted_path(&(blk_dev->dev));
+            if (mounted_path)
+            {
                   dfs_unmount(mounted_path);
                   LOG_D("unmount file system %s for device %s.\r\n", mounted_path, blk_dev->dev.parent.name);
-        	}
+            }
             rt_sem_delete(blk_dev->part.lock);
             rt_device_unregister(&blk_dev->dev);
             rt_list_remove(&blk_dev->list);
diff --git a/components/drivers/sdio/mmc.c b/components/drivers/sdio/mmc.c
index c1c56d37fd..5aba3dba7a 100644
--- a/components/drivers/sdio/mmc.c
+++ b/components/drivers/sdio/mmc.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -45,9 +45,9 @@ static const rt_uint8_t tacc_value[] =
 rt_inline rt_uint32_t GET_BITS(rt_uint32_t *resp,
                                rt_uint32_t  start,
                                rt_uint32_t  size)
-{                               
+{
         const rt_int32_t __size = size;
-        const rt_uint32_t __mask = (__size < 32 ? 1 << __size : 0) - 1; 
+        const rt_uint32_t __mask = (__size < 32 ? 1 << __size : 0) - 1;
         const rt_int32_t __off = 3 - ((start) / 32);
         const rt_int32_t __shft = (start) & 31;
         rt_uint32_t __res;
@@ -67,7 +67,7 @@ static rt_int32_t mmcsd_parse_csd(struct rt_mmcsd_card *card)
       rt_uint32_t a, b;
       struct rt_mmcsd_csd *csd = &card->csd;
       rt_uint32_t *resp = card->resp_csd;
-      
+
       /*
       * We only understand CSD structure v1.1 and v1.2.
       * v1.2 has extra information in bits 15, 11 and 10.
@@ -76,10 +76,10 @@ static rt_int32_t mmcsd_parse_csd(struct rt_mmcsd_card *card)
       csd->csd_structure = GET_BITS(resp, 126, 2);
       if (csd->csd_structure == 0) {
         LOG_E("unrecognised CSD structure version %d!", csd->csd_structure);
-        
+
         return -RT_ERROR;
       }
-      
+
       csd->taac = GET_BITS(resp, 112, 8);
       csd->nsac = GET_BITS(resp, 104, 8);
       csd->tran_speed = GET_BITS(resp, 96, 8);
@@ -95,7 +95,7 @@ static rt_int32_t mmcsd_parse_csd(struct rt_mmcsd_card *card)
       csd->wr_blk_len = GET_BITS(resp, 22, 4);
       csd->wr_blk_partial = GET_BITS(resp, 21, 1);
       csd->csd_crc = GET_BITS(resp, 1, 7);
-      
+
       card->card_blksize = 1 << csd->rd_blk_len;
       card->tacc_clks = csd->nsac * 100;
       card->tacc_ns = (tacc_uint[csd->taac&0x07] * tacc_value[(csd->taac&0x78)>>3] + 9) / 10;
@@ -106,7 +106,7 @@ static rt_int32_t mmcsd_parse_csd(struct rt_mmcsd_card *card)
         card->erase_size = (a + 1) * (b + 1);
         card->erase_size <<= csd->wr_blk_len - 9;
       }
-      
+
       return 0;
 }
 
@@ -119,12 +119,12 @@ static int mmc_get_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t **new_ext_csd)
   struct rt_mmcsd_req req;
   struct rt_mmcsd_cmd cmd;
   struct rt_mmcsd_data data;
-  
+
   *new_ext_csd = RT_NULL;
-  
+
   if (GET_BITS(card->resp_cid, 122, 4) < 4)
      return 0;
-  
+
   /*
   * As the ext_csd is so large and mostly unused, we don't store the
   * raw block in mmc_card.
@@ -134,29 +134,29 @@ static int mmc_get_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t **new_ext_csd)
     LOG_E("alloc memory failed when get ext csd!");
     return -RT_ENOMEM;
   }
-  
+
   rt_memset(&req, 0, sizeof(struct rt_mmcsd_req));
   rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
   rt_memset(&data, 0, sizeof(struct rt_mmcsd_data));
-  
+
   req.cmd = &cmd;
   req.data = &data;
-  
+
   cmd.cmd_code = SEND_EXT_CSD;
   cmd.arg = 0;
-  
+
   /* NOTE HACK:  the RESP_SPI_R1 is always correct here, but we
   * rely on callers to never use this with "native" calls for reading
   * CSD or CID.  Native versions of those commands use the R2 type,
   * not R1 plus a data block.
   */
   cmd.flags = RESP_SPI_R1 | RESP_R1 | CMD_ADTC;
-  
+
   data.blksize = 512;
   data.blks = 1;
   data.flags = DATA_DIR_READ;
   data.buf = ext_csd;
-  
+
   /*
   * Some cards require longer data read timeout than indicated in CSD.
   * Address this by setting the read timeout to a "reasonably high"
@@ -165,14 +165,14 @@ static int mmc_get_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t **new_ext_csd)
   */
   data.timeout_ns = 300000000;
   data.timeout_clks = 0;
-  
+
   mmcsd_send_request(card->host, &req);
-  
+
   if (cmd.err)
     return cmd.err;
   if (data.err)
     return data.err;
-  
+
   *new_ext_csd = ext_csd;
   return 0;
 }
@@ -192,13 +192,13 @@ static int mmc_parse_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
 
   card->flags |=  CARD_FLAG_HIGHSPEED;
   card->hs_max_data_rate = 52000000;
-  
+
   card_capacity = *((rt_uint32_t *)&ext_csd[EXT_CSD_SEC_CNT]);
   card_capacity *= card->card_blksize;
   card_capacity >>= 10; /* unit:KB */
   card->card_capacity = card_capacity;
   LOG_I("emmc card capacity %d KB.", card->card_capacity);
-  
+
   return 0;
 }
 
@@ -211,41 +211,41 @@ static int mmc_parse_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
  *
  *   Modifies the EXT_CSD register for selected card.
  */
-static int mmc_switch(struct rt_mmcsd_card *card, rt_uint8_t set, 
+static int mmc_switch(struct rt_mmcsd_card *card, rt_uint8_t set,
                       rt_uint8_t index, rt_uint8_t value)
 {
   int err;
   struct rt_mmcsd_host *host = card->host;
   struct rt_mmcsd_cmd cmd = {0};
-  
+
   cmd.cmd_code = SWITCH;
   cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
     (index << 16) | (value << 8) | set;
   cmd.flags = RESP_SPI_R1 | RESP_R1 | CMD_AC;
-  
+
   err = mmcsd_send_cmd(host, &cmd, 3);
   if (err)
     return err;
-  
+
   return 0;
 }
 
-static int mmc_compare_ext_csds(struct rt_mmcsd_card *card, 
+static int mmc_compare_ext_csds(struct rt_mmcsd_card *card,
                                 rt_uint8_t *ext_csd, rt_uint32_t bus_width)
 {
   rt_uint8_t *bw_ext_csd;
   int err;
-  
+
   if (bus_width == MMCSD_BUS_WIDTH_1)
     return 0;
-  
+
   err = mmc_get_ext_csd(card, &bw_ext_csd);
-  
+
   if (err || bw_ext_csd == RT_NULL) {
     err = -RT_ERROR;
     goto out;
   }
-  
+
   /* only compare read only fields */
   err = !((ext_csd[EXT_CSD_PARTITION_SUPPORT] == bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) &&
           (ext_csd[EXT_CSD_ERASED_MEM_CONT] == bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) &&
@@ -273,10 +273,10 @@ static int mmc_compare_ext_csds(struct rt_mmcsd_card *card,
           (ext_csd[EXT_CSD_PWR_CL_DDR_52_195] == bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_195]) &&
           (ext_csd[EXT_CSD_PWR_CL_DDR_52_360] == bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_360]) &&
           (ext_csd[EXT_CSD_PWR_CL_DDR_200_360] == bw_ext_csd[EXT_CSD_PWR_CL_DDR_200_360]));
-  
+
   if (err)
      err = -RT_ERROR;
-  
+
 out:
   rt_free(bw_ext_csd);
   return err;
@@ -302,10 +302,10 @@ static int mmc_select_bus_width(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
   struct rt_mmcsd_host *host = card->host;
   unsigned idx, bus_width = 0;
   int err = 0;
-  
+
   if (GET_BITS(card->resp_cid, 122, 4) < 4)
      return 0;
-  
+
   /*
   * Unlike SD, MMC cards dont have a configuration register to notify
   * supported bus width. So bus test command should be run to identify
@@ -323,18 +323,18 @@ static int mmc_select_bus_width(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
     * set by drivers.
     */
      if ((!(host->flags & MMCSD_BUSWIDTH_8) &&
-	  ext_csd_bits[idx] == EXT_CSD_BUS_WIDTH_8) ||
+      ext_csd_bits[idx] == EXT_CSD_BUS_WIDTH_8) ||
          (!(host->flags & MMCSD_BUSWIDTH_4) &&
-	  (ext_csd_bits[idx] == EXT_CSD_BUS_WIDTH_4 ||
-	  ext_csd_bits[idx] == EXT_CSD_BUS_WIDTH_8)))
-	     continue;
+      (ext_csd_bits[idx] == EXT_CSD_BUS_WIDTH_4 ||
+      ext_csd_bits[idx] == EXT_CSD_BUS_WIDTH_8)))
+         continue;
 
     err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                      EXT_CSD_BUS_WIDTH,
                      ext_csd_bits[idx]);
     if (err)
       continue;
-    
+
     bus_width = bus_widths[idx];
     mmcsd_set_bus_width(host, bus_width);
     mmcsd_delay_ms(20); //delay 10ms
@@ -358,10 +358,10 @@ static int mmc_select_bus_width(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
       }
     }
   }
-  
+
   return err;
 }
-rt_err_t mmc_send_op_cond(struct rt_mmcsd_host *host, 
+rt_err_t mmc_send_op_cond(struct rt_mmcsd_host *host,
                           rt_uint32_t ocr, rt_uint32_t *rocr)
 {
     struct rt_mmcsd_cmd cmd;
@@ -369,20 +369,20 @@ rt_err_t mmc_send_op_cond(struct rt_mmcsd_host *host,
     rt_err_t err = RT_EOK;
 
     rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
-    
+
     cmd.cmd_code = SEND_OP_COND;
     cmd.arg = controller_is_spi(host) ? 0 : ocr;
     cmd.flags = RESP_SPI_R1 | RESP_R3 | CMD_BCR;
-  
+
     for (i = 100; i; i--) {
       err = mmcsd_send_cmd(host, &cmd, 3);
       if (err)
         break;
-      
+
       /* if we're just probing, do a single pass */
       if (ocr == 0)
         break;
-      
+
       /* otherwise wait until reset completes */
       if (controller_is_spi(host)) {
         if (!(cmd.resp[0] & R1_SPI_IDLE))
@@ -391,15 +391,15 @@ rt_err_t mmc_send_op_cond(struct rt_mmcsd_host *host,
         if (cmd.resp[0] & CARD_BUSY)
           break;
       }
-      
+
       err = -RT_ETIMEOUT;
-      
+
       mmcsd_delay_ms(10); //delay 10ms
     }
-  
+
   if (rocr && !controller_is_spi(host))
     *rocr = cmd.resp[0];
-  
+
   return err;
 }
 
@@ -407,17 +407,17 @@ static rt_err_t mmc_set_card_addr(struct rt_mmcsd_host *host, rt_uint32_t rca)
 {
   rt_err_t err;
   struct rt_mmcsd_cmd cmd;
-  
+
   rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
-  
+
   cmd.cmd_code = SET_RELATIVE_ADDR;
   cmd.arg = rca << 16;
   cmd.flags = RESP_R1 | CMD_AC;
-  
+
   err = mmcsd_send_cmd(host, &cmd, 3);
   if (err)
     return err;
-  
+
   return 0;
 }
 
@@ -432,19 +432,19 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
     struct rt_mmcsd_card *card = RT_NULL;
 
     mmcsd_go_idle(host);
-    
+
     /* The extra bit indicates that we support high capacity */
     err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
     if (err)
       goto err;
-    
-    if (controller_is_spi(host)) 
+
+    if (controller_is_spi(host))
     {
         err = mmcsd_spi_use_crc(host, 1);
         if (err)
             goto err1;
     }
-    
+
     if (controller_is_spi(host))
         err = mmcsd_get_cid(host, resp);
     else
@@ -453,7 +453,7 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
         goto err;
 
     card = rt_malloc(sizeof(struct rt_mmcsd_card));
-    if (!card) 
+    if (!card)
     {
         LOG_E("malloc card failed!");
         err = -RT_ENOMEM;
@@ -469,7 +469,7 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
     /*
      * For native busses:  get card RCA and quit open drain mode.
      */
-    if (!controller_is_spi(host)) 
+    if (!controller_is_spi(host))
     {
         err = mmc_set_card_addr(host, card->rca);
         if (err)
@@ -486,24 +486,24 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
     if (err)
         goto err1;
 
-    if (!controller_is_spi(host)) 
+    if (!controller_is_spi(host))
     {
         err = mmcsd_select_card(card);
         if (err)
             goto err1;
     }
-    
+
     /*
     * Fetch and process extended CSD.
     */
-    
+
     err = mmc_get_ext_csd(card, &ext_csd);
     if (err)
       goto err1;
     err = mmc_parse_ext_csd(card, ext_csd);
     if (err)
       goto err1;
-    
+
     /* If doing byte addressing, check if required to do sector
     * addressing.  Handle the case of <2GB cards needing sector
     * addressing.  See section 8.1 JEDEC Standard JED84-A441;
@@ -511,9 +511,9 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
     */
     if (!(card->flags & CARD_FLAG_SDHC) && (rocr & (1<<30)))
         card->flags |= CARD_FLAG_SDHC;
- 
+
     /* set bus speed */
-    if (card->flags & CARD_FLAG_HIGHSPEED) 
+    if (card->flags & CARD_FLAG_HIGHSPEED)
         max_data_rate = card->hs_max_data_rate;
     else
         max_data_rate = card->max_data_rate;
@@ -522,7 +522,7 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
 
     /*switch bus width*/
     mmc_select_bus_width(card, ext_csd);
-    
+
     host->card = card;
 
     rt_free(ext_csd);
diff --git a/components/drivers/sdio/mmcsd_core.c b/components/drivers/sdio/mmcsd_core.c
index 8131a33133..09481d403a 100644
--- a/components/drivers/sdio/mmcsd_core.c
+++ b/components/drivers/sdio/mmcsd_core.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -63,7 +63,7 @@ void mmcsd_send_request(struct rt_mmcsd_host *host, struct rt_mmcsd_req *req)
         req->cmd->err = 0;
         req->cmd->mrq = req;
         if (req->data)
-        {   
+        {
             req->cmd->data = req->data;
             req->data->err = 0;
             req->data->mrq = req;
@@ -72,12 +72,12 @@ void mmcsd_send_request(struct rt_mmcsd_host *host, struct rt_mmcsd_req *req)
                 req->data->stop = req->stop;
                 req->stop->err = 0;
                 req->stop->mrq = req;
-            }       
+            }
         }
         host->ops->request(host, req);
 
         rt_sem_take(&host->sem_ack, RT_WAITING_FOREVER);
-          
+
     } while(req->cmd->err && (req->cmd->retries > 0));
 
 
@@ -122,7 +122,7 @@ rt_int32_t mmcsd_go_idle(struct rt_mmcsd_host *host)
 
     mmcsd_delay_ms(1);
 
-    if (!controller_is_spi(host)) 
+    if (!controller_is_spi(host))
     {
         mmcsd_set_chip_select(host, MMCSD_CS_IGNORE);
         mmcsd_delay_ms(1);
@@ -179,7 +179,7 @@ rt_int32_t mmcsd_get_cid(struct rt_mmcsd_host *host, rt_uint32_t *cid)
     struct rt_mmcsd_data data;
     rt_uint32_t *buf = RT_NULL;
 
-    if (!controller_is_spi(host)) 
+    if (!controller_is_spi(host))
     {
         if (!host->card)
             return -RT_ERROR;
@@ -198,7 +198,7 @@ rt_int32_t mmcsd_get_cid(struct rt_mmcsd_host *host, rt_uint32_t *cid)
     }
 
     buf = (rt_uint32_t *)rt_malloc(16);
-    if (!buf) 
+    if (!buf)
     {
         LOG_E("allocate memory failed!");
 
@@ -274,7 +274,7 @@ rt_int32_t mmcsd_get_csd(struct rt_mmcsd_card *card, rt_uint32_t *csd)
     }
 
     buf = (rt_uint32_t*)rt_malloc(16);
-    if (!buf) 
+    if (!buf)
     {
         LOG_E("allocate memory failed!");
 
@@ -336,12 +336,12 @@ static rt_int32_t _mmcsd_select_card(struct rt_mmcsd_host *host,
 
     cmd.cmd_code = SELECT_CARD;
 
-    if (card) 
+    if (card)
     {
         cmd.arg = card->rca << 16;
         cmd.flags = RESP_R1 | CMD_AC;
-    } 
-    else 
+    }
+    else
     {
         cmd.arg = 0;
         cmd.flags = RESP_NONE | CMD_AC;
@@ -442,7 +442,7 @@ void mmcsd_set_data_timeout(struct rt_mmcsd_data       *data,
 {
     rt_uint32_t mult;
 
-    if (card->card_type == CARD_TYPE_SDIO) 
+    if (card->card_type == CARD_TYPE_SDIO)
     {
         data->timeout_ns = 1000000000;  /* SDIO card 1s */
         data->timeout_clks = 0;
@@ -468,7 +468,7 @@ void mmcsd_set_data_timeout(struct rt_mmcsd_data       *data,
     /*
      * SD cards also have an upper limit on the timeout.
      */
-    if (card->card_type == CARD_TYPE_SD) 
+    if (card->card_type == CARD_TYPE_SD)
     {
         rt_uint32_t timeout_us, limit_us;
 
@@ -488,21 +488,21 @@ void mmcsd_set_data_timeout(struct rt_mmcsd_data       *data,
         /*
          * SDHC cards always use these fixed values.
          */
-        if (timeout_us > limit_us || card->flags & CARD_FLAG_SDHC) 
+        if (timeout_us > limit_us || card->flags & CARD_FLAG_SDHC)
         {
             data->timeout_ns = limit_us * 1000; /* SDHC card fixed 250ms */
             data->timeout_clks = 0;
         }
     }
 
-    if (controller_is_spi(card->host)) 
+    if (controller_is_spi(card->host))
     {
-        if (data->flags & DATA_DIR_WRITE) 
+        if (data->flags & DATA_DIR_WRITE)
         {
             if (data->timeout_ns < 1000000000)
                 data->timeout_ns = 1000000000;  /* 1s */
-        } 
-        else 
+        }
+        else
         {
             if (data->timeout_ns < 100000000)
                 data->timeout_ns =  100000000;  /* 100ms */
@@ -522,7 +522,7 @@ rt_uint32_t mmcsd_select_voltage(struct rt_mmcsd_host *host, rt_uint32_t ocr)
     ocr &= host->valid_ocr;
 
     bit = __rt_ffs(ocr);
-    if (bit) 
+    if (bit)
     {
         bit -= 1;
 
@@ -530,8 +530,8 @@ rt_uint32_t mmcsd_select_voltage(struct rt_mmcsd_host *host, rt_uint32_t ocr)
 
         host->io_cfg.vdd = bit;
         mmcsd_set_iocfg(host);
-    } 
-    else 
+    }
+    else
     {
         LOG_W("host doesn't support card's voltages!");
         ocr = 0;
@@ -549,7 +549,7 @@ static void mmcsd_power_up(struct rt_mmcsd_host *host)
     {
         host->io_cfg.chip_select = MMCSD_CS_HIGH;
         host->io_cfg.bus_mode = MMCSD_BUSMODE_PUSHPULL;
-    } 
+    }
     else
     {
         host->io_cfg.chip_select = MMCSD_CS_IGNORE;
@@ -580,7 +580,7 @@ static void mmcsd_power_off(struct rt_mmcsd_host *host)
 {
     host->io_cfg.clock = 0;
     host->io_cfg.vdd = 0;
-    if (!controller_is_spi(host)) 
+    if (!controller_is_spi(host))
     {
         host->io_cfg.bus_mode = MMCSD_BUSMODE_OPENDRAIN;
         host->io_cfg.chip_select = MMCSD_CS_IGNORE;
@@ -619,7 +619,7 @@ void mmcsd_detect(void *param)
     rt_uint32_t  ocr;
     rt_int32_t  err;
 
-    while (1) 
+    while (1)
     {
         if (rt_mb_recv(&mmcsd_detect_mb, (rt_ubase_t *)&host, RT_WAITING_FOREVER) == RT_EOK)
         {
@@ -644,7 +644,7 @@ void mmcsd_detect(void *param)
                  * detect SD card
                  */
                 err = mmcsd_send_app_op_cond(host, 0, &ocr);
-                if (!err) 
+                if (!err)
                 {
                     if (init_sd(host, ocr))
                         mmcsd_power_off(host);
@@ -652,12 +652,12 @@ void mmcsd_detect(void *param)
                     rt_mb_send(&mmcsd_hotpluge_mb, (rt_uint32_t)host);
                     continue;
                 }
-                
+
                 /*
                  * detect mmc card
                  */
                 err = mmc_send_op_cond(host, 0, &ocr);
-                if (!err) 
+                if (!err)
                 {
                     if (init_mmc(host, ocr))
                         mmcsd_power_off(host);
@@ -669,21 +669,21 @@ void mmcsd_detect(void *param)
             }
             else
             {
-            	/* card removed */
-            	mmcsd_host_lock(host);
-            	if (host->card->sdio_function_num != 0)
-            	{
-            		LOG_W("unsupport sdio card plug out!");
-            	}
-            	else
-            	{
-            		rt_mmcsd_blk_remove(host->card);
-            		rt_free(host->card);
+                /* card removed */
+                mmcsd_host_lock(host);
+                if (host->card->sdio_function_num != 0)
+                {
+                    LOG_W("unsupport sdio card plug out!");
+                }
+                else
+                {
+                    rt_mmcsd_blk_remove(host->card);
+                    rt_free(host->card);
 
-            		host->card = RT_NULL;
-            	}
-            	mmcsd_host_unlock(host);
-            	rt_mb_send(&mmcsd_hotpluge_mb, (rt_uint32_t)host);
+                    host->card = RT_NULL;
+                }
+                mmcsd_host_unlock(host);
+                rt_mb_send(&mmcsd_hotpluge_mb, (rt_uint32_t)host);
             }
         }
     }
@@ -694,7 +694,7 @@ struct rt_mmcsd_host *mmcsd_alloc_host(void)
     struct rt_mmcsd_host *host;
 
     host = rt_malloc(sizeof(struct rt_mmcsd_host));
-    if (!host) 
+    if (!host)
     {
         LOG_E("alloc host failed");
 
@@ -736,16 +736,16 @@ int rt_mmcsd_core_init(void)
         &mmcsd_hotpluge_mb_pool[0], sizeof(mmcsd_hotpluge_mb_pool) / sizeof(mmcsd_hotpluge_mb_pool[0]),
         RT_IPC_FLAG_FIFO);
     RT_ASSERT(ret == RT_EOK);
-     ret = rt_thread_init(&mmcsd_detect_thread, "mmcsd_detect", mmcsd_detect, RT_NULL, 
+     ret = rt_thread_init(&mmcsd_detect_thread, "mmcsd_detect", mmcsd_detect, RT_NULL,
                  &mmcsd_stack[0], RT_MMCSD_STACK_SIZE, RT_MMCSD_THREAD_PREORITY, 20);
-    if (ret == RT_EOK) 
+    if (ret == RT_EOK)
     {
         rt_thread_startup(&mmcsd_detect_thread);
     }
 
     rt_sdio_init();
 
-	return 0;
+    return 0;
 }
 INIT_PREV_EXPORT(rt_mmcsd_core_init);
 
diff --git a/components/drivers/sdio/sd.c b/components/drivers/sdio/sd.c
index f7e4e46720..d739ee4eaf 100644
--- a/components/drivers/sdio/sd.c
+++ b/components/drivers/sdio/sd.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -45,9 +45,9 @@ static const rt_uint8_t tacc_value[] =
 rt_inline rt_uint32_t GET_BITS(rt_uint32_t *resp,
                                rt_uint32_t  start,
                                rt_uint32_t  size)
-{                               
+{
         const rt_int32_t __size = size;
-        const rt_uint32_t __mask = (__size < 32 ? 1 << __size : 0) - 1; 
+        const rt_uint32_t __mask = (__size < 32 ? 1 << __size : 0) - 1;
         const rt_int32_t __off = 3 - ((start) / 32);
         const rt_int32_t __shft = (start) & 31;
         rt_uint32_t __res;
@@ -97,7 +97,7 @@ static rt_int32_t mmcsd_parse_csd(struct rt_mmcsd_card *card)
     case 1:
         card->flags |= CARD_FLAG_SDHC;
 
-        /*This field is fixed to 0Eh, which indicates 1 ms. 
+        /*This field is fixed to 0Eh, which indicates 1 ms.
           The host should not use TAAC, NSAC, and R2W_FACTOR
           to calculate timeout and should uses fixed timeout
           values for read and write operations*/
@@ -157,13 +157,13 @@ static rt_int32_t mmcsd_switch(struct rt_mmcsd_card *card)
     rt_uint8_t *buf;
 
     buf = (rt_uint8_t*)rt_malloc(64);
-    if (!buf) 
+    if (!buf)
     {
         LOG_E("alloc memory failed!");
 
         return -RT_ENOMEM;
     }
-    
+
     if (card->card_type != CARD_TYPE_SD)
         goto err;
     if (card->scr.sd_version < SCR_SPEC_VER_1)
@@ -191,7 +191,7 @@ static rt_int32_t mmcsd_switch(struct rt_mmcsd_card *card)
 
     mmcsd_send_request(host, &req);
 
-    if (cmd.err || data.err) 
+    if (cmd.err || data.err)
     {
         goto err1;
     }
@@ -221,12 +221,12 @@ static rt_int32_t mmcsd_switch(struct rt_mmcsd_card *card)
 
     mmcsd_send_request(host, &req);
 
-    if (cmd.err || data.err) 
+    if (cmd.err || data.err)
     {
         goto err1;
     }
 
-    if ((buf[16] & 0xF) != 1) 
+    if ((buf[16] & 0xF) != 1)
     {
         LOG_I("switching card to high speed failed!");
         goto err;
@@ -255,12 +255,12 @@ static rt_err_t mmcsd_app_cmd(struct rt_mmcsd_host *host,
 
     cmd.cmd_code = APP_CMD;
 
-    if (card) 
+    if (card)
     {
         cmd.arg = card->rca << 16;
         cmd.flags = RESP_R1 | CMD_AC;
-    } 
-    else 
+    }
+    else
     {
         cmd.arg = 0;
         cmd.flags = RESP_R1 | CMD_BCR;
@@ -285,7 +285,7 @@ rt_err_t mmcsd_send_app_cmd(struct rt_mmcsd_host *host,
 {
     struct rt_mmcsd_req req;
 
-    rt_uint32_t i; 
+    rt_uint32_t i;
     rt_err_t err;
 
     err = -RT_ERROR;
@@ -294,15 +294,15 @@ rt_err_t mmcsd_send_app_cmd(struct rt_mmcsd_host *host,
      * We have to resend MMC_APP_CMD for each attempt so
      * we cannot use the retries field in mmc_command.
      */
-    for (i = 0;i <= retry;i++) 
+    for (i = 0;i <= retry;i++)
     {
         rt_memset(&req, 0, sizeof(struct rt_mmcsd_req));
 
         err = mmcsd_app_cmd(host, card);
-        if (err) 
+        if (err)
         {
             /* no point in retrying; no APP commands allowed */
-            if (controller_is_spi(host)) 
+            if (controller_is_spi(host))
             {
                 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
                     break;
@@ -324,7 +324,7 @@ rt_err_t mmcsd_send_app_cmd(struct rt_mmcsd_host *host,
             break;
 
         /* no point in retrying illegal APP commands */
-        if (controller_is_spi(host)) 
+        if (controller_is_spi(host))
         {
             if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
                 break;
@@ -344,7 +344,7 @@ rt_err_t mmcsd_app_set_bus_width(struct rt_mmcsd_card *card, rt_int32_t width)
     cmd.cmd_code = SD_APP_SET_BUS_WIDTH;
     cmd.flags = RESP_R1 | CMD_AC;
 
-    switch (width) 
+    switch (width)
     {
     case MMCSD_BUS_WIDTH_1:
         cmd.arg = MMCSD_BUS_WIDTH_1;
@@ -380,7 +380,7 @@ rt_err_t mmcsd_send_app_op_cond(struct rt_mmcsd_host *host,
         cmd.arg = ocr;
     cmd.flags = RESP_SPI_R1 | RESP_R3 | CMD_BCR;
 
-    for (i = 100; i; i--) 
+    for (i = 100; i; i--)
     {
         err = mmcsd_send_app_cmd(host, RT_NULL, &cmd, 3);
         if (err)
@@ -391,12 +391,12 @@ rt_err_t mmcsd_send_app_op_cond(struct rt_mmcsd_host *host,
             break;
 
         /* otherwise wait until reset completes */
-        if (controller_is_spi(host)) 
+        if (controller_is_spi(host))
         {
             if (!(cmd.resp[0] & R1_SPI_IDLE))
                 break;
-        } 
-        else 
+        }
+        else
         {
             if (cmd.resp[0] & CARD_BUSY)
                 break;
@@ -544,7 +544,7 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host,
         goto err;
 
     card = rt_malloc(sizeof(struct rt_mmcsd_card));
-    if (!card) 
+    if (!card)
     {
         LOG_E("malloc card failed!");
         err = -RT_ENOMEM;
@@ -559,7 +559,7 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host,
     /*
      * For native busses:  get card RCA and quit open drain mode.
      */
-    if (!controller_is_spi(host)) 
+    if (!controller_is_spi(host))
     {
         err = mmcsd_get_card_addr(host, &card->rca);
         if (err)
@@ -576,7 +576,7 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host,
     if (err)
         goto err1;
 
-    if (!controller_is_spi(host)) 
+    if (!controller_is_spi(host))
     {
         err = mmcsd_select_card(card);
         if (err)
@@ -589,7 +589,7 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host,
 
     mmcsd_parse_scr(card);
 
-    if (controller_is_spi(host)) 
+    if (controller_is_spi(host))
     {
         err = mmcsd_spi_use_crc(host, 1);
         if (err)
@@ -606,12 +606,12 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host,
     /* set bus speed */
     max_data_rate = (unsigned int)-1;
 
-    if (card->flags & CARD_FLAG_HIGHSPEED) 
+    if (card->flags & CARD_FLAG_HIGHSPEED)
     {
         if (max_data_rate > card->hs_max_data_rate)
             max_data_rate = card->hs_max_data_rate;
-    } 
-    else if (max_data_rate > card->max_data_rate) 
+    }
+    else if (max_data_rate > card->max_data_rate)
     {
         max_data_rate = card->max_data_rate;
     }
@@ -620,7 +620,7 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host,
 
     /*switch bus width*/
     if ((host->flags & MMCSD_BUSWIDTH_4) &&
-        (card->scr.sd_bus_widths & SD_SCR_BUS_WIDTH_4)) 
+        (card->scr.sd_bus_widths & SD_SCR_BUS_WIDTH_4))
     {
         err = mmcsd_app_set_bus_width(card, MMCSD_BUS_WIDTH_4);
         if (err)
diff --git a/components/drivers/sdio/sdio.c b/components/drivers/sdio/sdio.c
index f5d97cdd08..adad68cf66 100644
--- a/components/drivers/sdio/sdio.c
+++ b/components/drivers/sdio/sdio.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -73,7 +73,7 @@ rt_int32_t sdio_io_send_op_cond(struct rt_mmcsd_host *host,
     cmd.arg = ocr;
     cmd.flags = RESP_SPI_R4 | RESP_R4 | CMD_BCR;
 
-    for (i = 100; i; i--) 
+    for (i = 100; i; i--)
     {
         err = mmcsd_send_cmd(host, &cmd, 0);
         if (err)
@@ -84,7 +84,7 @@ rt_int32_t sdio_io_send_op_cond(struct rt_mmcsd_host *host,
             break;
 
         /* otherwise wait until reset completes */
-        if (controller_is_spi(host)) 
+        if (controller_is_spi(host))
         {
             /*
              * Both R1_SPI_IDLE and MMC_CARD_BUSY indicate
@@ -94,8 +94,8 @@ rt_int32_t sdio_io_send_op_cond(struct rt_mmcsd_host *host,
              */
             if (cmd.resp[1] & CARD_BUSY)
                 break;
-        } 
-        else 
+        }
+        else
         {
             if (cmd.resp[0] & CARD_BUSY)
                 break;
@@ -143,7 +143,7 @@ rt_int32_t sdio_io_rw_direct(struct rt_mmcsd_card *card,
     if (err)
         return err;
 
-    if (!controller_is_spi(card->host)) 
+    if (!controller_is_spi(card->host))
     {
         if (cmd.resp[0] & R5_ERROR)
             return -RT_EIO;
@@ -153,7 +153,7 @@ rt_int32_t sdio_io_rw_direct(struct rt_mmcsd_card *card,
             return -RT_ERROR;
     }
 
-    if (!rw || raw) 
+    if (!rw || raw)
     {
         if (controller_is_spi(card->host))
             *pdata = (cmd.resp[0] >> 8) & 0xFF;
@@ -218,7 +218,7 @@ rt_int32_t sdio_io_rw_extended(struct rt_mmcsd_card *card,
     if (data.err)
         return data.err;
 
-    if (!controller_is_spi(card->host)) 
+    if (!controller_is_spi(card->host))
     {
         if (cmd.resp[0] & R5_ERROR)
             return -RT_EIO;
@@ -250,7 +250,7 @@ rt_int32_t sdio_io_rw_extended_block(struct rt_sdio_function *func,
     rt_int32_t  ret;
     rt_uint32_t left_size;
     rt_uint32_t max_blks, blks;
-    
+
     left_size = len;
 
     /* Do the bulk of the transfer using block mode (if supported). */
@@ -267,7 +267,7 @@ rt_int32_t sdio_io_rw_extended_block(struct rt_sdio_function *func,
                 blks = max_blks;
             len = blks * func->cur_blk_size;
 
-            ret = sdio_io_rw_extended(func->card, rw, func->num, 
+            ret = sdio_io_rw_extended(func->card, rw, func->num,
                   addr, op_code, buf, blks, func->cur_blk_size);
             if (ret)
                 return ret;
@@ -283,7 +283,7 @@ rt_int32_t sdio_io_rw_extended_block(struct rt_sdio_function *func,
     {
         len = MIN(left_size, sdio_max_block_size(func));
 
-        ret = sdio_io_rw_extended(func->card, rw, func->num, 
+        ret = sdio_io_rw_extended(func->card, rw, func->num,
                   addr, op_code, buf, 1, len);
         if (ret)
             return ret;
@@ -297,7 +297,7 @@ rt_int32_t sdio_io_rw_extended_block(struct rt_sdio_function *func,
     return 0;
 }
 
-rt_uint8_t sdio_io_readb(struct rt_sdio_function *func, 
+rt_uint8_t sdio_io_readb(struct rt_sdio_function *func,
                          rt_uint32_t              reg,
                          rt_int32_t              *err)
 {
@@ -314,7 +314,7 @@ rt_uint8_t sdio_io_readb(struct rt_sdio_function *func,
     return data;
 }
 
-rt_int32_t sdio_io_writeb(struct rt_sdio_function *func, 
+rt_int32_t sdio_io_writeb(struct rt_sdio_function *func,
                           rt_uint32_t              reg,
                           rt_uint8_t               data)
 {
@@ -332,7 +332,7 @@ rt_uint16_t sdio_io_readw(struct rt_sdio_function *func,
         *err = 0;
 
     ret = sdio_io_rw_extended_block(func, 0, addr, 1, (rt_uint8_t *)&dmabuf, 2);
-    if (ret) 
+    if (ret)
     {
         if (err)
             *err = ret;
@@ -361,7 +361,7 @@ rt_uint32_t sdio_io_readl(struct rt_sdio_function *func,
         *err = 0;
 
     ret = sdio_io_rw_extended_block(func, 0, addr, 1, (rt_uint8_t *)&dmabuf, 4);
-    if (ret) 
+    if (ret)
     {
         if (err)
             *err = ret;
@@ -379,7 +379,7 @@ rt_int32_t sdio_io_writel(struct rt_sdio_function *func,
     return sdio_io_rw_extended_block(func, 1, addr, 1, (rt_uint8_t *)&dmabuf, 4);
 }
 
-rt_int32_t sdio_io_read_multi_fifo_b(struct rt_sdio_function *func, 
+rt_int32_t sdio_io_read_multi_fifo_b(struct rt_sdio_function *func,
                                      rt_uint32_t              addr,
                                      rt_uint8_t              *buf,
                                      rt_uint32_t              len)
@@ -387,7 +387,7 @@ rt_int32_t sdio_io_read_multi_fifo_b(struct rt_sdio_function *func,
     return sdio_io_rw_extended_block(func, 0, addr, 0, buf, len);
 }
 
-rt_int32_t sdio_io_write_multi_fifo_b(struct rt_sdio_function *func, 
+rt_int32_t sdio_io_write_multi_fifo_b(struct rt_sdio_function *func,
                                       rt_uint32_t              addr,
                                       rt_uint8_t              *buf,
                                       rt_uint32_t              len)
@@ -395,7 +395,7 @@ rt_int32_t sdio_io_write_multi_fifo_b(struct rt_sdio_function *func,
     return sdio_io_rw_extended_block(func, 1, addr, 0, buf, len);
 }
 
-rt_int32_t sdio_io_read_multi_incr_b(struct rt_sdio_function *func, 
+rt_int32_t sdio_io_read_multi_incr_b(struct rt_sdio_function *func,
                                      rt_uint32_t              addr,
                                      rt_uint8_t              *buf,
                                      rt_uint32_t              len)
@@ -403,7 +403,7 @@ rt_int32_t sdio_io_read_multi_incr_b(struct rt_sdio_function *func,
     return sdio_io_rw_extended_block(func, 0, addr, 1, buf, len);
 }
 
-rt_int32_t sdio_io_write_multi_incr_b(struct rt_sdio_function *func, 
+rt_int32_t sdio_io_write_multi_incr_b(struct rt_sdio_function *func,
                                       rt_uint32_t              addr,
                                       rt_uint8_t              *buf,
                                       rt_uint32_t              len)
@@ -425,7 +425,7 @@ static rt_int32_t sdio_read_cccr(struct rt_mmcsd_card *card)
 
     cccr_version = data & 0x0f;
 
-    if (cccr_version > SDIO_CCCR_REV_3_00) 
+    if (cccr_version > SDIO_CCCR_REV_3_00)
     {
         LOG_E("unrecognised CCCR structure version %d", cccr_version);
 
@@ -447,7 +447,7 @@ static rt_int32_t sdio_read_cccr(struct rt_mmcsd_card *card)
     if (data & SDIO_CCCR_CAP_4BLS)
         card->cccr.bus_width = 1;
 
-    if (cccr_version >= SDIO_CCCR_REV_1_10) 
+    if (cccr_version >= SDIO_CCCR_REV_1_10)
     {
         data = sdio_io_readb(card->sdio_function[0], SDIO_REG_CCCR_POWER_CTRL, &ret);
         if (ret)
@@ -457,7 +457,7 @@ static rt_int32_t sdio_read_cccr(struct rt_mmcsd_card *card)
             card->cccr.power_ctrl = 1;
     }
 
-    if (cccr_version >= SDIO_CCCR_REV_1_20) 
+    if (cccr_version >= SDIO_CCCR_REV_1_20)
     {
         data = sdio_io_readb(card->sdio_function[0], SDIO_REG_CCCR_SPEED, &ret);
         if (ret)
@@ -528,7 +528,7 @@ static rt_int32_t sdio_read_cis(struct rt_sdio_function *func)
 
     for (i = 0; i < 3; i++)
     {
-        data = sdio_io_readb(func0, 
+        data = sdio_io_readb(func0,
             SDIO_REG_FBR_BASE(func->num) + SDIO_REG_FBR_CIS + i, &ret);
         if (ret)
             return ret;
@@ -557,13 +557,13 @@ static rt_int32_t sdio_read_cis(struct rt_sdio_function *func)
             return -RT_ENOMEM;
         curr->data = (rt_uint8_t *)curr + sizeof(struct rt_sdio_function_tuple);
 
-        for (i = 0; i < tpl_link; i++) 
+        for (i = 0; i < tpl_link; i++)
         {
             curr->data[i] = sdio_io_readb(func0, cisptr + i, &ret);
             if (ret)
                 break;
         }
-        if (ret) 
+        if (ret)
         {
             rt_free(curr);
             break;
@@ -611,7 +611,7 @@ static rt_int32_t sdio_read_cis(struct rt_sdio_function *func)
                 LOG_D("CISTPL_VERS_1 too short");
             }
             break;
-        default: 
+        default:
             /* this tuple is unknown to the core */
             curr->next = RT_NULL;
             curr->code = tpl_code;
@@ -644,7 +644,7 @@ void sdio_free_cis(struct rt_sdio_function *func)
 
     tuple = func->tuples;
 
-    while (tuple && ((tuple != card->sdio_function[0]->tuples) || (!func->num))) 
+    while (tuple && ((tuple != card->sdio_function[0]->tuples) || (!func->num)))
     {
         tmp = tuple;
         tuple = tuple->next;
@@ -660,16 +660,16 @@ static rt_int32_t sdio_read_fbr(struct rt_sdio_function *func)
     rt_uint8_t data;
     struct rt_sdio_function *func0 = func->card->sdio_function[0];
 
-    data = sdio_io_readb(func0, 
+    data = sdio_io_readb(func0,
         SDIO_REG_FBR_BASE(func->num) + SDIO_REG_FBR_STD_FUNC_IF, &ret);
     if (ret)
         goto err;
 
     data &= 0x0f;
 
-    if (data == 0x0f) 
+    if (data == 0x0f)
     {
-        data = sdio_io_readb(func0, 
+        data = sdio_io_readb(func0,
             SDIO_REG_FBR_BASE(func->num) + SDIO_REG_FBR_STD_IF_EXT, &ret);
         if (ret)
             goto err;
@@ -828,7 +828,7 @@ static rt_int32_t sdio_init_card(struct rt_mmcsd_host *host, rt_uint32_t ocr)
     if (err)
         goto err;
 
-    if (controller_is_spi(host)) 
+    if (controller_is_spi(host))
     {
         err = mmcsd_spi_use_crc(host, host->spi_use_crc);
         if (err)
@@ -838,7 +838,7 @@ static rt_int32_t sdio_init_card(struct rt_mmcsd_host *host, rt_uint32_t ocr)
     function_num = (cmd5_resp & 0x70000000) >> 28;
 
     card = rt_malloc(sizeof(struct rt_mmcsd_card));
-    if (!card) 
+    if (!card)
     {
         LOG_E("malloc card failed");
         err = -RT_ENOMEM;
@@ -862,7 +862,7 @@ static rt_int32_t sdio_init_card(struct rt_mmcsd_host *host, rt_uint32_t ocr)
     card->sdio_function[0]->card = card;
     card->sdio_function[0]->num = 0;
 
-    if (!controller_is_spi(host)) 
+    if (!controller_is_spi(host))
     {
         err = mmcsd_get_card_addr(host, &card->rca);
         if (err)
@@ -871,7 +871,7 @@ static rt_int32_t sdio_init_card(struct rt_mmcsd_host *host, rt_uint32_t ocr)
         mmcsd_set_bus_mode(host, MMCSD_BUSMODE_PUSHPULL);
     }
 
-    if (!controller_is_spi(host)) 
+    if (!controller_is_spi(host))
     {
         err = mmcsd_select_card(card);
         if (err)
@@ -890,7 +890,7 @@ static rt_int32_t sdio_init_card(struct rt_mmcsd_host *host, rt_uint32_t ocr)
     if (err)
         goto err2;
 
-    if (card->flags & CARD_FLAG_HIGHSPEED) 
+    if (card->flags & CARD_FLAG_HIGHSPEED)
     {
         mmcsd_set_clock(host, card->host->freq_max > 50000000 ? 50000000 : card->host->freq_max);
     }
@@ -903,7 +903,7 @@ static rt_int32_t sdio_init_card(struct rt_mmcsd_host *host, rt_uint32_t ocr)
     if (err)
         goto err2;
 
-    for (i = 1; i < function_num + 1; i++) 
+    for (i = 1; i < function_num + 1; i++)
     {
         err = sdio_initialize_function(card, i);
         if (err)
@@ -950,7 +950,7 @@ err1:
     }
 err:
     LOG_E("error %d while initialising SDIO card", err);
-    
+
     return err;
 }
 
@@ -961,13 +961,13 @@ rt_int32_t init_sdio(struct rt_mmcsd_host *host, rt_uint32_t ocr)
 
     RT_ASSERT(host != RT_NULL);
 
-    if (ocr & 0x7F) 
+    if (ocr & 0x7F)
     {
         LOG_W("Card ocr below the defined voltage rang.");
         ocr &= ~0x7F;
     }
 
-    if (ocr & VDD_165_195) 
+    if (ocr & VDD_165_195)
     {
         LOG_W("Can't support the low voltage SDIO card.");
         ocr &= ~VDD_165_195;
@@ -975,7 +975,7 @@ rt_int32_t init_sdio(struct rt_mmcsd_host *host, rt_uint32_t ocr)
 
     current_ocr = mmcsd_select_voltage(host, ocr);
 
-    if (!current_ocr) 
+    if (!current_ocr)
     {
         err = -RT_ERROR;
         goto err;
@@ -1007,35 +1007,35 @@ static void sdio_irq_thread(void *param)
     card = host->card;
     RT_ASSERT(card != RT_NULL);
 
-    while (1) 
+    while (1)
     {
         if (rt_sem_take(host->sdio_irq_sem, RT_WAITING_FOREVER) == RT_EOK)
         {
             mmcsd_host_lock(host);
-            pending = sdio_io_readb(host->card->sdio_function[0], 
+            pending = sdio_io_readb(host->card->sdio_function[0],
                         SDIO_REG_CCCR_INT_PEND, &ret);
-            if (ret) 
+            if (ret)
             {
                 mmcsd_dbg("error %d reading SDIO_REG_CCCR_INT_PEND\n", ret);
                 goto out;
             }
 
-            for (i = 1; i <= 7; i++) 
+            for (i = 1; i <= 7; i++)
             {
-                if (pending & (1 << i)) 
+                if (pending & (1 << i))
                 {
                     struct rt_sdio_function *func = card->sdio_function[i];
-                    if (!func) 
+                    if (!func)
                     {
                         mmcsd_dbg("pending IRQ for "
                             "non-existant function %d\n", func->num);
                         goto out;
-                    } 
-                    else if (func->irq_handler) 
+                    }
+                    else if (func->irq_handler)
                     {
                         func->irq_handler(func);
-                    } 
-                    else 
+                    }
+                    else
                     {
                         mmcsd_dbg("pending IRQ with no register handler\n");
                         goto out;
@@ -1063,9 +1063,9 @@ static rt_int32_t sdio_irq_thread_create(struct rt_mmcsd_card *card)
         host->sdio_irq_sem = rt_sem_create("sdio_irq", 0, RT_IPC_FLAG_FIFO);
         RT_ASSERT(host->sdio_irq_sem != RT_NULL);
 
-        host->sdio_irq_thread = rt_thread_create("sdio_irq", sdio_irq_thread, host, 
+        host->sdio_irq_thread = rt_thread_create("sdio_irq", sdio_irq_thread, host,
                              RT_SDIO_STACK_SIZE, RT_SDIO_THREAD_PRIORITY, 20);
-        if (host->sdio_irq_thread != RT_NULL) 
+        if (host->sdio_irq_thread != RT_NULL)
         {
             rt_thread_startup(host->sdio_irq_thread);
         }
@@ -1081,7 +1081,7 @@ static rt_int32_t sdio_irq_thread_delete(struct rt_mmcsd_card *card)
     RT_ASSERT(host->sdio_irq_num > 0);
 
     host->sdio_irq_num--;
-    if (!host->sdio_irq_num) 
+    if (!host->sdio_irq_num)
     {
         if (host->flags & MMCSD_SUP_SDIO_IRQ)
             host->ops->enable_sdio_irq(host, 0);
@@ -1108,7 +1108,7 @@ rt_int32_t sdio_attach_irq(struct rt_sdio_function *func,
 
     mmcsd_dbg("SDIO: enabling IRQ for function %d\n", func->num);
 
-    if (func->irq_handler) 
+    if (func->irq_handler)
     {
         mmcsd_dbg("SDIO: IRQ for already in use.\n");
 
@@ -1149,7 +1149,7 @@ rt_int32_t sdio_detach_irq(struct rt_sdio_function *func)
 
     mmcsd_dbg("SDIO: disabling IRQ for function %d\n", func->num);
 
-    if (func->irq_handler) 
+    if (func->irq_handler)
     {
         func->irq_handler = RT_NULL;
         sdio_irq_thread_delete(func->card);
@@ -1206,7 +1206,7 @@ rt_int32_t sdio_enable_func(struct rt_sdio_function *func)
 
     timeout = rt_tick_get() + func->enable_timeout_val * RT_TICK_PER_SECOND / 1000;
 
-    while (1) 
+    while (1)
     {
         reg = sdio_io_readb(func0, SDIO_REG_CCCR_IO_RDY, &ret);
         if (ret)
@@ -1278,17 +1278,17 @@ rt_int32_t sdio_set_block_size(struct rt_sdio_function *func,
     if (blksize > func->card->host->max_blk_size)
         return -RT_ERROR;
 
-    if (blksize == 0) 
+    if (blksize == 0)
     {
         blksize = MIN(func->max_blk_size, func->card->host->max_blk_size);
         blksize = MIN(blksize, 512u);
     }
 
-    ret = sdio_io_writeb(func0, SDIO_REG_FBR_BASE(func->num) + SDIO_REG_FBR_BLKSIZE, 
+    ret = sdio_io_writeb(func0, SDIO_REG_FBR_BASE(func->num) + SDIO_REG_FBR_BLKSIZE,
                  blksize & 0xff);
     if (ret)
         return ret;
-    ret = sdio_io_writeb(func0, SDIO_REG_FBR_BASE(func->num) + SDIO_REG_FBR_BLKSIZE + 1, 
+    ret = sdio_io_writeb(func0, SDIO_REG_FBR_BASE(func->num) + SDIO_REG_FBR_BLKSIZE + 1,
                  (blksize >> 8) & 0xff);
     if (ret)
         return ret;
@@ -1301,14 +1301,14 @@ rt_inline rt_int32_t sdio_match_card(struct rt_mmcsd_card           *card,
                                      const struct rt_sdio_device_id *id)
 {
     rt_uint8_t num = 1;
-    
-    if ((id->manufacturer != SDIO_ANY_MAN_ID) && 
+
+    if ((id->manufacturer != SDIO_ANY_MAN_ID) &&
         (id->manufacturer != card->cis.manufacturer))
         return 0;
-    
+
     while (num <= card->sdio_function_num)
     {
-        if ((id->product != SDIO_ANY_PROD_ID) && 
+        if ((id->product != SDIO_ANY_PROD_ID) &&
             (id->product == card->sdio_function[num]->product))
             return 1;
         num++;