[MMC] code cleanup for mmc/sd.

components/drivers/include/drivers/mmcsd_core.h

@@ -4,8 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  *
  * Change Logs:
- * Date           Author		Notes
- * 2011-07-25     weety		first version
+ * Date           Author        Notes
+ * 2011-07-25     weety         first version
  */
 
 #ifndef __CORE_H__
@@ -28,148 +28,149 @@ extern "C" {
 #define mmcsd_dbg(fmt, ...)
 #endif
 
-struct rt_mmcsd_data {
-	rt_uint32_t  blksize;
-	rt_uint32_t  blks;
-	rt_uint32_t  *buf;
-	void *dma_addr;
-	rt_int32_t  err;
-	rt_uint32_t  flags;
-#define DATA_DIR_WRITE	(1 << 0)
-#define DATA_DIR_READ	(1 << 1)
-#define DATA_STREAM	(1 << 2)
+struct rt_mmcsd_data
+{
+    rt_uint32_t  blksize;
+    rt_uint32_t  blks;
+    rt_uint32_t  *buf;
+    void *dma_addr;
+    rt_int32_t  err;
+    rt_uint32_t  flags;
+#define DATA_DIR_WRITE  (1 << 0)
+#define DATA_DIR_READ   (1 << 1)
+#define DATA_STREAM     (1 << 2)
 
-	unsigned int		bytes_xfered;
+    unsigned int        bytes_xfered;
 
-	struct rt_mmcsd_cmd	*stop;		/* stop command */
-	struct rt_mmcsd_req	*mrq;		/* associated request */
+    struct rt_mmcsd_cmd *stop;      /* stop command */
+    struct rt_mmcsd_req *mrq;       /* associated request */
 
-	rt_uint32_t  timeout_ns;
-	rt_uint32_t  timeout_clks;
-	long host_cookie;	/* host driver private data */
+    rt_uint32_t  timeout_ns;
+    rt_uint32_t  timeout_clks;
+    long host_cookie;   /* host driver private data */
 };
 
-struct rt_mmcsd_cmd {
-	rt_uint32_t  cmd_code;
-	rt_uint32_t  arg;
-	rt_uint32_t  resp[4];
-	rt_uint32_t  flags;
-/*rsponse types 
- *bits:0~3
- */
-#define RESP_MASK	(0xF)
-#define RESP_NONE	(0)
-#define RESP_R1		(1 << 0)
-#define RESP_R1B	(2 << 0)
-#define RESP_R2		(3 << 0)
-#define RESP_R3		(4 << 0)
-#define RESP_R4		(5 << 0)
-#define RESP_R6		(6 << 0)
-#define RESP_R7		(7 << 0)
-#define RESP_R5		(8 << 0)	/*SDIO command response type*/
-/*command types 
- *bits:4~5
- */
-#define CMD_MASK	(3 << 4)		/* command type */
-#define CMD_AC		(0 << 4)
-#define CMD_ADTC	(1 << 4)
-#define CMD_BC		(2 << 4)
-#define CMD_BCR		(3 << 4)
+struct rt_mmcsd_cmd
+{
+    rt_uint32_t  cmd_code;
+    rt_uint32_t  arg;
+    rt_uint32_t  resp[4];
+    rt_uint32_t  flags;
+    /*rsponse types
+     *bits:0~3
+     */
+#define RESP_MASK   (0xF)
+#define RESP_NONE   (0)
+#define RESP_R1     (1 << 0)
+#define RESP_R1B    (2 << 0)
+#define RESP_R2     (3 << 0)
+#define RESP_R3     (4 << 0)
+#define RESP_R4     (5 << 0)
+#define RESP_R6     (6 << 0)
+#define RESP_R7     (7 << 0)
+#define RESP_R5     (8 << 0)    /*SDIO command response type*/
+    /*command types
+     *bits:4~5
+     */
+#define CMD_MASK    (3 << 4)        /* command type */
+#define CMD_AC      (0 << 4)
+#define CMD_ADTC    (1 << 4)
+#define CMD_BC      (2 << 4)
+#define CMD_BCR     (3 << 4)
 
-#define resp_type(cmd)	((cmd)->flags & RESP_MASK)
+#define resp_type(cmd)  ((cmd)->flags & RESP_MASK)
 
-/*spi rsponse types 
- *bits:6~8
- */
-#define RESP_SPI_MASK	(0x7 << 6)
-#define RESP_SPI_R1	(1 << 6)
-#define RESP_SPI_R1B	(2 << 6)
-#define RESP_SPI_R2	(3 << 6)
-#define RESP_SPI_R3	(4 << 6)
-#define RESP_SPI_R4	(5 << 6)
-#define RESP_SPI_R5	(6 << 6)
-#define RESP_SPI_R7	(7 << 6)
+    /*spi rsponse types
+     *bits:6~8
+     */
+#define RESP_SPI_MASK   (0x7 << 6)
+#define RESP_SPI_R1 (1 << 6)
+#define RESP_SPI_R1B    (2 << 6)
+#define RESP_SPI_R2 (3 << 6)
+#define RESP_SPI_R3 (4 << 6)
+#define RESP_SPI_R4 (5 << 6)
+#define RESP_SPI_R5 (6 << 6)
+#define RESP_SPI_R7 (7 << 6)
 
-#define spi_resp_type(cmd)	((cmd)->flags & RESP_SPI_MASK)
-/*
- * These are the command types.
- */
-#define cmd_type(cmd)	((cmd)->flags & CMD_MASK)
-	
-	rt_int32_t  retries;	/* max number of retries */
-	rt_int32_t  err;
-    unsigned int busy_timeout;	/* busy detect timeout in ms */
+#define spi_resp_type(cmd)  ((cmd)->flags & RESP_SPI_MASK)
+    /*
+     * These are the command types.
+     */
+#define cmd_type(cmd)   ((cmd)->flags & CMD_MASK)
+
+    rt_int32_t  retries;            /* max number of retries */
+    rt_int32_t  err;
+    unsigned int busy_timeout;      /* busy detect timeout in ms */
 
-	struct rt_mmcsd_data *data;
-	struct rt_mmcsd_req	*mrq;		/* associated request */
+    struct rt_mmcsd_data *data;
+    struct rt_mmcsd_req *mrq;       /* associated request */
 };
 
-struct rt_mmcsd_req {
-	struct rt_mmcsd_data  *data;
-	struct rt_mmcsd_cmd   *cmd;
-	struct rt_mmcsd_cmd   *stop;
-	struct rt_mmcsd_cmd	*sbc;		/* SET_BLOCK_COUNT for multiblock */	
-	/* Allow other commands during this ongoing data transfer or busy wait */
-	int cap_cmd_during_tfr;
+struct rt_mmcsd_req
+{
+    struct rt_mmcsd_data  *data;
+    struct rt_mmcsd_cmd   *cmd;
+    struct rt_mmcsd_cmd   *stop;
+    struct rt_mmcsd_cmd *sbc;       /* SET_BLOCK_COUNT for multiblock */
+    /* Allow other commands during this ongoing data transfer or busy wait */
+    int cap_cmd_during_tfr;
 };
 
 /*the following is response bit*/
-#define R1_OUT_OF_RANGE		(1 << 31)	/* er, c */
-#define R1_ADDRESS_ERROR	(1 << 30)	/* erx, c */
-#define R1_BLOCK_LEN_ERROR	(1 << 29)	/* er, c */
-#define R1_ERASE_SEQ_ERROR      (1 << 28)	/* er, c */
-#define R1_ERASE_PARAM		(1 << 27)	/* ex, c */
-#define R1_WP_VIOLATION		(1 << 26)	/* erx, c */
-#define R1_CARD_IS_LOCKED	(1 << 25)	/* sx, a */
-#define R1_LOCK_UNLOCK_FAILED	(1 << 24)	/* erx, c */
-#define R1_COM_CRC_ERROR	(1 << 23)	/* er, b */
-#define R1_ILLEGAL_COMMAND	(1 << 22)	/* er, b */
-#define R1_CARD_ECC_FAILED	(1 << 21)	/* ex, c */
-#define R1_CC_ERROR		(1 << 20)	/* erx, c */
-#define R1_ERROR		(1 << 19)	/* erx, c */
-#define R1_UNDERRUN		(1 << 18)	/* ex, c */
-#define R1_OVERRUN		(1 << 17)	/* ex, c */
-#define R1_CID_CSD_OVERWRITE	(1 << 16)	/* erx, c, CID/CSD overwrite */
-#define R1_WP_ERASE_SKIP	(1 << 15)	/* sx, c */
-#define R1_CARD_ECC_DISABLED	(1 << 14)	/* sx, a */
-#define R1_ERASE_RESET		(1 << 13)	/* sr, c */
+#define R1_OUT_OF_RANGE     (1 << 31)   /* er, c */
+#define R1_ADDRESS_ERROR    (1 << 30)   /* erx, c */
+#define R1_BLOCK_LEN_ERROR  (1 << 29)   /* er, c */
+#define R1_ERASE_SEQ_ERROR  (1 << 28)   /* er, c */
+#define R1_ERASE_PARAM      (1 << 27)   /* ex, c */
+#define R1_WP_VIOLATION     (1 << 26)   /* erx, c */
+#define R1_CARD_IS_LOCKED   (1 << 25)   /* sx, a */
+#define R1_LOCK_UNLOCK_FAILED   (1 << 24)   /* erx, c */
+#define R1_COM_CRC_ERROR    (1 << 23)   /* er, b */
+#define R1_ILLEGAL_COMMAND  (1 << 22)   /* er, b */
+#define R1_CARD_ECC_FAILED  (1 << 21)   /* ex, c */
+#define R1_CC_ERROR     (1 << 20)   /* erx, c */
+#define R1_ERROR        (1 << 19)   /* erx, c */
+#define R1_UNDERRUN     (1 << 18)   /* ex, c */
+#define R1_OVERRUN      (1 << 17)   /* ex, c */
+#define R1_CID_CSD_OVERWRITE    (1 << 16)   /* erx, c, CID/CSD overwrite */
+#define R1_WP_ERASE_SKIP    (1 << 15)   /* sx, c */
+#define R1_CARD_ECC_DISABLED    (1 << 14)   /* sx, a */
+#define R1_ERASE_RESET      (1 << 13)   /* sr, c */
 #define R1_STATUS(x)            (x & 0xFFFFE000)
-#define R1_CURRENT_STATE(x)	((x & 0x00001E00) >> 9)	/* sx, b (4 bits) */
-#define R1_READY_FOR_DATA	(1 << 8)	/* sx, a */
-#define R1_APP_CMD		(1 << 5)	/* sr, c */
+#define R1_CURRENT_STATE(x) ((x & 0x00001E00) >> 9) /* sx, b (4 bits) */
+#define R1_READY_FOR_DATA   (1 << 8)    /* sx, a */
+#define R1_APP_CMD          (1 << 5)    /* sr, c */
 
 
-#define R1_SPI_IDLE		(1 << 0)
-#define R1_SPI_ERASE_RESET	(1 << 1)
-#define R1_SPI_ILLEGAL_COMMAND	(1 << 2)
-#define R1_SPI_COM_CRC		(1 << 3)
-#define R1_SPI_ERASE_SEQ	(1 << 4)
-#define R1_SPI_ADDRESS		(1 << 5)
-#define R1_SPI_PARAMETER	(1 << 6)
+#define R1_SPI_IDLE     (1 << 0)
+#define R1_SPI_ERASE_RESET  (1 << 1)
+#define R1_SPI_ILLEGAL_COMMAND  (1 << 2)
+#define R1_SPI_COM_CRC      (1 << 3)
+#define R1_SPI_ERASE_SEQ    (1 << 4)
+#define R1_SPI_ADDRESS      (1 << 5)
+#define R1_SPI_PARAMETER    (1 << 6)
 /* R1 bit 7 is always zero */
-#define R2_SPI_CARD_LOCKED	(1 << 8)
-#define R2_SPI_WP_ERASE_SKIP	(1 << 9)	/* or lock/unlock fail */
-#define R2_SPI_LOCK_UNLOCK_FAIL	R2_SPI_WP_ERASE_SKIP
-#define R2_SPI_ERROR		(1 << 10)
-#define R2_SPI_CC_ERROR		(1 << 11)
-#define R2_SPI_CARD_ECC_ERROR	(1 << 12)
-#define R2_SPI_WP_VIOLATION	(1 << 13)
-#define R2_SPI_ERASE_PARAM	(1 << 14)
-#define R2_SPI_OUT_OF_RANGE	(1 << 15)	/* or CSD overwrite */
-#define R2_SPI_CSD_OVERWRITE	R2_SPI_OUT_OF_RANGE
+#define R2_SPI_CARD_LOCKED  (1 << 8)
+#define R2_SPI_WP_ERASE_SKIP    (1 << 9)    /* or lock/unlock fail */
+#define R2_SPI_LOCK_UNLOCK_FAIL R2_SPI_WP_ERASE_SKIP
+#define R2_SPI_ERROR        (1 << 10)
+#define R2_SPI_CC_ERROR     (1 << 11)
+#define R2_SPI_CARD_ECC_ERROR   (1 << 12)
+#define R2_SPI_WP_VIOLATION (1 << 13)
+#define R2_SPI_ERASE_PARAM  (1 << 14)
+#define R2_SPI_OUT_OF_RANGE (1 << 15)   /* or CSD overwrite */
+#define R2_SPI_CSD_OVERWRITE    R2_SPI_OUT_OF_RANGE
 
-#define CARD_BUSY	0x80000000	/* Card Power up status bit */
+#define CARD_BUSY   0x80000000  /* Card Power up status bit */
 
 /* R5 response bits */
-#define R5_COM_CRC_ERROR	(1 << 15)
-#define R5_ILLEGAL_COMMAND	(1 << 14)
-#define R5_ERROR			(1 << 11)
-#define R5_FUNCTION_NUMBER	(1 << 9)
-#define R5_OUT_OF_RANGE		(1 << 8)
-#define R5_STATUS(x)		(x & 0xCB00)
-#define R5_IO_CURRENT_STATE(x)	((x & 0x3000) >> 12)
-
-
+#define R5_COM_CRC_ERROR    (1 << 15)
+#define R5_ILLEGAL_COMMAND  (1 << 14)
+#define R5_ERROR            (1 << 11)
+#define R5_FUNCTION_NUMBER  (1 << 9)
+#define R5_OUT_OF_RANGE     (1 << 8)
+#define R5_STATUS(x)        (x & 0xCB00)
+#define R5_IO_CURRENT_STATE(x)  ((x & 0x3000) >> 12)
 
 /**
  * fls - find last (most-significant) bit set
@@ -181,36 +182,36 @@ struct rt_mmcsd_req {
 
 rt_inline rt_uint32_t __rt_fls(rt_uint32_t val)
 {
-	rt_uint32_t  bit = 32;
+    rt_uint32_t  bit = 32;
 
-	if (!val)
-		return 0;
-	if (!(val & 0xffff0000u)) 
-	{
-		val <<= 16;
-		bit -= 16;
-	}
-	if (!(val & 0xff000000u)) 
-	{
-		val <<= 8;
-		bit -= 8;
-	}
-	if (!(val & 0xf0000000u)) 
-	{
-		val <<= 4;
-		bit -= 4;
-	}
-	if (!(val & 0xc0000000u)) 
-	{
-		val <<= 2;
-		bit -= 2;
-	}
-	if (!(val & 0x80000000u)) 
-	{
-		bit -= 1;
-	}
+    if (!val)
+        return 0;
+    if (!(val & 0xffff0000u))
+    {
+        val <<= 16;
+        bit -= 16;
+    }
+    if (!(val & 0xff000000u))
+    {
+        val <<= 8;
+        bit -= 8;
+    }
+    if (!(val & 0xf0000000u))
+    {
+        val <<= 4;
+        bit -= 4;
+    }
+    if (!(val & 0xc0000000u))
+    {
+        val <<= 2;
+        bit -= 2;
+    }
+    if (!(val & 0x80000000u))
+    {
+        bit -= 1;
+    }
 
-	return bit;
+    return bit;
 }
 
 #define MMCSD_HOST_PLUGED       0
@@ -250,7 +251,6 @@ rt_int32_t read_lba(struct rt_mmcsd_card *card, size_t lba, uint8_t *buffer, siz
 rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card);
 void rt_mmcsd_blk_remove(struct rt_mmcsd_card *card);
 
-
 #ifdef __cplusplus
 }
 #endif

components/drivers/include/drivers/mmcsd_host.h

@@ -17,11 +17,12 @@
 extern "C" {
 #endif
 
-struct rt_mmcsd_io_cfg {
+struct rt_mmcsd_io_cfg
+{
     rt_uint32_t clock;          /* clock rate */
     rt_uint16_t vdd;
 
-/* vdd stores the bit number of the selected voltage range from below. */
+    /* vdd stores the bit number of the selected voltage range from below. */
 
     rt_uint8_t  bus_mode;       /* command output mode */
 
@@ -46,38 +47,39 @@ struct rt_mmcsd_io_cfg {
 #define MMCSD_BUS_WIDTH_4       2
 #define MMCSD_BUS_WIDTH_8       3
 
-	unsigned char	timing;			/* timing specification used */
+    unsigned char   timing;         /* timing specification used */
 
-#define MMCSD_TIMING_LEGACY	0
-#define MMCSD_TIMING_MMC_HS	1
-#define MMCSD_TIMING_SD_HS	2
-#define MMCSD_TIMING_UHS_SDR12	3
-#define MMCSD_TIMING_UHS_SDR25	4
-#define MMCSD_TIMING_UHS_SDR50	5
-#define MMCSD_TIMING_UHS_SDR104	6
-#define MMCSD_TIMING_UHS_DDR50	7
-#define MMCSD_TIMING_MMC_DDR52	8
-#define MMCSD_TIMING_MMC_HS200	9
-#define MMCSD_TIMING_MMC_HS400	10
+#define MMCSD_TIMING_LEGACY 0
+#define MMCSD_TIMING_MMC_HS 1
+#define MMCSD_TIMING_SD_HS  2
+#define MMCSD_TIMING_UHS_SDR12  3
+#define MMCSD_TIMING_UHS_SDR25  4
+#define MMCSD_TIMING_UHS_SDR50  5
+#define MMCSD_TIMING_UHS_SDR104 6
+#define MMCSD_TIMING_UHS_DDR50  7
+#define MMCSD_TIMING_MMC_DDR52  8
+#define MMCSD_TIMING_MMC_HS200  9
+#define MMCSD_TIMING_MMC_HS400  10
 
-	unsigned char	drv_type;		/* driver type (A, B, C, D) */
+    unsigned char   drv_type;       /* driver type (A, B, C, D) */
 
-#define MMCSD_SET_DRIVER_TYPE_B	0
-#define MMCSD_SET_DRIVER_TYPE_A	1
-#define MMCSD_SET_DRIVER_TYPE_C	2
-#define MMCSD_SET_DRIVER_TYPE_D	3
+#define MMCSD_SET_DRIVER_TYPE_B 0
+#define MMCSD_SET_DRIVER_TYPE_A 1
+#define MMCSD_SET_DRIVER_TYPE_C 2
+#define MMCSD_SET_DRIVER_TYPE_D 3
 
-	unsigned char	signal_voltage;
+    unsigned char   signal_voltage;
 
-#define MMCSD_SIGNAL_VOLTAGE_330	0
-#define MMCSD_SIGNAL_VOLTAGE_180	1
-#define MMCSD_SIGNAL_VOLTAGE_120	2
+#define MMCSD_SIGNAL_VOLTAGE_330    0
+#define MMCSD_SIGNAL_VOLTAGE_180    1
+#define MMCSD_SIGNAL_VOLTAGE_120    2
 };
 
 struct rt_mmcsd_host;
 struct rt_mmcsd_req;
 
-struct rt_mmcsd_host_ops {
+struct rt_mmcsd_host_ops
+{
     void (*request)(struct rt_mmcsd_host *host, struct rt_mmcsd_req *req);
     void (*set_iocfg)(struct rt_mmcsd_host *host, struct rt_mmcsd_io_cfg *io_cfg);
     rt_int32_t (*get_card_status)(struct rt_mmcsd_host *host);
@@ -85,7 +87,8 @@ struct rt_mmcsd_host_ops {
     rt_int32_t (*execute_tuning)(struct rt_mmcsd_host *host, rt_int32_t opcode);
 };
 
-struct rt_mmcsd_host {
+struct rt_mmcsd_host
+{
     char name[RT_NAME_MAX];
     struct rt_mmcsd_card *card;
     const struct rt_mmcsd_host_ops *ops;
@@ -125,7 +128,7 @@ struct rt_mmcsd_host {
 #define MMCSD_SUP_HS200_1V8  (1 << 9)
 #define MMCSD_SUP_HS200_1V2  (1 << 10)
 #define MMCSD_SUP_HS200     (MMCSD_SUP_HS200_1V2 | MMCSD_SUP_HS200_1V8) /* hs200 sdr */
-#define MMCSD_SUP_NONREMOVABLE	(1 << 11)
+#define MMCSD_SUP_NONREMOVABLE  (1 << 11)
 
     rt_uint32_t max_seg_size;   /* maximum size of one dma segment */
     rt_uint32_t max_dma_segs;   /* maximum number of dma segments in one request */
@@ -151,7 +154,7 @@ rt_inline void mmcsd_delay_ms(rt_uint32_t ms)
     }
     else
     {
-        rt_thread_delay(ms/(1000 / RT_TICK_PER_SECOND));
+        rt_thread_delay(ms / (1000 / RT_TICK_PER_SECOND));
     }
 }
 

components/drivers/sdio/block_dev.c

@@ -51,11 +51,11 @@ static int __send_status(struct rt_mmcsd_card *card, rt_uint32_t *status, unsign
     cmd.arg = card->rca << 16;
     cmd.flags = RESP_R1 | CMD_AC;
     err = mmcsd_send_cmd(card->host, &cmd, retries);
-	if (err)
-		return err;
+    if (err)
+        return err;
 
-	if (status)
-		*status = cmd.resp[0];
+    if (status)
+        *status = cmd.resp[0];
 
     return 0;
 }
@@ -94,8 +94,9 @@ static int card_busy_detect(struct rt_mmcsd_card *card, unsigned int timeout_ms,
          * so make sure to check both the busy
          * indication and the card state.
          */
-    } while (!(status & R1_READY_FOR_DATA) ||
-             (R1_CURRENT_STATE(status) == 7));
+    }
+    while (!(status & R1_READY_FOR_DATA) ||
+            (R1_CURRENT_STATE(status) == 7));
 
     return err;
 }
@@ -135,7 +136,7 @@ rt_int32_t mmcsd_num_wr_blocks(struct rt_mmcsd_card *card)
 
     timeout_us = data.timeout_ns / 1000;
     timeout_us += data.timeout_clks * 1000 /
-        (card->host->io_cfg.clock / 1000);
+                  (card->host->io_cfg.clock / 1000);
 
     if (timeout_us > 100000)
     {
@@ -231,7 +232,7 @@ static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card,
 
     mmcsd_set_data_timeout(&data, card);
     data.buf = buf;
- 
+
     mmcsd_send_request(host, &req);
 
     mmcsd_host_unlock(host);
@@ -240,7 +241,7 @@ static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card,
     {
         LOG_E("mmcsd request blocks error");
         LOG_E("%d,%d,%d, 0x%08x,0x%08x",
-                   cmd.err, data.err, stop.err, data.flags, sector);
+              cmd.err, data.err, stop.err, data.flags, sector);
 
         return -RT_ERROR;
     }
@@ -392,7 +393,7 @@ rt_int32_t read_lba(struct rt_mmcsd_card *card, size_t lba, uint8_t *buffer, siz
     rt_uint8_t status = 0;
 
     status = mmcsd_set_blksize(card);
-    if(status)
+    if (status)
     {
         return status;
     }
@@ -429,12 +430,12 @@ rt_int32_t gpt_device_probe(struct rt_mmcsd_card *card)
     }
 
     blk_dev->max_req_size = BLK_MIN((card->host->max_dma_segs *
-                                        card->host->max_seg_size) >> 9,
+                                     card->host->max_seg_size) >> 9,
                                     (card->host->max_blk_count *
-                                        card->host->max_blk_size) >> 9);
+                                     card->host->max_blk_size) >> 9);
     blk_dev->part.offset = 0;
     blk_dev->part.size   = 0;
-    rt_snprintf(sname, sizeof(sname)-1, "sem_%s%d", card->host->name,0);
+    rt_snprintf(sname, sizeof(sname) - 1, "sem_%s%d", card->host->name, 0);
     blk_dev->part.lock = rt_sem_create(sname, 1, RT_IPC_FLAG_FIFO);
     /* register mmcsd device */
     blk_dev->dev.type  = RT_Device_Class_Block;
@@ -450,7 +451,7 @@ rt_int32_t gpt_device_probe(struct rt_mmcsd_card *card)
 #endif
     blk_dev->card = card;
 
-    blk_dev->geometry.bytes_per_sector = 1<<9;
+    blk_dev->geometry.bytes_per_sector = 1 << 9;
     blk_dev->geometry.block_size = card->card_blksize;
     blk_dev->geometry.sector_count =
         card->card_capacity * (1024 / 512);
@@ -458,7 +459,7 @@ rt_int32_t gpt_device_probe(struct rt_mmcsd_card *card)
     blk_dev->dev.user_data = blk_dev;
 
     rt_device_register(&(blk_dev->dev), card->host->name,
-        RT_DEVICE_FLAG_RDWR);
+                       RT_DEVICE_FLAG_RDWR);
     rt_list_insert_after(&blk_devices, &blk_dev->list);
 
     for (i = 0; i < RT_GPT_PARTITION_MAX; i++)
@@ -470,16 +471,16 @@ rt_int32_t gpt_device_probe(struct rt_mmcsd_card *card)
             break;
         }
         blk_dev->max_req_size = BLK_MIN((card->host->max_dma_segs *
-                                        card->host->max_seg_size) >> 9,
+                                         card->host->max_seg_size) >> 9,
                                         (card->host->max_blk_count *
-                                        card->host->max_blk_size) >> 9);
+                                         card->host->max_blk_size) >> 9);
 
         /* get the first partition */
         status = gpt_get_partition_param(card, &blk_dev->part, i);
         if (status == RT_EOK)
         {
-            rt_snprintf(dname, sizeof(dname)-1, "%s%d", card->host->name,i);
-            rt_snprintf(sname, sizeof(sname)-1, "sem_%s%d", card->host->name,i+1);
+            rt_snprintf(dname, sizeof(dname) - 1, "%s%d", card->host->name, i);
+            rt_snprintf(sname, sizeof(sname) - 1, "sem_%s%d", card->host->name, i + 1);
             blk_dev->part.lock = rt_sem_create(sname, 1, RT_IPC_FLAG_FIFO);
 
             /* register mmcsd device */
@@ -496,14 +497,14 @@ rt_int32_t gpt_device_probe(struct rt_mmcsd_card *card)
 #endif
             blk_dev->card = card;
 
-            blk_dev->geometry.bytes_per_sector = 1<<9;
+            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;
 
             blk_dev->dev.user_data = blk_dev;
 
             rt_device_register(&(blk_dev->dev), dname,
-                RT_DEVICE_FLAG_RDWR);
+                               RT_DEVICE_FLAG_RDWR);
             rt_list_insert_after(&blk_devices, &blk_dev->list);
         }
         else
