diff --git a/components/drivers/include/drivers/mmcsd_core.h b/components/drivers/include/drivers/mmcsd_core.h index 3b4d5c83215a7f98e9ca2fd22d7c22198a88b3a8..d0b5297677a5eb5b5af3002ad525a1b15c1fee97 100644 --- a/components/drivers/include/drivers/mmcsd_core.h +++ b/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 diff --git a/components/drivers/include/drivers/mmcsd_host.h b/components/drivers/include/drivers/mmcsd_host.h index e3bd5d71870e02afbbad50af1b292b30142d7b5f..8fb39c9aceb139c5eaabdb05d2664649a9c6cbbf 100644 --- a/components/drivers/include/drivers/mmcsd_host.h +++ b/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)); } } diff --git a/components/drivers/sdio/block_dev.c b/components/drivers/sdio/block_dev.c index 911d46b963f0f9674b6cb20d734e359c6b4331a4..70e41cdd126e2980c67d659859991829d28238e0 100644 --- a/components/drivers/sdio/block_dev.c +++ b/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); diff --git a/components/drivers/sdio/mmc.c b/components/drivers/sdio/mmc.c index c9e227327e01b12ad6bbcbd80a0e6f7832ceeec0..e2ac5cb1dc9074e4813d872f8c2d838523bc555f 100644 --- a/components/drivers/sdio/mmc.c +++ b/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 */ diff --git a/components/drivers/sdio/mmcsd_core.c b/components/drivers/sdio/mmcsd_core.c index c1d95741aeb211a1358c10b439d16ce956d64ddb..edcf291f4cad63876eb4512b8482eb4170aecdbd 100644 --- a/components/drivers/sdio/mmcsd_core.c +++ b/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);