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

[lts 3.1.x] format codes

1 files changed, 63 insertions, 63 deletions

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++;