@@ -537,7 +538,7 @@ rt_int32_t mbr_device_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;
     }
@@ -561,12 +562,12 @@ rt_int32_t mbr_device_probe(struct rt_mmcsd_card *card)
             return -1;
         }
         blk_dev->max_req_size = BLK_MIN((card->host->max_dma_segs *
-                                        card->host->max_seg_size) >> 9,
+                                         card->host->max_seg_size) >> 9,
                                         (card->host->max_blk_count *
-                                        card->host->max_blk_size) >> 9);
+                                         card->host->max_blk_size) >> 9);
         blk_dev->part.offset = 0;
         blk_dev->part.size   = 0;
-        rt_snprintf(sname, sizeof(sname)-1, "sem_%s%d", card->host->name,0);
+        rt_snprintf(sname, sizeof(sname) - 1, "sem_%s%d", card->host->name, 0);
         blk_dev->part.lock = rt_sem_create(sname, 1, RT_IPC_FLAG_FIFO);
         /* register mmcsd device */
         blk_dev->dev.type  = RT_Device_Class_Block;
@@ -582,7 +583,7 @@ rt_int32_t mbr_device_probe(struct rt_mmcsd_card *card)
 #endif
         blk_dev->card = card;
 
-        blk_dev->geometry.bytes_per_sector = 1<<9;
+        blk_dev->geometry.bytes_per_sector = 1 << 9;
         blk_dev->geometry.block_size = card->card_blksize;
         blk_dev->geometry.sector_count =
             card->card_capacity * (1024 / 512);
@@ -590,7 +591,7 @@ rt_int32_t mbr_device_probe(struct rt_mmcsd_card *card)
         blk_dev->dev.user_data = blk_dev;
 
         rt_device_register(&(blk_dev->dev), card->host->name,
-            RT_DEVICE_FLAG_RDWR);
+                           RT_DEVICE_FLAG_RDWR);
         rt_list_insert_after(&blk_devices, &blk_dev->list);
         for (i = 0; i < RT_MMCSD_MAX_PARTITION; i++)
         {
@@ -601,40 +602,40 @@ rt_int32_t mbr_device_probe(struct rt_mmcsd_card *card)
                 break;
             }
             blk_dev->max_req_size = BLK_MIN((card->host->max_dma_segs *
-                                            card->host->max_seg_size) >> 9,
+                                             card->host->max_seg_size) >> 9,
                                             (card->host->max_blk_count *
-                                            card->host->max_blk_size) >> 9);
+                                             card->host->max_blk_size) >> 9);
 
             /* get the first partition */
             status = dfs_filesystem_get_partition(&blk_dev->part, sector, i);
             if (status == RT_EOK)
             {
-                rt_snprintf(dname, sizeof(dname)-1, "%s%d", card->host->name,i);
-                rt_snprintf(sname, sizeof(sname)-1, "sem_%s%d", card->host->name,i+1);
+                rt_snprintf(dname, sizeof(dname) - 1, "%s%d", card->host->name, i);
+                rt_snprintf(sname, sizeof(sname) - 1, "sem_%s%d", card->host->name, i + 1);
                 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
+#ifdef RT_USING_DEVICE_OPS
                 blk_dev->dev.ops  = &mmcsd_blk_ops;
-    #else
+#else
                 blk_dev->dev.init = rt_mmcsd_init;
                 blk_dev->dev.open = rt_mmcsd_open;
                 blk_dev->dev.close = rt_mmcsd_close;
                 blk_dev->dev.read = rt_mmcsd_read;
                 blk_dev->dev.write = rt_mmcsd_write;
                 blk_dev->dev.control = rt_mmcsd_control;
-    #endif
+#endif
                 blk_dev->card = card;
 
-                blk_dev->geometry.bytes_per_sector = 1<<9;
+                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;
 
                 blk_dev->dev.user_data = blk_dev;
 
                 rt_device_register(&(blk_dev->dev), dname,
-                    RT_DEVICE_FLAG_RDWR);
+                                   RT_DEVICE_FLAG_RDWR);
                 rt_list_insert_after(&blk_devices, &blk_dev->list);
             }
             else
@@ -644,20 +645,20 @@ rt_int32_t mbr_device_probe(struct rt_mmcsd_card *card)
                 break;
             }
 
-    #ifdef RT_USING_DFS_MNTTABLE
+#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));
             }
-    #endif
+#endif
         }
     }
     else
     {
         LOG_E("read mmcsd first sector failed");
-        err = -RT_ERROR;        
+        err = -RT_ERROR;
     }
 
     /* release sector buffer */
@@ -694,11 +695,11 @@ void rt_mmcsd_blk_remove(struct rt_mmcsd_card *card)
         if (blk_dev->card == card)
         {
             /* unmount file system */
-            const char * mounted_path = dfs_filesystem_get_mounted_path(&(blk_dev->dev));
+            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);
+                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);

components/drivers/sdio/mmc.c

@@ -46,17 +46,17 @@ 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_int32_t __off = 3 - ((start) / 32);
-        const rt_int32_t __shft = (start) & 31;
-        rt_uint32_t __res;
+    const rt_int32_t __size = size;
+    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;
 
-        __res = resp[__off] >> __shft;
-        if (__size + __shft > 32)
-            __res |= resp[__off-1] << ((32 - __shft) % 32);
+    __res = resp[__off] >> __shft;
+    if (__size + __shft > 32)
+        __res |= resp[__off - 1] << ((32 - __shft) % 32);
 
-        return __res & __mask;
+    return __res & __mask;
 }
 
 /*
@@ -64,50 +64,52 @@ rt_inline rt_uint32_t GET_BITS(rt_uint32_t *resp,
  */
 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.
-      * We also support eMMC v4.4 & v4.41.
-      */
-      csd->csd_structure = GET_BITS(resp, 126, 2);
-      if (csd->csd_structure == 0) {
+    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.
+    * We also support eMMC v4.4 & v4.41.
+    */
+    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);
-      csd->card_cmd_class = GET_BITS(resp, 84, 12);
-      csd->rd_blk_len = GET_BITS(resp, 80, 4);
-      csd->rd_blk_part = GET_BITS(resp, 79, 1);
-      csd->wr_blk_misalign = GET_BITS(resp, 78, 1);
-      csd->rd_blk_misalign = GET_BITS(resp, 77, 1);
-      csd->dsr_imp = GET_BITS(resp, 76, 1);
-      csd->c_size = GET_BITS(resp, 62, 12);
-      csd->c_size_mult = GET_BITS(resp, 47, 3);
-      csd->r2w_factor = GET_BITS(resp, 26, 3);
-      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;
-      card->max_data_rate = tran_unit[csd->tran_speed&0x07] * tran_value[(csd->tran_speed&0x78)>>3];
-      if (csd->wr_blk_len >= 9) {
+    }
+
+    csd->taac = GET_BITS(resp, 112, 8);
+    csd->nsac = GET_BITS(resp, 104, 8);
+    csd->tran_speed = GET_BITS(resp, 96, 8);
+    csd->card_cmd_class = GET_BITS(resp, 84, 12);
+    csd->rd_blk_len = GET_BITS(resp, 80, 4);
+    csd->rd_blk_part = GET_BITS(resp, 79, 1);
+    csd->wr_blk_misalign = GET_BITS(resp, 78, 1);
+    csd->rd_blk_misalign = GET_BITS(resp, 77, 1);
+    csd->dsr_imp = GET_BITS(resp, 76, 1);
+    csd->c_size = GET_BITS(resp, 62, 12);
+    csd->c_size_mult = GET_BITS(resp, 47, 3);
+    csd->r2w_factor = GET_BITS(resp, 26, 3);
+    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;
+    card->max_data_rate = tran_unit[csd->tran_speed & 0x07] * tran_value[(csd->tran_speed & 0x78) >> 3];
+    if (csd->wr_blk_len >= 9)
+    {
         a = GET_BITS(resp, 42, 5);
         b = GET_BITS(resp, 37, 5);
         card->erase_size = (a + 1) * (b + 1);
         card->erase_size <<= csd->wr_blk_len - 9;
-      }
+    }
 
-      return 0;
+    return 0;
 }
 
 /*
@@ -115,65 +117,66 @@ static rt_int32_t mmcsd_parse_csd(struct rt_mmcsd_card *card)
  */
 static int mmc_get_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t **new_ext_csd)
 {
-  void *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_csd, 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.
-  */
-  ext_csd = rt_malloc(512);
-  if (!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"
-  * value. For the cards tested, 300ms has proven enough. If necessary,
-  * this value can be increased if other problematic cards require this.
-  */
-  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;
+    void *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_csd, 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.
+    */
+    ext_csd = rt_malloc(512);
+    if (!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"
+    * value. For the cards tested, 300ms has proven enough. If necessary,
+    * this value can be increased if other problematic cards require this.
+    */
+    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;
 }
 
 /*
@@ -183,7 +186,7 @@ static int mmc_parse_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
 {
     rt_uint64_t card_capacity = 0;
     struct rt_mmcsd_host *host;
-    if(card == RT_NULL || ext_csd == RT_NULL)
+    if (card == RT_NULL || ext_csd == RT_NULL)
     {
         LOG_E("emmc parse ext csd fail, invaild args");
         return -1;
@@ -193,27 +196,27 @@ static int mmc_parse_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
     if (host->flags & MMCSD_SUP_HS200)
     {
         card->flags |=  CARD_FLAG_HS200;
-        card->hs_max_data_rate = 200000000; 
+        card->hs_max_data_rate = 200000000;
     }
     else if (host->flags & MMCSD_SUP_HIGHSPEED_DDR)
     {
         card->flags |=  CARD_FLAG_HIGHSPEED_DDR;
-        card->hs_max_data_rate = 52000000;    
+        card->hs_max_data_rate = 52000000;
     }
     else
     {
         card->flags |=  CARD_FLAG_HIGHSPEED;
-        card->hs_max_data_rate = 52000000;       
+        card->hs_max_data_rate = 52000000;
     }
 
-  card_capacity = *((rt_uint32_t *)&ext_csd[EXT_CSD_SEC_CNT]);
-  card->card_sec_cnt = card_capacity;
-  card_capacity *= card->card_blksize;
-  card_capacity >>= 10; /* unit:KB */
-  card->card_capacity = card_capacity;
-  LOG_I("emmc card capacity %d KB, card sec count:%d.", card->card_capacity, card->card_sec_cnt);
+    card_capacity = *((rt_uint32_t *)&ext_csd[EXT_CSD_SEC_CNT]);
+    card->card_sec_cnt = card_capacity;
+    card_capacity *= card->card_blksize;
+    card_capacity >>= 10; /* unit:KB */
+    card->card_capacity = card_capacity;
+    LOG_I("emmc card capacity %d KB, card sec count:%d.", card->card_capacity, card->card_sec_cnt);
 
-  return 0;
+    return 0;
 }
 
 /**
@@ -228,72 +231,73 @@ static int mmc_parse_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
 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};
+    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_R1B | CMD_AC;
+    cmd.cmd_code = SWITCH;
+    cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
+              (index << 16) | (value << 8) | set;
+    cmd.flags = RESP_R1B | CMD_AC;
 
-  err = mmcsd_send_cmd(host, &cmd, 3);
-  if (err)
-    return err;
+    err = mmcsd_send_cmd(host, &cmd, 3);
+    if (err)
+        return err;
 
-  return 0;
+    return 0;
 }
 
 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;
+    rt_uint8_t *bw_ext_csd;
+    int err;
 
-  if (bus_width == MMCSD_BUS_WIDTH_1)
-    return 0;
+    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;
+    }
 
-  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]) &&
-          (ext_csd[EXT_CSD_REV] == bw_ext_csd[EXT_CSD_REV]) &&
-          (ext_csd[EXT_CSD_STRUCTURE] == bw_ext_csd[EXT_CSD_STRUCTURE]) &&
-          (ext_csd[EXT_CSD_CARD_TYPE] == bw_ext_csd[EXT_CSD_CARD_TYPE]) &&
-          (ext_csd[EXT_CSD_S_A_TIMEOUT] == bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) &&
-          (ext_csd[EXT_CSD_HC_WP_GRP_SIZE] == bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) &&
-          (ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT] == bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) &&
-          (ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] == bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&
-          (ext_csd[EXT_CSD_SEC_TRIM_MULT] == bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) &&
-          (ext_csd[EXT_CSD_SEC_ERASE_MULT] == bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) &&
-          (ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT] == bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) &&
-          (ext_csd[EXT_CSD_TRIM_MULT] == bw_ext_csd[EXT_CSD_TRIM_MULT]) &&
-          (ext_csd[EXT_CSD_SEC_CNT + 0] == bw_ext_csd[EXT_CSD_SEC_CNT + 0]) &&
-          (ext_csd[EXT_CSD_SEC_CNT + 1] == bw_ext_csd[EXT_CSD_SEC_CNT + 1]) &&
-          (ext_csd[EXT_CSD_SEC_CNT + 2] == bw_ext_csd[EXT_CSD_SEC_CNT + 2]) &&
-          (ext_csd[EXT_CSD_SEC_CNT + 3] == bw_ext_csd[EXT_CSD_SEC_CNT + 3]) &&
-          (ext_csd[EXT_CSD_PWR_CL_52_195] == bw_ext_csd[EXT_CSD_PWR_CL_52_195]) &&
-          (ext_csd[EXT_CSD_PWR_CL_26_195] == bw_ext_csd[EXT_CSD_PWR_CL_26_195]) &&
-          (ext_csd[EXT_CSD_PWR_CL_52_360] == bw_ext_csd[EXT_CSD_PWR_CL_52_360]) &&
-          (ext_csd[EXT_CSD_PWR_CL_26_360] == bw_ext_csd[EXT_CSD_PWR_CL_26_360]) &&
-          (ext_csd[EXT_CSD_PWR_CL_200_195] == bw_ext_csd[EXT_CSD_PWR_CL_200_195]) &&
-          (ext_csd[EXT_CSD_PWR_CL_200_360] == bw_ext_csd[EXT_CSD_PWR_CL_200_360]) &&
-          (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;
+    /* 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]) &&
+            (ext_csd[EXT_CSD_REV] == bw_ext_csd[EXT_CSD_REV]) &&
+            (ext_csd[EXT_CSD_STRUCTURE] == bw_ext_csd[EXT_CSD_STRUCTURE]) &&
+            (ext_csd[EXT_CSD_CARD_TYPE] == bw_ext_csd[EXT_CSD_CARD_TYPE]) &&
+            (ext_csd[EXT_CSD_S_A_TIMEOUT] == bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) &&
+            (ext_csd[EXT_CSD_HC_WP_GRP_SIZE] == bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) &&
+            (ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT] == bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) &&
+            (ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] == bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&
+            (ext_csd[EXT_CSD_SEC_TRIM_MULT] == bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) &&
+            (ext_csd[EXT_CSD_SEC_ERASE_MULT] == bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) &&
+            (ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT] == bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) &&
+            (ext_csd[EXT_CSD_TRIM_MULT] == bw_ext_csd[EXT_CSD_TRIM_MULT]) &&
+            (ext_csd[EXT_CSD_SEC_CNT + 0] == bw_ext_csd[EXT_CSD_SEC_CNT + 0]) &&
+            (ext_csd[EXT_CSD_SEC_CNT + 1] == bw_ext_csd[EXT_CSD_SEC_CNT + 1]) &&
+            (ext_csd[EXT_CSD_SEC_CNT + 2] == bw_ext_csd[EXT_CSD_SEC_CNT + 2]) &&
+            (ext_csd[EXT_CSD_SEC_CNT + 3] == bw_ext_csd[EXT_CSD_SEC_CNT + 3]) &&
+            (ext_csd[EXT_CSD_PWR_CL_52_195] == bw_ext_csd[EXT_CSD_PWR_CL_52_195]) &&
+            (ext_csd[EXT_CSD_PWR_CL_26_195] == bw_ext_csd[EXT_CSD_PWR_CL_26_195]) &&
+            (ext_csd[EXT_CSD_PWR_CL_52_360] == bw_ext_csd[EXT_CSD_PWR_CL_52_360]) &&
+            (ext_csd[EXT_CSD_PWR_CL_26_360] == bw_ext_csd[EXT_CSD_PWR_CL_26_360]) &&
+            (ext_csd[EXT_CSD_PWR_CL_200_195] == bw_ext_csd[EXT_CSD_PWR_CL_200_195]) &&
+            (ext_csd[EXT_CSD_PWR_CL_200_360] == bw_ext_csd[EXT_CSD_PWR_CL_200_360]) &&
+            (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;
+    rt_free(bw_ext_csd);
+    return err;
 }
 
 /*
@@ -319,8 +323,8 @@ static int mmc_select_bus_width(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
     unsigned idx, bus_width = 0;
     int err = 0, ddr = 0;
 
-  if (GET_BITS(card->resp_csd, 122, 4) < 4)
-     return 0;
+    if (GET_BITS(card->resp_csd, 122, 4) < 4)
+        return 0;
 
     if (card->flags & CARD_FLAG_HIGHSPEED_DDR)
     {
@@ -332,7 +336,7 @@ static int mmc_select_bus_width(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
     * the supported bus width or compare the ext csd values of current
     * bus width and ext csd values of 1 bit mode read earlier.
     */
-    for (idx = 0; idx < sizeof(bus_widths)/sizeof(rt_uint32_t); idx++)
+    for (idx = 0; idx < sizeof(bus_widths) / sizeof(rt_uint32_t); idx++)
     {
         /*
         * Host is capable of 8bit transfer, then switch
@@ -350,12 +354,12 @@ static int mmc_select_bus_width(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
         }
 
         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
-                        EXT_CSD_BUS_WIDTH,
-                        ext_csd_bits[idx][0]);
+                         EXT_CSD_BUS_WIDTH,
+                         ext_csd_bits[idx][0]);
 
         if (err)
             continue;
-        
+
         mmcsd_set_bus_width(host, bus_width);
         err = mmc_compare_ext_csds(card, ext_csd, bus_width);
         if (!err)
@@ -364,7 +368,7 @@ static int mmc_select_bus_width(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
         }
         else
         {
-            switch(ext_csd_bits[idx][0])
+            switch (ext_csd_bits[idx][0])
             {
             case 0:
                 LOG_E("switch to bus width 1 bit failed!");
@@ -376,7 +380,7 @@ static int mmc_select_bus_width(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
                 LOG_E("switch to bus width 8 bit failed!");
                 break;
             default:
-              break;
+                break;
             }
         }
     }
@@ -384,8 +388,8 @@ static int mmc_select_bus_width(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
     if (!err && ddr)
     {
         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
-                        EXT_CSD_BUS_WIDTH,
-                        ext_csd_bits[idx][1]);
+                         EXT_CSD_BUS_WIDTH,
+                         ext_csd_bits[idx][1]);
     }
 
     if (!err)
@@ -394,12 +398,12 @@ static int mmc_select_bus_width(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd)
         {
 
             err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
-                            EXT_CSD_HS_TIMING,
-                            1);      
+                             EXT_CSD_HS_TIMING,
+                             1);
         }
     }
 
-  return err;
+    return err;
 }
 rt_err_t mmc_send_op_cond(struct rt_mmcsd_host *host,
                           rt_uint32_t ocr, rt_uint32_t *rocr)
@@ -414,94 +418,98 @@ rt_err_t mmc_send_op_cond(struct rt_mmcsd_host *host,
     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;
+    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;
+        /* 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))
-          break;
-      } else {
-        if (cmd.resp[0] & CARD_BUSY)
-          break;
-      }
+        /* otherwise wait until reset completes */
+        if (controller_is_spi(host))
+        {
+            if (!(cmd.resp[0] & R1_SPI_IDLE))
+                break;
+        }
+        else
+        {
+            if (cmd.resp[0] & CARD_BUSY)
+                break;
+        }
 
-      err = -RT_ETIMEOUT;
+        err = -RT_ETIMEOUT;
 
-      mmcsd_delay_ms(10); //delay 10ms
+        mmcsd_delay_ms(10); //delay 10ms
     }
 
-  if (rocr && !controller_is_spi(host))
-    *rocr = cmd.resp[0];
+    if (rocr && !controller_is_spi(host))
+        *rocr = cmd.resp[0];
 
-  return err;
+    return err;
 }
 
 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_err_t err;
+    struct rt_mmcsd_cmd cmd;
 
-  rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_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;
+    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;
+    err = mmcsd_send_cmd(host, &cmd, 3);
+    if (err)
+        return err;
 
-  return 0;
+    return 0;
 }
 
 static int mmc_select_hs200(struct rt_mmcsd_card *card)
 {
-  int ret;
+    int ret;
 
-  ret = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+    ret = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                      EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS200);
-  if (ret)
-    return ret;
+    if (ret)
+        return ret;
 
-  mmcsd_set_timing(card->host, MMCSD_TIMING_MMC_HS200);
-  mmcsd_set_clock(card->host, 200000000);
+    mmcsd_set_timing(card->host, MMCSD_TIMING_MMC_HS200);
+    mmcsd_set_clock(card->host, 200000000);
 
-  ret = mmcsd_excute_tuning(card);
+    ret = mmcsd_excute_tuning(card);
 
-  return ret;
+    return ret;
 }
 
 static int mmc_select_timing(struct rt_mmcsd_card *card)
 {
-  int ret = 0;
-
-  if (card->flags & CARD_FLAG_HS200)
-  {
-    ret = mmc_select_hs200(card);
-  }
-  else if (card->flags & CARD_FLAG_HIGHSPEED_DDR)
-  {
-    mmcsd_set_timing(card->host, MMCSD_TIMING_MMC_DDR52);
-    mmcsd_set_clock(card->host, card->hs_max_data_rate);
-  }
-  else
-  {
-    mmcsd_set_timing(card->host, MMCSD_TIMING_UHS_SDR50);
-    mmcsd_set_clock(card->host, card->hs_max_data_rate);
-  }
-
-  return ret;
+    int ret = 0;
+
+    if (card->flags & CARD_FLAG_HS200)
+    {
+        ret = mmc_select_hs200(card);
+    }
+    else if (card->flags & CARD_FLAG_HIGHSPEED_DDR)
+    {
+        mmcsd_set_timing(card->host, MMCSD_TIMING_MMC_DDR52);
+        mmcsd_set_clock(card->host, card->hs_max_data_rate);
+    }
+    else
+    {
+        mmcsd_set_timing(card->host, MMCSD_TIMING_UHS_SDR50);
+        mmcsd_set_clock(card->host, card->hs_max_data_rate);
+    }
+
+    return ret;
 }
 
 static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
-                                     rt_uint32_t           ocr)
+                                      rt_uint32_t           ocr)
 {
     rt_int32_t err;
     rt_uint32_t resp[4];
@@ -515,7 +523,7 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
     /* The extra bit indicates that we support high capacity */
     err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
     if (err)
-      goto err;
+        goto err;
 
     if (controller_is_spi(host))
     {
@@ -578,17 +586,17 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host,
 
     err = mmc_get_ext_csd(card, &ext_csd);
     if (err)
-      goto err1;
+        goto err1;
     err = mmc_parse_ext_csd(card, ext_csd);
     if (err)
-      goto err1;
+        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;
     * ocr register has bit 30 set for sector addressing.
     */
-    if (!(card->flags & CARD_FLAG_SDHC) && (rocr & (1<<30)))
+    if (!(card->flags & CARD_FLAG_SDHC) && (rocr & (1 << 30)))
         card->flags |= CARD_FLAG_SDHC;
 
     /* set bus speed */

components/drivers/sdio/mmcsd_core.c

@@ -59,7 +59,8 @@ void mmcsd_req_complete(struct rt_mmcsd_host *host)
 
 void mmcsd_send_request(struct rt_mmcsd_host *host, struct rt_mmcsd_req *req)
 {
-    do {
+    do
+    {
         req->cmd->retries--;
         req->cmd->err = 0;
         req->cmd->mrq = req;
@@ -79,7 +80,8 @@ void mmcsd_send_request(struct rt_mmcsd_host *host, struct rt_mmcsd_req *req)
 
         rt_sem_take(&host->sem_ack, RT_WAITING_FOREVER);
 
-    } while(req->cmd->err && (req->cmd->retries > 0));
+    }
+    while (req->cmd->err && (req->cmd->retries > 0));
 
 
 }
@@ -243,7 +245,7 @@ rt_int32_t mmcsd_get_cid(struct rt_mmcsd_host *host, rt_uint32_t *cid)
         return -RT_ERROR;
     }
 
-    for (i = 0;i < 4;i++)
+    for (i = 0; i < 4; i++)
         cid[i] = buf[i];
     rt_free(buf);
 
@@ -274,7 +276,7 @@ rt_int32_t mmcsd_get_csd(struct rt_mmcsd_card *card, rt_uint32_t *csd)
         return 0;
     }
 
-    buf = (rt_uint32_t*)rt_malloc(16);
+    buf = (rt_uint32_t *)rt_malloc(16);
     if (!buf)
     {
         LOG_E("allocate memory failed!");
@@ -320,7 +322,7 @@ rt_int32_t mmcsd_get_csd(struct rt_mmcsd_card *card, rt_uint32_t *csd)
         return -RT_ERROR;
     }
 
-    for (i = 0;i < 4;i++)
+    for (i = 0; i < 4; i++)
         csd[i] = buf[i];
     rt_free(buf);
 
@@ -388,10 +390,10 @@ rt_inline void mmcsd_set_iocfg(struct rt_mmcsd_host *host)
     struct rt_mmcsd_io_cfg *io_cfg = &host->io_cfg;
 
     mmcsd_dbg("clock %uHz busmode %u powermode %u cs %u Vdd %u "
-        "width %u \n",
-         io_cfg->clock, io_cfg->bus_mode,
-         io_cfg->power_mode, io_cfg->chip_select, io_cfg->vdd,
-         io_cfg->bus_width);
+              "width %u \n",
+              io_cfg->clock, io_cfg->bus_mode,
+              io_cfg->power_mode, io_cfg->chip_select, io_cfg->vdd,
+              io_cfg->bus_width);
 
     host->ops->set_iocfg(host, io_cfg);
 }
@@ -441,7 +443,7 @@ void mmcsd_set_bus_width(struct rt_mmcsd_host *host, rt_uint32_t width)
 void mmcsd_set_timing(struct rt_mmcsd_host *host, rt_uint32_t timing)
 {
     host->io_cfg.timing = timing;
-    mmcsd_set_iocfg(host);   
+    mmcsd_set_iocfg(host);
 }
 
 void mmcsd_set_data_timeout(struct rt_mmcsd_data       *data,
@@ -481,7 +483,7 @@ void mmcsd_set_data_timeout(struct rt_mmcsd_data       *data,
 
         timeout_us = data->timeout_ns / 1000;
         timeout_us += data->timeout_clks * 1000 /
-            (card->host->io_cfg.clock / 1000);
+                      (card->host->io_cfg.clock / 1000);
 
         if (data->flags & DATA_DIR_WRITE)
             /*
@@ -602,7 +604,7 @@ int mmcsd_wait_cd_changed(rt_int32_t timeout)
     struct rt_mmcsd_host *host;
     if (rt_mb_recv(&mmcsd_hotpluge_mb, (rt_ubase_t *)&host, timeout) == RT_EOK)
     {
-        if(host->card == RT_NULL)
+        if (host->card == RT_NULL)
         {
             return MMCSD_HOST_UNPLUGED;
         }
@@ -699,7 +701,7 @@ void mmcsd_detect(void *param)
 void mmcsd_host_init(struct rt_mmcsd_host *host)
 {
     rt_memset(host, 0, sizeof(struct rt_mmcsd_host));
-    strncpy(host->name, "sd", sizeof(host->name)-1);
+    strncpy(host->name, "sd", sizeof(host->name) - 1);
     host->max_seg_size = 65535;
     host->max_dma_segs = 1;
     host->max_blk_size = 512;
@@ -756,16 +758,16 @@ int rt_mmcsd_core_init(void)
     /* initialize detect SD cart thread */
     /* initialize mailbox and create detect SD card thread */
     ret = rt_mb_init(&mmcsd_detect_mb, "mmcsdmb",
-        &mmcsd_detect_mb_pool[0], sizeof(mmcsd_detect_mb_pool) / sizeof(mmcsd_detect_mb_pool[0]),
-        RT_IPC_FLAG_FIFO);
+                     &mmcsd_detect_mb_pool[0], sizeof(mmcsd_detect_mb_pool) / sizeof(mmcsd_detect_mb_pool[0]),
+                     RT_IPC_FLAG_FIFO);
     RT_ASSERT(ret == RT_EOK);
 
-   ret = rt_mb_init(&mmcsd_hotpluge_mb, "mmcsdhotplugmb",
-        &mmcsd_hotpluge_mb_pool[0], sizeof(mmcsd_hotpluge_mb_pool) / sizeof(mmcsd_hotpluge_mb_pool[0]),
-        RT_IPC_FLAG_FIFO);
+    ret = rt_mb_init(&mmcsd_hotpluge_mb, "mmcsdhotplugmb",
+                     &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,
-                 &mmcsd_stack[0], RT_MMCSD_STACK_SIZE, RT_MMCSD_THREAD_PREORITY, 20);
+    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)
     {
         rt_thread_startup(&mmcsd_detect_thread);