diff --git a/bsp/phytium/libraries/drivers/drv_sdif_msg.c b/bsp/phytium/libraries/drivers/drv_sdif_msg.c index ae85b9e24572..e43eb0d0da8a 100644 --- a/bsp/phytium/libraries/drivers/drv_sdif_msg.c +++ b/bsp/phytium/libraries/drivers/drv_sdif_msg.c @@ -52,7 +52,7 @@ #define SDIF_DMA_ALIGN SDIF_DMA_BLK_SZ /* preserve pointer to host instance */ -static struct rt_mmcsd_host *mmc_host[FSDIF_NUM] = {RT_NULL}; +static struct rt_mmcsd_host *mmc_host[FSDIF_NUM] = { RT_NULL }; /**************************** Type Definitions *******************************/ typedef struct { @@ -63,10 +63,10 @@ typedef struct rt_size_t rw_desc_num; struct rt_event event; #define SDIF_EVENT_CARD_DETECTED (1 << 0) -#define SDIF_EVENT_COMMAND_DONE (1 << 1) -#define SDIF_EVENT_DATA_DONE (1 << 2) -#define SDIF_EVENT_ERROR_OCCUR (1 << 3) -#define SDIF_EVENT_SDIO_IRQ (1 << 4) +#define SDIF_EVENT_COMMAND_DONE (1 << 1) +#define SDIF_EVENT_DATA_DONE (1 << 2) +#define SDIF_EVENT_ERROR_OCCUR (1 << 3) +#define SDIF_EVENT_SDIO_IRQ (1 << 4) void *aligned_buffer; uintptr_t aligned_buffer_dma; rt_size_t aligned_buffer_size; @@ -99,7 +99,7 @@ rt_int32_t sdif_card_inserted(rt_uint32_t id) return 0; } -static void sdif_card_detect_callback(FSdifMsgCtrl *const instance_p, void *args, void *data) +static void sdif_card_detect_callback(FSdifMsgCtrl * const instance_p, void *args, void *data) { struct rt_mmcsd_host *host = (struct rt_mmcsd_host *)args; sdif_info_t *host_info = (sdif_info_t *)host->private_data; @@ -108,7 +108,7 @@ static void sdif_card_detect_callback(FSdifMsgCtrl *const instance_p, void *args sdif_change(host_info->sdif.config.instance_id); } -static void sdif_command_done_callback(FSdifMsgCtrl *const instance_p, void *args, void *data) +static void sdif_command_done_callback(FSdifMsgCtrl * const instance_p, void *args, void *data) { struct rt_mmcsd_host *host = (struct rt_mmcsd_host *)args; sdif_info_t *host_info = (sdif_info_t *)host->private_data; @@ -116,7 +116,7 @@ static void sdif_command_done_callback(FSdifMsgCtrl *const instance_p, void *arg rt_event_send(&host_info->event, SDIF_EVENT_COMMAND_DONE); } -static void sdif_data_done_callback(FSdifMsgCtrl *const instance_p, void *args, void *data) +static void sdif_data_done_callback(FSdifMsgCtrl * const instance_p, void *args, void *data) { struct rt_mmcsd_host *host = (struct rt_mmcsd_host *)args; sdif_info_t *host_info = (sdif_info_t *)host->private_data; @@ -124,7 +124,7 @@ static void sdif_data_done_callback(FSdifMsgCtrl *const instance_p, void *args, rt_event_send(&host_info->event, SDIF_EVENT_DATA_DONE); } -static void sdif_error_occur_callback(FSdifMsgCtrl *const instance_p, void *args, void *data) +static void sdif_error_occur_callback(FSdifMsgCtrl * const instance_p, void *args, void *data) { struct rt_mmcsd_host *host = (struct rt_mmcsd_host *)args; sdif_info_t *host_info = (sdif_info_t *)host->private_data; @@ -140,19 +140,29 @@ static void sdif_error_occur_callback(FSdifMsgCtrl *const instance_p, void *args LOG_E("Status: 0x%x, dmac status: 0x%x.", status, dmac_status); if (status & FSDIF_INT_RE_BIT) + { LOG_E("[CMD_FAIL]Response err. 0x%x", FSDIF_INT_RE_BIT); + } if (status & FSDIF_INT_RTO_BIT) + { LOG_E("[CMD_FAIL]Response timeout. 0x%x", FSDIF_INT_RTO_BIT); + } if (dmac_status & FSDIF_DMAC_STATUS_DU) + { LOG_E("[DATA_FAIL]Descriptor un-readable. 0x%x", FSDIF_DMAC_STATUS_DU); + } if (status & FSDIF_INT_DCRC_BIT) + { LOG_E("[DATA_FAIL]Data CRC error. 0x%x", FSDIF_INT_DCRC_BIT); + } if (status & FSDIF_INT_RCRC_BIT) + { LOG_E("[DATA_FAIL]Data CRC error. 0x%x", FSDIF_INT_RCRC_BIT); + } rt_event_send(&host_info->event, SDIF_EVENT_ERROR_OCCUR); } @@ -381,79 +391,79 @@ static uint32_t sdif_prepare_sd_command_flags(struct rt_mmcsd_req *req) uint32_t argument = input_cmd->arg; uint32_t flags = 0U; - switch(opcode) + switch (opcode) { - case GO_IDLE_STATE: /* MMC_GO_IDLE_STATE 0 */ - flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_NONE | FSDIF_MMC_CMD_BC; - break; - case SEND_EXT_CSD: /* SD_SEND_IF_COND 8 */ - flags |= FSDIF_MMC_RSP_SPI_R7 | FSDIF_MMC_RSP_R7 | FSDIF_MMC_CMD_BCR; - break; - case SD_APP_OP_COND: /* SD_APP_OP_COND 41 */ - flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R3 | FSDIF_MMC_CMD_BCR; - break; - case VOLTAGE_SWITCH: /* SD_SWITCH_VOLTAGE 11 */ - flags |= FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; - break; - case ALL_SEND_CID: /* MMC_ALL_SEND_CID 2 */ - flags |= FSDIF_MMC_RSP_R2 | FSDIF_MMC_CMD_AC; - break; - case SET_RELATIVE_ADDR: /* SD_SEND_RELATIVE_ADDR 3 */ - flags |= FSDIF_MMC_RSP_R6 | FSDIF_MMC_CMD_BCR; - break; - case SEND_CSD: /* MMC_SEND_CSD 9 */ - flags |= FSDIF_MMC_RSP_R2 | FSDIF_MMC_CMD_AC; - break; - case SELECT_CARD: /* MMC_SELECT_CARD 7 */ - if (argument) - { - flags |= FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; - } - else - { - flags |= FSDIF_MMC_RSP_NONE | FSDIF_MMC_CMD_AC; - } - break; - case APP_CMD: /* MMC_APP_CMD 55 */ - if (argument) - { - flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; - } - else - { - flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_BCR; - } - break; - case SD_APP_SEND_SCR: /* SD_APP_SEND_SCR 51 */ - flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; - break; - case SD_APP_SET_BUS_WIDTH: /* SD_APP_SET_BUS_WIDTH 6 */ + case GO_IDLE_STATE: /* MMC_GO_IDLE_STATE 0 */ + flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_NONE | FSDIF_MMC_CMD_BC; + break; + case SEND_EXT_CSD: /* SD_SEND_IF_COND 8 */ + flags |= FSDIF_MMC_RSP_SPI_R7 | FSDIF_MMC_RSP_R7 | FSDIF_MMC_CMD_BCR; + break; + case SD_APP_OP_COND: /* SD_APP_OP_COND 41 */ + flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R3 | FSDIF_MMC_CMD_BCR; + break; + case VOLTAGE_SWITCH: /* SD_SWITCH_VOLTAGE 11 */ + flags |= FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; + break; + case ALL_SEND_CID: /* MMC_ALL_SEND_CID 2 */ + flags |= FSDIF_MMC_RSP_R2 | FSDIF_MMC_CMD_AC; + break; + case SET_RELATIVE_ADDR: /* SD_SEND_RELATIVE_ADDR 3 */ + flags |= FSDIF_MMC_RSP_R6 | FSDIF_MMC_CMD_BCR; + break; + case SEND_CSD: /* MMC_SEND_CSD 9 */ + flags |= FSDIF_MMC_RSP_R2 | FSDIF_MMC_CMD_AC; + break; + case SELECT_CARD: /* MMC_SELECT_CARD 7 */ + if (argument) + { flags |= FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; - break; - case SEND_STATUS: /* SD_APP_SD_STATUS 13 */ - flags |= FSDIF_MMC_RSP_SPI_R2 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; - break; - case SET_BLOCKLEN : /* MMC_SET_BLOCKLEN 16 */ + } + else + { + flags |= FSDIF_MMC_RSP_NONE | FSDIF_MMC_CMD_AC; + } + break; + case APP_CMD: /* MMC_APP_CMD 55 */ + if (argument) + { flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; - break; - case SET_BLOCK_COUNT: /* MMC_SET_BLOCK_COUNT 23 */ - flags |= FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; - break; - case WRITE_BLOCK: /* MMC_WRITE_BLOCK 24 */ - flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; - break; - case WRITE_MULTIPLE_BLOCK: /* MMC_WRITE_MULTIPLE_BLOCK 25 */ - flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; - break; - case READ_SINGLE_BLOCK: /* MMC_READ_SINGLE_BLOCK 17 */ - flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; - break; - case READ_MULTIPLE_BLOCK: /* MMC_READ_MULTIPLE_BLOCK 18 */ - flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; - break; - default: - LOG_E("unhandled command-%d !!!", opcode); - break; + } + else + { + flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_BCR; + } + break; + case SD_APP_SEND_SCR: /* SD_APP_SEND_SCR 51 */ + flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; + break; + case SD_APP_SET_BUS_WIDTH: /* SD_APP_SET_BUS_WIDTH 6 */ + flags |= FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; + break; + case SEND_STATUS: /* SD_APP_SD_STATUS 13 */ + flags |= FSDIF_MMC_RSP_SPI_R2 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; + break; + case SET_BLOCKLEN: /* MMC_SET_BLOCKLEN 16 */ + flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; + break; + case SET_BLOCK_COUNT: /* MMC_SET_BLOCK_COUNT 23 */ + flags |= FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; + break; + case WRITE_BLOCK: /* MMC_WRITE_BLOCK 24 */ + flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; + break; + case WRITE_MULTIPLE_BLOCK: /* MMC_WRITE_MULTIPLE_BLOCK 25 */ + flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; + break; + case READ_SINGLE_BLOCK: /* MMC_READ_SINGLE_BLOCK 17 */ + flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; + break; + case READ_MULTIPLE_BLOCK: /* MMC_READ_MULTIPLE_BLOCK 18 */ + flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; + break; + default: + LOG_E("unhandled command-%d !!!", opcode); + break; } return flags; @@ -466,63 +476,63 @@ static uint32_t sdif_prepar_emmc_command_flags(struct rt_mmcsd_req *req) uint32_t argument = input_cmd->arg; uint32_t flags = 0U; - switch(opcode) + switch (opcode) { - case GO_IDLE_STATE: /* MMC_GO_IDLE_STATE 0 */ - flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_NONE | FSDIF_MMC_CMD_BC; - break; - case SEND_OP_COND: /* MMC_SEND_OP_COND 1 */ - flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R3 | FSDIF_MMC_CMD_BCR; - break; - case ALL_SEND_CID: /* MMC_ALL_SEND_CID 2 */ - flags |= FSDIF_MMC_RSP_R2 | FSDIF_MMC_CMD_AC; - break; - case SET_RELATIVE_ADDR: /* MMC_SET_RELATIVE_ADDR 3 */ - flags |= FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; - break; - case SEND_CSD: /* MMC_SEND_CSD 9 */ - flags |= FSDIF_MMC_RSP_R2 | FSDIF_MMC_CMD_AC; - break; - case SELECT_CARD: /* MMC_SELECT_CARD 7 */ - if (argument) - { - flags |= FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; - } - else - { - flags |= FSDIF_MMC_RSP_NONE | FSDIF_MMC_CMD_AC; - } - break; - case SEND_EXT_CSD: /* MMC_SEND_EXT_CSD 8 */ - flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; - break; - case SWITCH: /* MMC_SWITCH 6 */ - flags |= FSDIF_MMC_CMD_AC | FSDIF_MMC_RSP_SPI_R1B | FSDIF_MMC_RSP_R1B; - break; - case SEND_STATUS: /* MMC_SEND_STATUS 13 */ - flags |= FSDIF_MMC_RSP_SPI_R2 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; - break; - case SET_BLOCKLEN: /* MMC_SET_BLOCKLEN 16 */ - flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; - break; - case SET_BLOCK_COUNT: /* MMC_SET_BLOCK_COUNT 23 */ + case GO_IDLE_STATE: /* MMC_GO_IDLE_STATE 0 */ + flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_NONE | FSDIF_MMC_CMD_BC; + break; + case SEND_OP_COND: /* MMC_SEND_OP_COND 1 */ + flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R3 | FSDIF_MMC_CMD_BCR; + break; + case ALL_SEND_CID: /* MMC_ALL_SEND_CID 2 */ + flags |= FSDIF_MMC_RSP_R2 | FSDIF_MMC_CMD_AC; + break; + case SET_RELATIVE_ADDR: /* MMC_SET_RELATIVE_ADDR 3 */ + flags |= FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; + break; + case SEND_CSD: /* MMC_SEND_CSD 9 */ + flags |= FSDIF_MMC_RSP_R2 | FSDIF_MMC_CMD_AC; + break; + case SELECT_CARD: /* MMC_SELECT_CARD 7 */ + if (argument) + { flags |= FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; - break; - case WRITE_BLOCK: /* MMC_WRITE_BLOCK 24 */ - flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; - break; - case WRITE_MULTIPLE_BLOCK: /* MMC_WRITE_MULTIPLE_BLOCK 25 */ - flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; - break; - case READ_SINGLE_BLOCK: /* MMC_READ_SINGLE_BLOCK 17 */ - flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; - break; - case READ_MULTIPLE_BLOCK: /* MMC_READ_MULTIPLE_BLOCK 18 */ - flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; - break; - default: - LOG_E("unhandled command-%d !!!", opcode); - break; + } + else + { + flags |= FSDIF_MMC_RSP_NONE | FSDIF_MMC_CMD_AC; + } + break; + case SEND_EXT_CSD: /* MMC_SEND_EXT_CSD 8 */ + flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; + break; + case MMC_SWITCH: /* MMC_SWITCH 6 */ + flags |= FSDIF_MMC_CMD_AC | FSDIF_MMC_RSP_SPI_R1B | FSDIF_MMC_RSP_R1B; + break; + case SEND_STATUS: /* MMC_SEND_STATUS 13 */ + flags |= FSDIF_MMC_RSP_SPI_R2 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; + break; + case SET_BLOCKLEN: /* MMC_SET_BLOCKLEN 16 */ + flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; + break; + case SET_BLOCK_COUNT: /* MMC_SET_BLOCK_COUNT 23 */ + flags |= FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_AC; + break; + case WRITE_BLOCK: /* MMC_WRITE_BLOCK 24 */ + flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; + break; + case WRITE_MULTIPLE_BLOCK: /* MMC_WRITE_MULTIPLE_BLOCK 25 */ + flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; + break; + case READ_SINGLE_BLOCK: /* MMC_READ_SINGLE_BLOCK 17 */ + flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; + break; + case READ_MULTIPLE_BLOCK: /* MMC_READ_MULTIPLE_BLOCK 18 */ + flags |= FSDIF_MMC_RSP_SPI_R1 | FSDIF_MMC_RSP_R1 | FSDIF_MMC_CMD_ADTC; + break; + default: + LOG_E("unhandled command-%d !!!", opcode); + break; } return flags; @@ -620,7 +630,7 @@ static void sdif_set_iocfg(struct rt_mmcsd_host *host, struct rt_mmcsd_io_cfg *i /* ClockData set */ if (0 != io_cfg->clock) { - target_ios.ios_clock = io_cfg->clock; + target_ios.ios_clock = io_cfg->clock; } /* Timing set */ @@ -643,23 +653,23 @@ static void sdif_set_iocfg(struct rt_mmcsd_host *host, struct rt_mmcsd_io_cfg *i { switch (io_cfg->timing) { - case MMCSD_TIMING_UHS_SDR12: - target_ios.ios_timing = FSDIF_MMC_TIMING_UHS_SDR12; - break; - case MMCSD_TIMING_UHS_SDR25: - target_ios.ios_timing = FSDIF_MMC_TIMING_UHS_SDR25; - break; - case MMCSD_TIMING_UHS_SDR50: - target_ios.ios_timing = FSDIF_MMC_TIMING_UHS_SDR50; - break; - case MMCSD_TIMING_UHS_SDR104: - target_ios.ios_timing = FSDIF_MMC_TIMING_UHS_SDR104; - break; - case MMCSD_TIMING_UHS_DDR50: - target_ios.ios_timing = FSDIF_MMC_TIMING_UHS_DDR50; - break; - default: - break; + case MMCSD_TIMING_UHS_SDR12: + target_ios.ios_timing = FSDIF_MMC_TIMING_UHS_SDR12; + break; + case MMCSD_TIMING_UHS_SDR25: + target_ios.ios_timing = FSDIF_MMC_TIMING_UHS_SDR25; + break; + case MMCSD_TIMING_UHS_SDR50: + target_ios.ios_timing = FSDIF_MMC_TIMING_UHS_SDR50; + break; + case MMCSD_TIMING_UHS_SDR104: + target_ios.ios_timing = FSDIF_MMC_TIMING_UHS_SDR104; + break; + case MMCSD_TIMING_UHS_DDR50: + target_ios.ios_timing = FSDIF_MMC_TIMING_UHS_DDR50; + break; + default: + break; } } } @@ -684,7 +694,6 @@ static void sdif_set_iocfg(struct rt_mmcsd_host *host, struct rt_mmcsd_io_cfg *i break; } } - } /* dataBusWidth set */ @@ -719,13 +728,12 @@ static rt_int32_t sdif_card_status(struct rt_mmcsd_host *host) return FSdifMsgCheckifCardExists(sdif) ? 1 : 0; } -static const struct rt_mmcsd_host_ops ops = - { - .request = sdif_send_request, - .set_iocfg = sdif_set_iocfg, - .get_card_status = sdif_card_status, - .enable_sdio_irq = RT_NULL, - .execute_tuning = RT_NULL, +static const struct rt_mmcsd_host_ops ops = { + .request = sdif_send_request, + .set_iocfg = sdif_set_iocfg, + .get_card_status = sdif_card_status, + .enable_sdio_irq = RT_NULL, + .execute_tuning = RT_NULL, }; static void sdif_ctrl_setup_interrupt(struct rt_mmcsd_host *host) @@ -769,7 +777,7 @@ void sdif_msg_prepare_init_data(FSdifMsgDataInit *msg_data_init, rt_uint32_t typ msg_data_init->clk_rate = FSDIF_CLK_FREQ_HZ; /*1.2GHz*/ } -static rt_err_t sdif_prepare_init_ios(FSdifMsgCtrl *const instance) +static rt_err_t sdif_prepare_init_ios(FSdifMsgCtrl * const instance) { FSdifMsgDataSetIos target_ios; @@ -787,7 +795,7 @@ static rt_err_t sdif_prepare_init_ios(FSdifMsgCtrl *const instance) return RT_EOK; } -static rt_err_t sdif_prepare_init_volt(FSdifMsgCtrl *const instance, rt_uint32_t type) +static rt_err_t sdif_prepare_init_volt(FSdifMsgCtrl * const instance, rt_uint32_t type) { FSdifMsgDataSwitchVolt target_volt; @@ -995,4 +1003,4 @@ int rt_hw_sdif_init(void) return status; } INIT_DEVICE_EXPORT(rt_hw_sdif_init); -#endif \ No newline at end of file +#endif diff --git a/components/drivers/block/blk.c b/components/drivers/block/blk.c index 313f50cdeba5..5f0d6b1f8234 100644 --- a/components/drivers/block/blk.c +++ b/components/drivers/block/blk.c @@ -15,13 +15,19 @@ #include "blk_dev.h" #include "blk_dfs.h" +#ifdef RT_USING_DFS +#include +#endif + static void blk_remove_all(struct rt_blk_disk *disk) { - struct rt_blk_device *blk, *blk_next; + rt_list_t *node, *next; + struct rt_blk_device *blk; /* Remove all partitions */ - rt_list_for_each_entry_safe(blk, blk_next, &disk->part_nodes, list) + rt_list_for_each_safe(node, next, &disk->part_nodes) { + blk = rt_list_entry(node, struct rt_blk_device, list); disk_remove_blk_dev(blk, RT_TRUE); } } @@ -44,7 +50,7 @@ static rt_err_t blk_close(rt_device_t dev) } static rt_ssize_t blk_read(rt_device_t dev, rt_off_t sector, - void *buffer, rt_size_t sector_count) + void *buffer, rt_size_t sector_count) { rt_ssize_t res; struct rt_blk_disk *disk = to_blk_disk(dev); @@ -59,7 +65,7 @@ static rt_ssize_t blk_read(rt_device_t dev, rt_off_t sector, } static rt_ssize_t blk_write(rt_device_t dev, rt_off_t sector, - const void *buffer, rt_size_t sector_count) + const void *buffer, rt_size_t sector_count) { rt_ssize_t res; struct rt_blk_disk *disk = to_blk_disk(dev); @@ -79,7 +85,7 @@ static rt_ssize_t blk_write(rt_device_t dev, rt_off_t sector, } static rt_ssize_t blk_parallel_read(rt_device_t dev, rt_off_t sector, - void *buffer, rt_size_t sector_count) + void *buffer, rt_size_t sector_count) { struct rt_blk_disk *disk = to_blk_disk(dev); @@ -87,7 +93,7 @@ static rt_ssize_t blk_parallel_read(rt_device_t dev, rt_off_t sector, } static rt_ssize_t blk_parallel_write(rt_device_t dev, rt_off_t sector, - const void *buffer, rt_size_t sector_count) + const void *buffer, rt_size_t sector_count) { struct rt_blk_disk *disk = to_blk_disk(dev); @@ -206,8 +212,7 @@ static rt_err_t blk_control(rt_device_t dev, int cmd, void *args) } #ifdef RT_USING_DEVICE_OPS -const static struct rt_device_ops blk_ops = -{ +const static struct rt_device_ops blk_ops = { .open = blk_open, .close = blk_close, .read = blk_read, @@ -215,8 +220,7 @@ const static struct rt_device_ops blk_ops = .control = blk_control, }; -const static struct rt_device_ops blk_parallel_ops = -{ +const static struct rt_device_ops blk_parallel_ops = { .open = blk_open, .close = blk_close, .read = blk_parallel_read, @@ -269,9 +273,9 @@ rt_err_t rt_hw_blk_disk_register(struct rt_blk_disk *disk) if (err) { - #ifdef RT_USING_DM +#ifdef RT_USING_DM rt_dm_ida_free(disk->ida, device_id); - #endif +#endif LOG_E("%s: Init user mutex error = %s", rt_strerror(err)); @@ -427,6 +431,7 @@ rt_ssize_t rt_blk_disk_get_logical_block_size(struct rt_blk_disk *disk) static int blk_dfs_mnt_table(void) { rt_ubase_t level; + rt_list_t *node, *part_node; struct rt_object *obj; struct rt_device *dev; struct rt_blk_disk *disk; @@ -435,8 +440,9 @@ static int blk_dfs_mnt_table(void) level = rt_hw_interrupt_disable(); - rt_list_for_each_entry(obj, &info->object_list, list) + rt_list_for_each(node, &info->object_list) { + obj = rt_list_entry(node, struct rt_object, list); dev = rt_container_of(obj, struct rt_device, parent); if (dev->type != RT_Device_Class_Block) @@ -457,8 +463,9 @@ static int blk_dfs_mnt_table(void) continue; } - rt_list_for_each_entry(blk_dev, &disk->part_nodes, list) + rt_list_for_each(part_node, &disk->part_nodes) { + blk_dev = rt_list_entry(part_node, struct rt_blk_device, list); dfs_mount_device(&blk_dev->parent); } } @@ -471,8 +478,19 @@ INIT_ENV_EXPORT(blk_dfs_mnt_table); #endif /* RT_USING_DFS_MNTTABLE */ #if defined(RT_USING_CONSOLE) && defined(RT_USING_MSH) +static const char *blk_get_mounted_path(struct rt_device *device) +{ +#ifdef RT_USING_DFS + return dfs_filesystem_get_mounted_path(device); +#else + RT_UNUSED(device); + + return RT_NULL; +#endif +} + const char *convert_size(struct rt_device_blk_geometry *geome, - rt_size_t sector_count, rt_size_t *out_cap, rt_size_t *out_minor) + rt_size_t sector_count, rt_size_t *out_cap, rt_size_t *out_minor) { rt_size_t cap, minor = 0; int size_index = 0; @@ -498,10 +516,11 @@ const char *convert_size(struct rt_device_blk_geometry *geome, return size_name[size_index]; } -static int list_blk(int argc, char**argv) +static int list_blk(int argc, char **argv) { rt_ubase_t level; rt_size_t cap, minor; + rt_list_t *node, *part_node; const char *size_name; struct rt_object *obj; struct rt_device *dev; @@ -514,8 +533,9 @@ static int list_blk(int argc, char**argv) rt_kprintf("%-*.s MAJ:MIN RM SIZE\tRO TYPE MOUNTPOINT\n", RT_NAME_MAX, "NAME"); - rt_list_for_each_entry(obj, &info->object_list, list) + rt_list_for_each(node, &info->object_list) { + obj = rt_list_entry(node, struct rt_object, list); dev = rt_container_of(obj, struct rt_device, parent); if (dev->type != RT_Device_Class_Block) @@ -538,33 +558,33 @@ static int list_blk(int argc, char**argv) size_name = convert_size(&geome, geome.sector_count, &cap, &minor); const char *mnt_path; - mnt_path = dfs_filesystem_get_mounted_path(&disk->parent); + mnt_path = blk_get_mounted_path(&disk->parent); rt_kprintf("%-*.s %3u.%-3u %u %u.%u%s\t%u disk %s\n", - RT_NAME_MAX, to_disk_name(disk), - #ifdef RT_USING_DM - disk->parent.master_id, disk->parent.device_id, - #else - 0, 0, - #endif - disk->removable, cap, minor, size_name, disk->read_only, - disk->max_partitions != RT_BLK_PARTITION_NONE ? "\b" : - (mnt_path ? mnt_path : "\b")); - - rt_list_for_each_entry(blk_dev, &disk->part_nodes, list) + RT_NAME_MAX, to_disk_name(disk), +#ifdef RT_USING_DM + disk->parent.master_id, disk->parent.device_id, +#else + 0, 0, +#endif + disk->removable, cap, minor, size_name, disk->read_only, + disk->max_partitions != RT_BLK_PARTITION_NONE ? "\b" : (mnt_path ? mnt_path : "\b")); + + rt_list_for_each(part_node, &disk->part_nodes) { + blk_dev = rt_list_entry(part_node, struct rt_blk_device, list); size_name = convert_size(&geome, blk_dev->sector_count, &cap, &minor); - mnt_path = dfs_filesystem_get_mounted_path(&blk_dev->parent); + mnt_path = blk_get_mounted_path(&blk_dev->parent); rt_kprintf("%c--%-*.s %3u.%-3u %u %u.%u%s\t%u part %s\n", - blk_dev->list.next != &disk->part_nodes ? '|' : '`', - RT_NAME_MAX - 3, to_blk_name(blk_dev), - #ifdef RT_USING_DM - blk_dev->parent.master_id, blk_dev->parent.device_id, - #else - 0, 0, - #endif - disk->removable, cap, minor, size_name, disk->read_only, - mnt_path ? mnt_path : ""); + blk_dev->list.next != &disk->part_nodes ? '|' : '`', + RT_NAME_MAX - 3, to_blk_name(blk_dev), +#ifdef RT_USING_DM + blk_dev->parent.master_id, blk_dev->parent.device_id, +#else + 0, 0, +#endif + disk->removable, cap, minor, size_name, disk->read_only, + mnt_path ? mnt_path : ""); } } diff --git a/components/drivers/block/blk_dfs.c b/components/drivers/block/blk_dfs.c index 1b5797b0a33c..ce637b687c35 100644 --- a/components/drivers/block/blk_dfs.c +++ b/components/drivers/block/blk_dfs.c @@ -8,12 +8,15 @@ * 2023-08-08 GuEe-GUI first version */ +#include + #include "blk_dfs.h" -#include #include #if defined(RT_USING_POSIX_DEVIO) && defined(RT_USING_DFS_V2) +#include + struct blk_fops_data { struct rt_device_blk_geometry geometry; @@ -55,7 +58,8 @@ static int blk_fops_ioctl(struct dfs_file *file, int cmd, void *arg) static ssize_t blk_fops_read(struct dfs_file *file, void *buf, size_t count, off_t *pos) { - void *rbuf; + rt_uint8_t *rbuf; + rt_uint8_t *read_buf = buf; rt_ssize_t res = 0; int bytes_per_sector, blk_pos, first_offs, rsize = 0; struct rt_device *dev = file->vnode->data; @@ -82,7 +86,7 @@ static ssize_t blk_fops_read(struct dfs_file *file, void *buf, size_t count, off { rsize = count; } - rt_memcpy(buf, rbuf + first_offs, rsize); + rt_memcpy(read_buf, rbuf + first_offs, rsize); ++blk_pos; /* @@ -99,12 +103,12 @@ static ssize_t blk_fops_read(struct dfs_file *file, void *buf, size_t count, off if (count - rsize >= bytes_per_sector) { - rt_memcpy(buf + rsize, rbuf, bytes_per_sector); + rt_memcpy(read_buf + rsize, rbuf, bytes_per_sector); rsize += bytes_per_sector; } else { - rt_memcpy(buf + rsize, rbuf, count - rsize); + rt_memcpy(read_buf + rsize, rbuf, count - rsize); rsize = count; } } @@ -120,7 +124,8 @@ static ssize_t blk_fops_read(struct dfs_file *file, void *buf, size_t count, off static ssize_t blk_fops_write(struct dfs_file *file, const void *buf, size_t count, off_t *pos) { - void *rbuf; + rt_uint8_t *rbuf; + const rt_uint8_t *write_buf = buf; rt_ssize_t res = 0; int bytes_per_sector, blk_pos, first_offs, wsize = 0; struct rt_device *dev = file->vnode->data; @@ -150,7 +155,7 @@ static ssize_t blk_fops_write(struct dfs_file *file, const void *buf, size_t cou if (res == 1) { - rt_memcpy(rbuf + first_offs, buf, wsize); + rt_memcpy(rbuf + first_offs, write_buf, wsize); res = rt_device_write(dev, blk_pos, (const void *)rbuf, 1); if (res == 1) @@ -174,7 +179,8 @@ static ssize_t blk_fops_write(struct dfs_file *file, const void *buf, size_t cou */ if ((count - wsize) / bytes_per_sector != 0) { - res = rt_device_write(dev, blk_pos, buf + wsize, (count - wsize) / bytes_per_sector); + res = rt_device_write(dev, blk_pos, write_buf + wsize, + (count - wsize) / bytes_per_sector); if (res != (count - wsize) / bytes_per_sector) { @@ -198,7 +204,7 @@ static ssize_t blk_fops_write(struct dfs_file *file, const void *buf, size_t cou if (res == 1) { - rt_memcpy(rbuf, buf + wsize, count - wsize); + rt_memcpy(rbuf, write_buf + wsize, count - wsize); res = rt_device_write(dev, blk_pos, (const void *)rbuf, 1); if (res == 1) @@ -229,8 +235,7 @@ static int blk_fops_poll(struct dfs_file *file, struct rt_pollreq *req) return mask; } -const static struct dfs_file_ops blk_fops = -{ +const static struct dfs_file_ops blk_fops = { .open = blk_fops_open, .close = blk_fops_close, .ioctl = blk_fops_ioctl, diff --git a/components/drivers/block/partitions/efi.c b/components/drivers/block/partitions/efi.c index 58c68cc98b9c..522d5f6076bb 100644 --- a/components/drivers/block/partitions/efi.c +++ b/components/drivers/block/partitions/efi.c @@ -93,8 +93,11 @@ rt_inline int pmbr_part_valid(gpt_mbr_record *part) */ static int is_pmbr_valid(legacy_mbr *mbr, rt_size_t total_sectors) { - rt_uint32_t sz = 0; - int part = 0, ret = 0; /* invalid by default */ + rt_uint32_t sz = 0; + rt_uint32_t disk_size; + int part = 0, ret = 0; /* invalid by default */ + + disk_size = total_sectors - 1 > RT_UINT32_MAX ? RT_UINT32_MAX : (rt_uint32_t)(total_sectors - 1); if (!mbr || rt_le16_to_cpu(mbr->signature) != MSDOS_MBR_SIGNATURE) { @@ -148,10 +151,10 @@ static int is_pmbr_valid(legacy_mbr *mbr, rt_size_t total_sectors) { sz = rt_le32_to_cpu(mbr->partition_record[part].size_in_lba); - if (sz != (rt_uint32_t)total_sectors - 1 && sz != 0xffffffff) + if (sz != disk_size && sz != RT_UINT32_MAX) { LOG_W("GPT: mbr size in lba (%u) different than whole disk (%u)", - sz, rt_min_t(rt_uint32_t, total_sectors - 1, 0xffffffff)); + sz, disk_size); } } @@ -172,9 +175,9 @@ static rt_size_t read_lba(struct rt_blk_disk *disk, rt_uint64_t lba, rt_uint8_t *buffer, rt_size_t count) { rt_uint32_t lbs; - rt_ssize_t cap_ss, lbs_ss; - rt_size_t totalreadcount = 0; - rt_uint8_t *secbuf = RT_NULL; + rt_ssize_t cap_ss, lbs_ss; + rt_size_t totalreadcount = 0; + rt_uint8_t *secbuf = RT_NULL; rt_uint64_t capacity, disk_bytes, n512; if (!buffer || count == 0) @@ -189,7 +192,7 @@ static rt_size_t read_lba(struct rt_blk_disk *disk, return 0; } - lbs = (rt_uint32_t)lbs_ss; + lbs = (rt_uint32_t)lbs_ss; capacity = (rt_uint64_t)cap_ss; if (lbs < 512 || (lbs % 512) != 0) @@ -203,7 +206,7 @@ static rt_size_t read_lba(struct rt_blk_disk *disk, } disk_bytes = capacity * (rt_uint64_t)lbs; - n512 = lba * ((rt_uint64_t)lbs / 512); + n512 = lba * ((rt_uint64_t)lbs / 512); secbuf = rt_malloc(lbs); if (!secbuf) @@ -213,8 +216,8 @@ static rt_size_t read_lba(struct rt_blk_disk *disk, while (count > 0) { - int copied = 512; - rt_ssize_t rd; + int copied = 512; + rt_ssize_t rd; rt_uint32_t off; rt_uint64_t log_sec, byte_off = n512 * 512; @@ -234,7 +237,7 @@ static rt_size_t read_lba(struct rt_blk_disk *disk, } log_sec = byte_off / lbs; - off = (rt_uint32_t)(byte_off % lbs); + off = (rt_uint32_t)(byte_off % lbs); if (off + (rt_uint32_t)copied <= lbs) { @@ -264,9 +267,9 @@ static rt_size_t read_lba(struct rt_blk_disk *disk, rt_memcpy(buffer + first, secbuf, copied - first); } - buffer += copied; + buffer += copied; totalreadcount += copied; - count -= copied; + count -= copied; ++n512; } @@ -282,10 +285,10 @@ static rt_size_t read_lba(struct rt_blk_disk *disk, * @return ptes on success, null on error. */ static gpt_entry *alloc_read_gpt_entries(struct rt_blk_disk *disk, - gpt_header *gpt) + gpt_header *gpt) { - rt_size_t count; - gpt_entry *pte; + rt_size_t count; + gpt_entry *pte; rt_uint64_t entry_lba; if (!gpt) @@ -333,7 +336,7 @@ static gpt_header *alloc_read_gpt_header(struct rt_blk_disk *disk, rt_uint64_t l { gpt_header *gpt; rt_uint32_t ssz; - rt_ssize_t lbs_ss = rt_blk_disk_get_logical_block_size(disk); + rt_ssize_t lbs_ss = rt_blk_disk_get_logical_block_size(disk); if (lbs_ss <= 0) { @@ -375,7 +378,7 @@ static rt_bool_t is_gpt_valid(struct rt_blk_disk *disk, { rt_uint32_t crc, origcrc; rt_uint64_t lastlba, pt_size; - rt_ssize_t logical_block_size; + rt_ssize_t logical_block_size; if (!ptes) { @@ -427,9 +430,9 @@ static rt_bool_t is_gpt_valid(struct rt_blk_disk *disk, } /* Check the GUID Partition Table CRC */ - origcrc = rt_le32_to_cpu((*gpt)->header_crc32); + origcrc = rt_le32_to_cpu((*gpt)->header_crc32); (*gpt)->header_crc32 = 0; - crc = efi_crc32((const rt_uint8_t *)(*gpt), rt_le32_to_cpu((*gpt)->header_size)); + crc = efi_crc32((const rt_uint8_t *)(*gpt), rt_le32_to_cpu((*gpt)->header_size)); if (crc != origcrc) { @@ -695,13 +698,13 @@ static void compare_gpts(struct rt_blk_disk *disk, static rt_bool_t find_valid_gpt(struct rt_blk_disk *disk, gpt_header **gpt, gpt_entry **ptes) { - int good_pgpt = 0, good_agpt = 0, good_pmbr = 0; + int good_pgpt = 0, good_agpt = 0, good_pmbr = 0; gpt_header *pgpt = RT_NULL, *agpt = RT_NULL; - gpt_entry *pptes = RT_NULL, *aptes = RT_NULL; + gpt_entry *pptes = RT_NULL, *aptes = RT_NULL; legacy_mbr *legacymbr; - rt_ssize_t cap_ss = rt_blk_disk_get_capacity(disk); - rt_size_t total_sectors; - rt_size_t lastlba; + rt_ssize_t cap_ss = rt_blk_disk_get_capacity(disk); + rt_size_t total_sectors; + rt_size_t lastlba; if (!ptes) { @@ -766,7 +769,7 @@ static rt_bool_t find_valid_gpt(struct rt_blk_disk *disk, /* The good cases */ if (good_pgpt) { - *gpt = pgpt; + *gpt = pgpt; *ptes = pptes; rt_free(agpt); rt_free(aptes); @@ -780,7 +783,7 @@ static rt_bool_t find_valid_gpt(struct rt_blk_disk *disk, } else if (good_agpt) { - *gpt = agpt; + *gpt = agpt; *ptes = aptes; rt_free(pgpt); rt_free(pptes); @@ -796,7 +799,7 @@ static rt_bool_t find_valid_gpt(struct rt_blk_disk *disk, rt_free(pptes); rt_free(aptes); - *gpt = RT_NULL; + *gpt = RT_NULL; *ptes = RT_NULL; return RT_FALSE; @@ -805,8 +808,8 @@ static rt_bool_t find_valid_gpt(struct rt_blk_disk *disk, rt_err_t efi_partition(struct rt_blk_disk *disk) { rt_uint32_t entries_nr; - gpt_header *gpt = RT_NULL; - gpt_entry *ptes = RT_NULL; + gpt_header *gpt = RT_NULL; + gpt_entry *ptes = RT_NULL; if (!find_valid_gpt(disk, &gpt, &ptes) || !gpt || !ptes) { @@ -821,8 +824,8 @@ rt_err_t efi_partition(struct rt_blk_disk *disk) for (int i = 0; i < entries_nr && i < disk->max_partitions; ++i) { rt_uint64_t start = rt_le64_to_cpu(ptes[i].starting_lba); - rt_uint64_t size = rt_le64_to_cpu(ptes[i].ending_lba) - - rt_le64_to_cpu(ptes[i].starting_lba) + 1ULL; + rt_uint64_t size = rt_le64_to_cpu(ptes[i].ending_lba) - + rt_le64_to_cpu(ptes[i].starting_lba) + 1ULL; if (!is_pte_valid(&ptes[i], last_lba(disk))) { diff --git a/components/drivers/include/drivers/blk.h b/components/drivers/include/drivers/blk.h index 95c1932456fc..cec39e33b8fe 100644 --- a/components/drivers/include/drivers/blk.h +++ b/components/drivers/include/drivers/blk.h @@ -40,9 +40,9 @@ struct rt_blk_disk struct rt_dm_ida *ida; #endif - rt_uint32_t read_only:1; - rt_uint32_t parallel_io:1; - rt_uint32_t removable:1; + rt_uint32_t read_only : 1; + rt_uint32_t parallel_io : 1; + rt_uint32_t removable : 1; #define RT_BLK_DISK_MAGIC 0xbdaabdaa rt_uint32_t __magic; @@ -62,9 +62,9 @@ struct rt_blk_disk struct rt_blk_disk_ops { rt_ssize_t (*read)(struct rt_blk_disk *disk, rt_off_t sector, void *buffer, - rt_size_t sector_count); + rt_size_t sector_count); rt_ssize_t (*write)(struct rt_blk_disk *disk, rt_off_t sector, const void *buffer, - rt_size_t sector_count); + rt_size_t sector_count); rt_err_t (*getgeome)(struct rt_blk_disk *disk, struct rt_device_blk_geometry *geometry); rt_err_t (*sync)(struct rt_blk_disk *disk); rt_err_t (*erase)(struct rt_blk_disk *disk); @@ -73,7 +73,18 @@ struct rt_blk_disk_ops }; #ifndef __DFS_H__ +#ifdef RT_USING_DFS #include +#else +/* Keep the legacy name available when the block layer is used without DFS. */ +struct dfs_partition +{ + rt_uint8_t type; + rt_off_t offset; + rt_size_t size; + rt_sem_t lock; +}; +#endif /* RT_USING_DFS */ /** * @brief Logical blk device, if you don't used DFS it will be defined by default. @@ -132,4 +143,4 @@ rt_ssize_t rt_blk_disk_get_logical_block_size(struct rt_blk_disk *disk); /*! @}*/ -#endif /* __BLK_H__ */ \ No newline at end of file +#endif /* __BLK_H__ */ diff --git a/components/drivers/include/drivers/mmcsd_card.h b/components/drivers/include/drivers/mmcsd_card.h index 6d86760a78a4..feab5a5724e5 100644 --- a/components/drivers/include/drivers/mmcsd_card.h +++ b/components/drivers/include/drivers/mmcsd_card.h @@ -19,128 +19,144 @@ extern "C" { #endif -#define SD_SCR_BUS_WIDTH_1 (1 << 0) -#define SD_SCR_BUS_WIDTH_4 (1 << 2) +#define SD_SCR_BUS_WIDTH_1 (1 << 0) +#define SD_SCR_BUS_WIDTH_4 (1 << 2) -struct rt_mmcsd_cid { - rt_uint8_t mid; /* ManufacturerID */ - rt_uint8_t prv; /* Product Revision */ +struct rt_mmcsd_cid +{ + rt_uint8_t mid; /* ManufacturerID */ + rt_uint8_t prv; /* Product Revision */ rt_uint16_t oid; /* OEM/Application ID */ rt_uint32_t psn; /* Product Serial Number */ - rt_uint8_t pnm[5]; /* Product Name */ - rt_uint8_t reserved1;/* reserved */ + rt_uint8_t pnm[5]; /* Product Name */ + rt_uint8_t reserved1;/* reserved */ rt_uint16_t mdt; /* Manufacturing Date */ - rt_uint8_t crc; /* CID CRC */ - rt_uint8_t reserved2;/* not used, always 1 */ + rt_uint8_t crc; /* CID CRC */ + rt_uint8_t reserved2;/* not used, always 1 */ }; -struct rt_mmcsd_csd { - rt_uint8_t csd_structure; /* CSD register version */ - rt_uint8_t taac; - rt_uint8_t nsac; - rt_uint8_t tran_speed; /* max data transfer rate */ - rt_uint16_t card_cmd_class; /* card command classes */ - rt_uint8_t rd_blk_len; /* max read data block length */ - rt_uint8_t rd_blk_part; - rt_uint8_t wr_blk_misalign; - rt_uint8_t rd_blk_misalign; - rt_uint8_t dsr_imp; /* DSR implemented */ - rt_uint8_t c_size_mult; /* CSD 1.0 , device size multiplier */ - rt_uint32_t c_size; /* device size */ - rt_uint8_t r2w_factor; - rt_uint8_t wr_blk_len; /* max wtire data block length */ - rt_uint8_t wr_blk_partial; - rt_uint8_t csd_crc; - +struct rt_mmcsd_csd +{ + rt_uint8_t csd_structure; /* CSD register version */ + rt_uint8_t taac; + rt_uint8_t nsac; + rt_uint8_t tran_speed; /* max data transfer rate */ + rt_uint16_t card_cmd_class; /* card command classes */ + rt_uint8_t rd_blk_len; /* max read data block length */ + rt_uint8_t rd_blk_part; + rt_uint8_t wr_blk_misalign; + rt_uint8_t rd_blk_misalign; + rt_uint8_t dsr_imp; /* DSR implemented */ + rt_uint8_t c_size_mult; /* CSD 1.0 , device size multiplier */ + rt_uint32_t c_size; /* device size */ + rt_uint8_t r2w_factor; + rt_uint8_t wr_blk_len; /* max wtire data block length */ + rt_uint8_t wr_blk_partial; + rt_uint8_t csd_crc; }; -struct rt_sd_scr { - rt_uint8_t sd_version; - rt_uint8_t sd_bus_widths; +struct rt_sd_scr +{ + rt_uint8_t sd_version; + rt_uint8_t sd_bus_widths; }; -struct rt_sdio_cccr { - rt_uint8_t sdio_version; - rt_uint8_t sd_version; - rt_uint8_t direct_cmd:1, /* Card Supports Direct Commands during data transfer +struct rt_sdio_cccr +{ + rt_uint8_t sdio_version; + rt_uint8_t sd_version; + rt_uint8_t direct_cmd : 1, /* Card Supports Direct Commands during data transfer only SD mode, not used for SPI mode */ - multi_block:1, /* Card Supports Multi-Block */ - read_wait:1, /* Card Supports Read Wait + multi_block : 1, /* Card Supports Multi-Block */ + read_wait : 1, /* Card Supports Read Wait only SD mode, not used for SPI mode */ - suspend_resume:1, /* Card supports Suspend/Resume + suspend_resume : 1, /* Card supports Suspend/Resume only SD mode, not used for SPI mode */ - s4mi:1, /* generate interrupts during a 4-bit + s4mi : 1, /* generate interrupts during a 4-bit multi-block data transfer */ - e4mi:1, /* Enable the multi-block IRQ during + e4mi : 1, /* Enable the multi-block IRQ during 4-bit transfer for the SDIO card */ - low_speed:1, /* Card is a Low-Speed card */ - low_speed_4:1; /* 4-bit support for Low-Speed cards */ + low_speed : 1, /* Card is a Low-Speed card */ + low_speed_4 : 1; /* 4-bit support for Low-Speed cards */ - rt_uint8_t bus_width:1, /* Support SDIO bus width, 1:4bit, 0:1bit */ - cd_disable:1, /* Connect[0]/Disconnect[1] the 10K-90K ohm pull-up + rt_uint8_t bus_width : 1, /* Support SDIO bus width, 1:4bit, 0:1bit */ + cd_disable : 1, /* Connect[0]/Disconnect[1] the 10K-90K ohm pull-up resistor on CD/DAT[3] (pin 1) of the card */ - power_ctrl:1, /* Support Master Power Control */ - high_speed:1; /* Support High-Speed */ - - + power_ctrl : 1, /* Support Master Power Control */ + high_speed : 1; /* Support High-Speed */ }; /* * SD Status */ -union rt_sd_status { +union rt_sd_status +{ rt_uint32_t status_words[16]; - struct { + struct + { rt_uint32_t reserved[12]; - rt_uint64_t : 8; - rt_uint64_t uhs_au_size: 4; - rt_uint64_t uhs_speed_grade: 4; - rt_uint64_t erase_offset: 2; - rt_uint64_t erase_timeout: 6; - rt_uint64_t erase_size: 16; - rt_uint64_t : 4; - rt_uint64_t au_size: 4; - rt_uint64_t performance_move: 8; - rt_uint64_t speed_class: 8; + rt_uint64_t : 8; + rt_uint64_t uhs_au_size : 4; + rt_uint64_t uhs_speed_grade : 4; + rt_uint64_t erase_offset : 2; + rt_uint64_t erase_timeout : 6; + rt_uint64_t erase_size : 16; + rt_uint64_t : 4; + rt_uint64_t au_size : 4; + rt_uint64_t performance_move : 8; + rt_uint64_t speed_class : 8; rt_uint32_t size_of_protected_area; - rt_uint32_t sd_card_type: 16; - rt_uint32_t : 6; - rt_uint32_t : 7; - rt_uint32_t secured_mode: 1; - rt_uint32_t data_bus_width: 2; + rt_uint32_t sd_card_type : 16; + rt_uint32_t : 6; + rt_uint32_t : 7; + rt_uint32_t secured_mode : 1; + rt_uint32_t data_bus_width : 2; + /* Arm Compiler 5 does not support anonymous structs in strict C99 mode. */ +#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 6000000) + } fields; +#else }; +#endif }; +#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 6000000) +#define RT_SD_STATUS_FIELD(status, field) ((status).fields.field) +#else +#define RT_SD_STATUS_FIELD(status, field) ((status).field) +#endif + /* * SD Speed Class */ -#define SD_SPEED_CLASS_0 0 -#define SD_SPEED_CLASS_2 1 -#define SD_SPEED_CLASS_4 2 -#define SD_SPEED_CLASS_6 3 -#define SD_SPEED_CLASS_10 4 +#define SD_SPEED_CLASS_0 0 +#define SD_SPEED_CLASS_2 1 +#define SD_SPEED_CLASS_4 2 +#define SD_SPEED_CLASS_6 3 +#define SD_SPEED_CLASS_10 4 /* * UHS Speed Grade */ -#define UHS_SPEED_GRADE_0 0 -#define UHS_SPEED_GRADE_1 1 -#define UHS_SPEED_GRADE_3 3 +#define UHS_SPEED_GRADE_0 0 +#define UHS_SPEED_GRADE_1 1 +#define UHS_SPEED_GRADE_3 3 -struct rt_sdio_cis { - rt_uint16_t manufacturer; - rt_uint16_t product; - rt_uint16_t func0_blk_size; - rt_uint32_t max_tran_speed; +struct rt_sdio_cis +{ + rt_uint16_t manufacturer; + rt_uint16_t product; + rt_uint16_t func0_blk_size; + rt_uint32_t max_tran_speed; }; /* * SDIO function CIS tuple (unknown to the core) */ -struct rt_sdio_function_tuple { +struct rt_sdio_function_tuple +{ struct rt_sdio_function_tuple *next; rt_uint8_t code; rt_uint8_t size; @@ -148,31 +164,32 @@ struct rt_sdio_function_tuple { }; struct rt_sdio_function; -typedef void (rt_sdio_irq_handler_t)(struct rt_sdio_function *); +typedef void(rt_sdio_irq_handler_t)(struct rt_sdio_function *); /* * SDIO function devices */ -struct rt_sdio_function { - struct rt_mmcsd_card *card; /* the card this device belongs to */ - rt_sdio_irq_handler_t *irq_handler; /* IRQ callback */ - rt_uint8_t num; /* function number */ +struct rt_sdio_function +{ + struct rt_mmcsd_card *card; /* the card this device belongs to */ + rt_sdio_irq_handler_t *irq_handler; /* IRQ callback */ + rt_uint8_t num; /* function number */ - rt_uint8_t func_code; /* Standard SDIO Function interface code */ - rt_uint16_t manufacturer; /* manufacturer id */ - rt_uint16_t product; /* product id */ + rt_uint8_t func_code; /* Standard SDIO Function interface code */ + rt_uint16_t manufacturer; /* manufacturer id */ + rt_uint16_t product; /* product id */ - rt_uint32_t max_blk_size; /* maximum block size */ - rt_uint32_t cur_blk_size; /* current block size */ + rt_uint32_t max_blk_size; /* maximum block size */ + rt_uint32_t cur_blk_size; /* current block size */ - rt_uint32_t enable_timeout_val; /* max enable timeout in msec */ + rt_uint32_t enable_timeout_val; /* max enable timeout in msec */ struct rt_sdio_function_tuple *tuples; - void *priv; + void *priv; }; -#define SDIO_MAX_FUNCTIONS 7 +#define SDIO_MAX_FUNCTIONS 7 struct rt_mmc_ext_csd { @@ -180,7 +197,8 @@ struct rt_mmc_ext_csd rt_uint32_t enhanced_data_strobe; }; -struct rt_mmcsd_card { +struct rt_mmcsd_card +{ struct rt_mmcsd_host *host; rt_uint32_t rca; /* card addr */ rt_uint32_t resp_cid[4]; /* card CID register */ @@ -195,28 +213,28 @@ struct rt_mmcsd_card { rt_uint32_t card_sec_cnt; /* card sector count*/ rt_uint32_t erase_size; /* erase size in sectors */ rt_uint16_t card_type; -#define CARD_TYPE_MMC 0 /* MMC card */ -#define CARD_TYPE_SD 1 /* SD card */ -#define CARD_TYPE_SDIO 2 /* SDIO card */ -#define CARD_TYPE_SDIO_COMBO 3 /* SD combo (IO+mem) card */ +#define CARD_TYPE_MMC 0 /* MMC card */ +#define CARD_TYPE_SD 1 /* SD card */ +#define CARD_TYPE_SDIO 2 /* SDIO card */ +#define CARD_TYPE_SDIO_COMBO 3 /* SD combo (IO+mem) card */ rt_uint16_t flags; -#define CARD_FLAG_HIGHSPEED (1 << 0) /* SDIO bus speed 50MHz */ -#define CARD_FLAG_SDHC (1 << 1) /* SDHC card */ -#define CARD_FLAG_SDXC (1 << 2) /* SDXC card */ -#define CARD_FLAG_HIGHSPEED_DDR (1 << 3) /* HIGH SPEED DDR */ -#define CARD_FLAG_HS200 (1 << 4) /* BUS SPEED 200MHz */ -#define CARD_FLAG_HS400 (1 << 5) /* BUS SPEED 400MHz */ -#define CARD_FLAG_SDR50 (1 << 6) /* BUS SPEED 100MHz */ -#define CARD_FLAG_SDR104 (1 << 7) /* BUS SPEED 200MHz */ -#define CARD_FLAG_DDR50 (1 << 8) /* DDR50, works on 1.8V only */ - struct rt_sd_scr scr; +#define CARD_FLAG_HIGHSPEED (1 << 0) /* SDIO bus speed 50MHz */ +#define CARD_FLAG_SDHC (1 << 1) /* SDHC card */ +#define CARD_FLAG_SDXC (1 << 2) /* SDXC card */ +#define CARD_FLAG_HIGHSPEED_DDR (1 << 3) /* HIGH SPEED DDR */ +#define CARD_FLAG_HS200 (1 << 4) /* BUS SPEED 200MHz */ +#define CARD_FLAG_HS400 (1 << 5) /* BUS SPEED 400MHz */ +#define CARD_FLAG_SDR50 (1 << 6) /* BUS SPEED 100MHz */ +#define CARD_FLAG_SDR104 (1 << 7) /* BUS SPEED 200MHz */ +#define CARD_FLAG_DDR50 (1 << 8) /* DDR50, works on 1.8V only */ + struct rt_sd_scr scr; struct rt_mmcsd_csd csd; - rt_uint32_t hs_max_data_rate; /* max data transfer rate in high speed mode */ + rt_uint32_t hs_max_data_rate; /* max data transfer rate in high speed mode */ - rt_uint8_t sdio_function_num; /* total number of SDIO functions */ - struct rt_sdio_cccr cccr; /* common card info */ - struct rt_sdio_cis cis; /* common tuple info */ + rt_uint8_t sdio_function_num; /* total number of SDIO functions */ + struct rt_sdio_cccr cccr; /* common card info */ + struct rt_sdio_cis cis; /* common tuple info */ struct rt_sdio_function *sdio_function[SDIO_MAX_FUNCTIONS + 1]; /* SDIO functions (devices) */ void *blk_dev; diff --git a/components/drivers/include/drivers/mmcsd_cmd.h b/components/drivers/include/drivers/mmcsd_cmd.h index 06212c5162ac..d8cd28db4123 100644 --- a/components/drivers/include/drivers/mmcsd_cmd.h +++ b/components/drivers/include/drivers/mmcsd_cmd.h @@ -17,28 +17,28 @@ extern "C" { #endif /* class 1 */ -#define GO_IDLE_STATE 0 /* bc */ -#define SEND_OP_COND 1 /* bcr [31:0] OCR R3 */ -#define ALL_SEND_CID 2 /* bcr R2 */ -#define SET_RELATIVE_ADDR 3 /* ac [31:16] RCA R1 */ -#define SET_DSR 4 /* bc [31:16] RCA */ -#define SWITCH 6 /* ac [31:0] See below R1b */ -#define SELECT_CARD 7 /* ac [31:16] RCA R1 */ -#define SEND_EXT_CSD 8 /* adtc R1 */ -#define SEND_CSD 9 /* ac [31:16] RCA R2 */ -#define SEND_CID 10 /* ac [31:16] RCA R2 */ -#define VOLTAGE_SWITCH 11 /* ac [31:0] R1 */ -#define STOP_TRANSMISSION 12 /* ac R1b */ -#define SEND_STATUS 13 /* ac [31:16] RCA R1 */ -#define GO_INACTIVE_STATE 15 /* ac [31:16] RCA */ -#define SPI_READ_OCR 58 /* spi spi_R3 */ -#define SPI_CRC_ON_OFF 59 /* spi [0:0] flag spi_R1 */ +#define GO_IDLE_STATE 0 /* bc */ +#define SEND_OP_COND 1 /* bcr [31:0] OCR R3 */ +#define ALL_SEND_CID 2 /* bcr R2 */ +#define SET_RELATIVE_ADDR 3 /* ac [31:16] RCA R1 */ +#define SET_DSR 4 /* bc [31:16] RCA */ +#define MMC_SWITCH 6 /* ac [31:0] See below R1b */ +#define SELECT_CARD 7 /* ac [31:16] RCA R1 */ +#define SEND_EXT_CSD 8 /* adtc R1 */ +#define SEND_CSD 9 /* ac [31:16] RCA R2 */ +#define SEND_CID 10 /* ac [31:16] RCA R2 */ +#define VOLTAGE_SWITCH 11 /* ac [31:0] R1 */ +#define STOP_TRANSMISSION 12 /* ac R1b */ +#define SEND_STATUS 13 /* ac [31:16] RCA R1 */ +#define GO_INACTIVE_STATE 15 /* ac [31:16] RCA */ +#define SPI_READ_OCR 58 /* spi spi_R3 */ +#define SPI_CRC_ON_OFF 59 /* spi [0:0] flag spi_R1 */ /* class 2 */ -#define SET_BLOCKLEN 16 /* ac [31:0] block len R1 */ -#define READ_SINGLE_BLOCK 17 /* adtc [31:0] data addr R1 */ -#define READ_MULTIPLE_BLOCK 18 /* adtc [31:0] data addr R1 */ -#define SEND_TUNING_BLOCK 19 /* adtc R1 */ +#define SET_BLOCKLEN 16 /* ac [31:0] block len R1 */ +#define READ_SINGLE_BLOCK 17 /* adtc [31:0] data addr R1 */ +#define READ_MULTIPLE_BLOCK 18 /* adtc [31:0] data addr R1 */ +#define SEND_TUNING_BLOCK 19 /* adtc R1 */ #define SEND_TUNING_BLOCK_HS200 21 /* adtc R1*/ /* class 3 */ #define WRITE_DAT_UNTIL_STOP 20 /* adtc [31:0] data addr R1 */ @@ -51,77 +51,77 @@ extern "C" { #define PROGRAM_CSD 27 /* adtc R1 */ /* class 6 */ -#define SET_WRITE_PROT 28 /* ac [31:0] data addr R1b */ -#define CLR_WRITE_PROT 29 /* ac [31:0] data addr R1b */ -#define SEND_WRITE_PROT 30 /* adtc [31:0] wpdata addr R1 */ +#define SET_WRITE_PROT 28 /* ac [31:0] data addr R1b */ +#define CLR_WRITE_PROT 29 /* ac [31:0] data addr R1b */ +#define SEND_WRITE_PROT 30 /* adtc [31:0] wpdata addr R1 */ /* class 5 */ -#define ERASE_GROUP_START 35 /* ac [31:0] data addr R1 */ -#define ERASE_GROUP_END 36 /* ac [31:0] data addr R1 */ -#define ERASE 38 /* ac R1b */ +#define ERASE_GROUP_START 35 /* ac [31:0] data addr R1 */ +#define ERASE_GROUP_END 36 /* ac [31:0] data addr R1 */ +#define ERASE 38 /* ac R1b */ /* class 9 */ -#define FAST_IO 39 /* ac R4 */ -#define GO_IRQ_STATE 40 /* bcr R5 */ +#define FAST_IO 39 /* ac R4 */ +#define GO_IRQ_STATE 40 /* bcr R5 */ /* class 7 */ -#define LOCK_UNLOCK 42 /* adtc R1b */ +#define LOCK_UNLOCK 42 /* adtc R1b */ /* class 8 */ -#define APP_CMD 55 /* ac [31:16] RCA R1 */ -#define GEN_CMD 56 /* adtc [0] RD/WR R1 */ +#define APP_CMD 55 /* ac [31:16] RCA R1 */ +#define GEN_CMD 56 /* adtc [0] RD/WR R1 */ /* SD commands type argument response */ /* class 0 */ /* This is basically the same command as for MMC with some quirks. */ -#define SD_SEND_RELATIVE_ADDR 3 /* bcr R6 */ -#define SD_SEND_IF_COND 8 /* bcr [11:0] See below R7 */ +#define SD_SEND_RELATIVE_ADDR 3 /* bcr R6 */ +#define SD_SEND_IF_COND 8 /* bcr [11:0] See below R7 */ /* class 10 */ -#define SD_SWITCH 6 /* adtc [31:0] See below R1 */ +#define SD_SWITCH 6 /* adtc [31:0] See below R1 */ /* Application commands */ -#define SD_APP_SET_BUS_WIDTH 6 /* ac [1:0] bus width R1 */ -#define SD_APP_SEND_NUM_WR_BLKS 22 /* adtc R1 */ -#define SD_APP_OP_COND 41 /* bcr [31:0] OCR R3 */ -#define SD_APP_SEND_SCR 51 /* adtc R1 */ +#define SD_APP_SET_BUS_WIDTH 6 /* ac [1:0] bus width R1 */ +#define SD_APP_SEND_NUM_WR_BLKS 22 /* adtc R1 */ +#define SD_APP_OP_COND 41 /* bcr [31:0] OCR R3 */ +#define SD_APP_SEND_SCR 51 /* adtc R1 */ -#define SCR_SPEC_VER_0 0 /* Implements system specification 1.0 - 1.01 */ -#define SCR_SPEC_VER_1 1 /* Implements system specification 1.10 */ -#define SCR_SPEC_VER_2 2 /* Implements system specification 2.00 */ +#define SCR_SPEC_VER_0 0 /* Implements system specification 1.0 - 1.01 */ +#define SCR_SPEC_VER_1 1 /* Implements system specification 1.10 */ +#define SCR_SPEC_VER_2 2 /* Implements system specification 2.00 */ /* SDIO commands type argument response */ -#define SD_IO_SEND_OP_COND 5 /* bcr [23:0] OCR R4 */ -#define SD_IO_RW_DIRECT 52 /* ac [31:0] See below R5 */ -#define SD_IO_RW_EXTENDED 53 /* adtc [31:0] See below R5 */ +#define SD_IO_SEND_OP_COND 5 /* bcr [23:0] OCR R4 */ +#define SD_IO_RW_DIRECT 52 /* ac [31:0] See below R5 */ +#define SD_IO_RW_EXTENDED 53 /* adtc [31:0] See below R5 */ /* CMD52 arguments */ -#define SDIO_ARG_CMD52_READ (0<<31) -#define SDIO_ARG_CMD52_WRITE (1u<<31) -#define SDIO_ARG_CMD52_FUNC_SHIFT 28 -#define SDIO_ARG_CMD52_FUNC_MASK 0x7 -#define SDIO_ARG_CMD52_RAW_FLAG (1u<<27) -#define SDIO_ARG_CMD52_REG_SHIFT 9 -#define SDIO_ARG_CMD52_REG_MASK 0x1ffff -#define SDIO_ARG_CMD52_DATA_SHIFT 0 -#define SDIO_ARG_CMD52_DATA_MASK 0xff -#define SDIO_R5_DATA(resp) ((resp)[0] & 0xff) +#define SDIO_ARG_CMD52_READ (0 << 31) +#define SDIO_ARG_CMD52_WRITE (1u << 31) +#define SDIO_ARG_CMD52_FUNC_SHIFT 28 +#define SDIO_ARG_CMD52_FUNC_MASK 0x7 +#define SDIO_ARG_CMD52_RAW_FLAG (1u << 27) +#define SDIO_ARG_CMD52_REG_SHIFT 9 +#define SDIO_ARG_CMD52_REG_MASK 0x1ffff +#define SDIO_ARG_CMD52_DATA_SHIFT 0 +#define SDIO_ARG_CMD52_DATA_MASK 0xff +#define SDIO_R5_DATA(resp) ((resp)[0] & 0xff) /* CMD53 arguments */ -#define SDIO_ARG_CMD53_READ (0<<31) -#define SDIO_ARG_CMD53_WRITE (1u<<31) -#define SDIO_ARG_CMD53_FUNC_SHIFT 28 -#define SDIO_ARG_CMD53_FUNC_MASK 0x7 -#define SDIO_ARG_CMD53_BLOCK_MODE (1u<<27) -#define SDIO_ARG_CMD53_INCREMENT (1u<<26) -#define SDIO_ARG_CMD53_REG_SHIFT 9 -#define SDIO_ARG_CMD53_REG_MASK 0x1ffff -#define SDIO_ARG_CMD53_LENGTH_SHIFT 0 -#define SDIO_ARG_CMD53_LENGTH_MASK 0x1ff -#define SDIO_ARG_CMD53_LENGTH_MAX 511 +#define SDIO_ARG_CMD53_READ (0 << 31) +#define SDIO_ARG_CMD53_WRITE (1u << 31) +#define SDIO_ARG_CMD53_FUNC_SHIFT 28 +#define SDIO_ARG_CMD53_FUNC_MASK 0x7 +#define SDIO_ARG_CMD53_BLOCK_MODE (1u << 27) +#define SDIO_ARG_CMD53_INCREMENT (1u << 26) +#define SDIO_ARG_CMD53_REG_SHIFT 9 +#define SDIO_ARG_CMD53_REG_MASK 0x1ffff +#define SDIO_ARG_CMD53_LENGTH_SHIFT 0 +#define SDIO_ARG_CMD53_LENGTH_MASK 0x1ff +#define SDIO_ARG_CMD53_LENGTH_MAX 511 #ifdef __cplusplus diff --git a/components/drivers/sdio/dev_block.c b/components/drivers/sdio/dev_block.c index d4f8f62885db..f0437c10c25b 100644 --- a/components/drivers/sdio/dev_block.c +++ b/components/drivers/sdio/dev_block.c @@ -14,11 +14,11 @@ #include #include -#define DBG_TAG "SDIO" +#define DBG_TAG "SDIO" #ifdef RT_SDIO_DEBUG -#define DBG_LVL DBG_LOG +#define DBG_LVL DBG_LOG #else -#define DBG_LVL DBG_INFO +#define DBG_LVL DBG_INFO #endif /* RT_SDIO_DEBUG */ #include @@ -26,6 +26,8 @@ #define RT_MMCSD_MAX_PARTITION 16 #endif +#define MMCSD_SECTOR_SIZE 512U + struct mmcsd_blk_device { struct rt_blk_disk parent; @@ -52,10 +54,14 @@ static int __send_status(struct rt_mmcsd_card *card, rt_uint32_t *status, unsign cmd.flags = RESP_R1 | CMD_AC; err = mmcsd_send_cmd(card->host, &cmd, retries); if (err) + { return err; + } if (status) + { *status = cmd.resp[0]; + } return 0; } @@ -82,7 +88,9 @@ static int card_busy_detect(struct rt_mmcsd_card *card, unsigned int timeout_ms, /* Accumulate any response error bits seen */ if (resp_errs) + { *resp_errs |= status; + } if (out) { @@ -94,9 +102,8 @@ 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; } @@ -119,9 +126,13 @@ rt_int32_t mmcsd_num_wr_blocks(struct rt_mmcsd_card *card) err = mmcsd_send_cmd(card->host, &cmd, 0); if (err) + { return -RT_ERROR; + } if (!controller_is_spi(card->host) && !(cmd.resp[0] & R1_APP_CMD)) + { return -RT_ERROR; + } rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); @@ -157,20 +168,22 @@ rt_int32_t mmcsd_num_wr_blocks(struct rt_mmcsd_card *card) mmcsd_send_request(card->host, &req); if (cmd.err || data.err) + { return -RT_ERROR; + } return blocks; } static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card, - rt_uint32_t sector, - void *buf, - rt_size_t blks, - rt_uint8_t dir) + rt_uint32_t sector, + void *buf, + rt_size_t blks, + rt_uint8_t dir) { - struct rt_mmcsd_cmd cmd, stop; - struct rt_mmcsd_data data; - struct rt_mmcsd_req req; + struct rt_mmcsd_cmd cmd, stop; + struct rt_mmcsd_data data; + struct rt_mmcsd_req req; struct rt_mmcsd_host *host = card->host; rt_uint32_t r_cmd, w_cmd; @@ -189,8 +202,8 @@ static rt_err_t rt_mmcsd_req_blk(struct rt_mmcsd_card *card, } cmd.flags = RESP_SPI_R1 | RESP_R1 | CMD_ADTC; - data.blksize = SECTOR_SIZE; - data.blks = blks; + data.blksize = MMCSD_SECTOR_SIZE; + data.blks = blks; if (blks > 1) { @@ -256,11 +269,13 @@ static rt_int32_t mmcsd_set_blksize(struct rt_mmcsd_card *card) /* Block-addressed cards ignore MMC_SET_BLOCKLEN. */ if (card->flags & CARD_FLAG_SDHC) + { return 0; + } mmcsd_host_lock(card->host); cmd.cmd_code = SET_BLOCKLEN; - cmd.arg = 512; + cmd.arg = MMCSD_SECTOR_SIZE; cmd.flags = RESP_SPI_R1 | RESP_R1 | CMD_AC; err = mmcsd_send_cmd(card->host, &cmd, 5); mmcsd_host_unlock(card->host); @@ -276,7 +291,7 @@ static rt_int32_t mmcsd_set_blksize(struct rt_mmcsd_card *card) } static rt_ssize_t mmcsd_blk_read(struct rt_blk_disk *disk, rt_off_t sector, - void *buffer, rt_size_t sector_count) + void *buffer, rt_size_t sector_count) { rt_err_t err; rt_size_t offset = 0; @@ -287,7 +302,7 @@ static rt_ssize_t mmcsd_blk_read(struct rt_blk_disk *disk, rt_off_t sector, while (remain_size) { - req_size = rt_min_t(rt_size_t, remain_size, blk_dev->max_req_size); + req_size = remain_size < blk_dev->max_req_size ? remain_size : blk_dev->max_req_size; err = rt_mmcsd_req_blk(blk_dev->card, sector + offset, rd_ptr, req_size, 0); @@ -297,7 +312,7 @@ static rt_ssize_t mmcsd_blk_read(struct rt_blk_disk *disk, rt_off_t sector, } offset += req_size; - rd_ptr = (void *)((rt_uint8_t *)rd_ptr + (req_size << 9)); + rd_ptr = (void *)((rt_uint8_t *)rd_ptr + req_size * MMCSD_SECTOR_SIZE); remain_size -= req_size; } @@ -305,7 +320,7 @@ static rt_ssize_t mmcsd_blk_read(struct rt_blk_disk *disk, rt_off_t sector, } static rt_ssize_t mmcsd_blk_write(struct rt_blk_disk *disk, rt_off_t sector, - const void *buffer, rt_size_t sector_count) + const void *buffer, rt_size_t sector_count) { rt_err_t err; rt_size_t offset = 0; @@ -316,7 +331,7 @@ static rt_ssize_t mmcsd_blk_write(struct rt_blk_disk *disk, rt_off_t sector, while (remain_size) { - req_size = rt_min_t(rt_size_t, remain_size, blk_dev->max_req_size); + req_size = remain_size < blk_dev->max_req_size ? remain_size : blk_dev->max_req_size; err = rt_mmcsd_req_blk(blk_dev->card, sector + offset, wr_ptr, req_size, 1); @@ -326,7 +341,7 @@ static rt_ssize_t mmcsd_blk_write(struct rt_blk_disk *disk, rt_off_t sector, } offset += req_size; - wr_ptr = (void *)((rt_uint8_t *)wr_ptr + (req_size << 9)); + wr_ptr = (void *)((rt_uint8_t *)wr_ptr + req_size * MMCSD_SECTOR_SIZE); remain_size -= req_size; } @@ -334,7 +349,7 @@ static rt_ssize_t mmcsd_blk_write(struct rt_blk_disk *disk, rt_off_t sector, } static rt_err_t mmcsd_blk_getgeome(struct rt_blk_disk *disk, - struct rt_device_blk_geometry *geometry) + struct rt_device_blk_geometry *geometry) { struct mmcsd_blk_device *blk_dev = raw_to_mmcsd_blk(disk); @@ -343,8 +358,7 @@ static rt_err_t mmcsd_blk_getgeome(struct rt_blk_disk *disk, return RT_EOK; } -static const struct rt_blk_disk_ops mmcsd_blk_ops = -{ +static const struct rt_blk_disk_ops mmcsd_blk_ops = { .read = mmcsd_blk_read, .write = mmcsd_blk_write, .getgeome = mmcsd_blk_getgeome, @@ -353,6 +367,8 @@ static const struct rt_blk_disk_ops mmcsd_blk_ops = rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card) { rt_err_t err; + rt_size_t max_dma_size; + rt_size_t max_blk_size; struct rt_mmcsd_host *host = card->host; struct mmcsd_blk_device *blk_dev = rt_calloc(1, sizeof(*blk_dev)); @@ -371,12 +387,12 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card) blk_dev->parent.max_partitions = RT_MMCSD_MAX_PARTITION; blk_dev->card = card; - blk_dev->max_req_size = rt_min_t(rt_size_t, - host->max_dma_segs * host->max_seg_size, - host->max_blk_count * host->max_blk_size) >> 9; - blk_dev->geometry.bytes_per_sector = 1 << 9; + max_dma_size = host->max_dma_segs * host->max_seg_size; + max_blk_size = host->max_blk_count * host->max_blk_size; + blk_dev->max_req_size = (max_dma_size < max_blk_size ? max_dma_size : max_blk_size) / MMCSD_SECTOR_SIZE; + blk_dev->geometry.bytes_per_sector = MMCSD_SECTOR_SIZE; blk_dev->geometry.block_size = card->card_blksize; - blk_dev->geometry.sector_count = card->card_capacity * (1024 / 512); + blk_dev->geometry.sector_count = card->card_capacity * (1024 / MMCSD_SECTOR_SIZE); /* Set blk size before partitions probe, Why? */ if ((err = mmcsd_set_blksize(card))) @@ -400,7 +416,7 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card) _fail: card->blk_dev = RT_NULL; - free(blk_dev); + rt_free(blk_dev); return err; } diff --git a/components/drivers/sdio/dev_mmc.c b/components/drivers/sdio/dev_mmc.c index 8a09aa937dfc..a3f42576e8bf 100644 --- a/components/drivers/sdio/dev_mmc.c +++ b/components/drivers/sdio/dev_mmc.c @@ -87,7 +87,9 @@ rt_inline rt_uint32_t GET_BITS(rt_uint32_t *resp, __res = resp[__off] >> __shft; if (__size + __shft > 32) + { __res |= resp[__off - 1] << ((32 - __shft) % 32); + } return __res & __mask; } @@ -157,7 +159,9 @@ static int mmc_get_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t **new_ext_csd) *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 @@ -204,9 +208,13 @@ static int mmc_get_ext_csd(struct rt_mmcsd_card *card, rt_uint8_t **new_ext_csd) 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; @@ -284,10 +292,14 @@ static int mmc_send_status(struct rt_mmcsd_card *card, rt_uint32_t *status, unsi cmd.flags = RESP_R1 | CMD_AC; err = mmcsd_send_cmd(card->host, &cmd, retries); if (err) + { return err; + } if (status) + { *status = cmd.resp[0]; + } return 0; } @@ -321,9 +333,8 @@ static int mmc_poll_for_busy(struct rt_mmcsd_card *card, rt_uint32_t timeout_ms, LOG_E("error %d requesting status", err); return err; } - } - while (!(status & R1_READY_FOR_DATA) || - (R1_CURRENT_STATE(status) == R1_STATE_PRG)); + } while (!(status & R1_READY_FOR_DATA) || + (R1_CURRENT_STATE(status) == R1_STATE_PRG)); return err; } @@ -344,21 +355,25 @@ static int mmc_switch(struct rt_mmcsd_card *card, rt_uint8_t set, struct rt_mmcsd_host *host = card->host; struct rt_mmcsd_cmd cmd = { 0 }; - cmd.cmd_code = SWITCH; + cmd.cmd_code = MMC_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; + } /* * Poll the card status using CMD13 with a timeout of 500ms and a polling interval of 1ms. */ err = mmc_poll_for_busy(card, 500, 3); if (err) + { return err; + } return 0; } @@ -370,7 +385,9 @@ static int mmc_compare_ext_csds(struct rt_mmcsd_card *card, int err; if (bus_width == MMCSD_BUS_WIDTH_1) + { return 0; + } err = mmc_get_ext_csd(card, &bw_ext_csd); @@ -409,7 +426,9 @@ static int mmc_compare_ext_csds(struct rt_mmcsd_card *card, (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); @@ -438,7 +457,9 @@ static int mmc_select_bus_width(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd) int err = 0, ddr = 0; if (GET_BITS(card->resp_csd, 122, 4) < 4) + { return 0; + } if (card->flags & CARD_FLAG_HIGHSPEED_DDR) { @@ -471,7 +492,9 @@ static int mmc_select_bus_width(struct rt_mmcsd_card *card, rt_uint8_t *ext_csd) 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); @@ -535,22 +558,30 @@ rt_err_t mmc_send_op_cond(struct rt_mmcsd_host *host, { err = mmcsd_send_cmd(host, &cmd, 3); if (err) + { break; + } /* if we're just probing, do a single pass */ if (ocr == 0) + { break; + } /* otherwise wait until reset completes */ if (controller_is_spi(host)) { if (!(cmd.resp[0] & R1_SPI_IDLE)) + { break; + } } else { if (cmd.resp[0] & CARD_BUSY) + { break; + } } err = -RT_ETIMEOUT; @@ -559,7 +590,9 @@ rt_err_t mmc_send_op_cond(struct rt_mmcsd_host *host, } if (rocr && !controller_is_spi(host)) + { *rocr = cmd.resp[0]; + } return err; } @@ -577,7 +610,9 @@ static rt_err_t mmc_set_card_addr(struct rt_mmcsd_host *host, rt_uint32_t rca) err = mmcsd_send_cmd(host, &cmd, 3); if (err) + { return err; + } return 0; } @@ -589,7 +624,9 @@ static int mmc_select_hs200(struct rt_mmcsd_card *card) ret = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS200); if (ret) + { return ret; + } mmcsd_set_timing(card->host, MMCSD_TIMING_MMC_HS200); mmcsd_set_clock(card->host, card->max_data_rate); @@ -714,21 +751,31 @@ 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; + } if (controller_is_spi(host)) { err = mmcsd_spi_use_crc(host, 1); if (err) + { goto err1; + } } if (controller_is_spi(host)) + { err = mmcsd_get_cid(host, resp); + } else + { err = mmcsd_all_get_cid(host, resp); + } if (err) + { goto err; + } card = rt_malloc(sizeof(struct rt_mmcsd_card)); if (!card) @@ -751,24 +798,32 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host, { err = mmc_set_card_addr(host, card->rca); if (err) + { goto err1; + } mmcsd_set_bus_mode(host, MMCSD_BUSMODE_PUSHPULL); } err = mmcsd_get_csd(card, card->resp_csd); if (err) + { goto err1; + } err = mmcsd_parse_csd(card); if (err) + { goto err1; + } if (!controller_is_spi(host)) { err = mmcsd_select_card(card); if (err) + { goto err1; + } } /* @@ -777,10 +832,14 @@ 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; + } err = mmc_parse_ext_csd(card, ext_csd); if (err) + { goto err1; + } /* If doing byte addressing, check if required to do sector * addressing. Handle the case of <2GB cards needing sector @@ -788,7 +847,9 @@ static rt_int32_t mmcsd_mmc_init_card(struct rt_mmcsd_host *host, * ocr register has bit 30 set for sector addressing. */ if (!(card->flags & CARD_FLAG_SDHC) && (rocr & (1 << 30))) + { card->flags |= CARD_FLAG_SDHC; + } /*switch bus width and bus mode*/ err = mmc_select_bus_width(card, ext_csd); @@ -839,7 +900,9 @@ rt_int32_t init_mmc(struct rt_mmcsd_host *host, rt_uint32_t ocr) { err = mmcsd_spi_read_ocr(host, 0, &ocr); if (err) + { goto err; + } } current_ocr = mmcsd_select_voltage(host, ocr); @@ -858,13 +921,17 @@ rt_int32_t init_mmc(struct rt_mmcsd_host *host, rt_uint32_t ocr) */ err = mmcsd_mmc_init_card(host, current_ocr); if (err) + { goto err; + } mmcsd_host_unlock(host); err = rt_mmcsd_blk_probe(host->card); if (err) + { goto remove_card; + } mmcsd_host_lock(host); return 0; diff --git a/components/drivers/sdio/dev_mmcsd_core.c b/components/drivers/sdio/dev_mmcsd_core.c index 9f80bb9b60b1..31fdea978cbc 100644 --- a/components/drivers/sdio/dev_mmcsd_core.c +++ b/components/drivers/sdio/dev_mmcsd_core.c @@ -15,11 +15,11 @@ #include #include -#define DBG_TAG "SDIO" +#define DBG_TAG "SDIO" #ifdef RT_SDIO_DEBUG -#define DBG_LVL DBG_LOG +#define DBG_LVL DBG_LOG #else -#define DBG_LVL DBG_INFO +#define DBG_LVL DBG_INFO #endif /* RT_SDIO_DEBUG */ #include @@ -28,16 +28,16 @@ #endif #ifndef RT_MMCSD_THREAD_PRIORITY #if (RT_THREAD_PRIORITY_MAX == 32) -#define RT_MMCSD_THREAD_PRIORITY 0x16 +#define RT_MMCSD_THREAD_PRIORITY 0x16 #else -#define RT_MMCSD_THREAD_PRIORITY 0x40 +#define RT_MMCSD_THREAD_PRIORITY 0x40 #endif #endif //static struct rt_semaphore mmcsd_sem; static struct rt_thread mmcsd_detect_thread; static rt_uint8_t mmcsd_stack[RT_MMCSD_STACK_SIZE]; -static struct rt_mailbox mmcsd_detect_mb; +static struct rt_mailbox mmcsd_detect_mb; static rt_uint32_t mmcsd_detect_mb_pool[4]; static struct rt_mailbox mmcsd_hotpluge_mb; static rt_uint32_t mmcsd_hotpluge_mb_pool[4]; @@ -80,15 +80,12 @@ 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)); } rt_int32_t mmcsd_send_cmd(struct rt_mmcsd_host *host, - struct rt_mmcsd_cmd *cmd, - int retries) + struct rt_mmcsd_cmd *cmd, + int retries) { struct rt_mmcsd_req req; @@ -135,8 +132,8 @@ rt_int32_t mmcsd_go_idle(struct rt_mmcsd_host *host) } rt_int32_t mmcsd_spi_read_ocr(struct rt_mmcsd_host *host, - rt_int32_t high_capacity, - rt_uint32_t *ocr) + rt_int32_t high_capacity, + rt_uint32_t *ocr) { struct rt_mmcsd_cmd cmd; rt_int32_t err; @@ -167,7 +164,9 @@ rt_int32_t mmcsd_all_get_cid(struct rt_mmcsd_host *host, rt_uint32_t *cid) err = mmcsd_send_cmd(host, &cmd, 3); if (err) + { return err; + } rt_memcpy(cid, cmd.resp, sizeof(rt_uint32_t) * 4); @@ -185,7 +184,9 @@ rt_int32_t mmcsd_get_cid(struct rt_mmcsd_host *host, rt_uint32_t *cid) if (!controller_is_spi(host)) { if (!host->card) + { return -RT_ERROR; + } rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); cmd.cmd_code = SEND_CID; @@ -193,7 +194,9 @@ rt_int32_t mmcsd_get_cid(struct rt_mmcsd_host *host, rt_uint32_t *cid) cmd.flags = RESP_R2 | CMD_AC; err = mmcsd_send_cmd(host, &cmd, 3); if (err) + { return err; + } rt_memcpy(cid, cmd.resp, sizeof(rt_uint32_t) * 4); @@ -246,7 +249,9 @@ rt_int32_t mmcsd_get_cid(struct rt_mmcsd_host *host, rt_uint32_t *cid) } for (i = 0; i < 4; i++) + { cid[i] = buf[i]; + } rt_free(buf); return 0; @@ -269,7 +274,9 @@ rt_int32_t mmcsd_get_csd(struct rt_mmcsd_card *card, rt_uint32_t *csd) cmd.flags = RESP_R2 | CMD_AC; err = mmcsd_send_cmd(card->host, &cmd, 3); if (err) + { return err; + } rt_memcpy(csd, cmd.resp, sizeof(rt_uint32_t) * 4); @@ -323,7 +330,9 @@ rt_int32_t mmcsd_get_csd(struct rt_mmcsd_card *card, rt_uint32_t *csd) } for (i = 0; i < 4; i++) + { csd[i] = buf[i]; + } rt_free(buf); return 0; @@ -352,7 +361,9 @@ static rt_int32_t _mmcsd_select_card(struct rt_mmcsd_host *host, err = mmcsd_send_cmd(host, &cmd, 3); if (err) + { return err; + } return 0; } @@ -380,7 +391,9 @@ rt_int32_t mmcsd_spi_use_crc(struct rt_mmcsd_host *host, rt_int32_t use_crc) err = mmcsd_send_cmd(host, &cmd, 0); if (!err) + { host->spi_use_crc = use_crc; + } return err; } @@ -446,7 +459,7 @@ void mmcsd_set_timing(struct rt_mmcsd_host *host, rt_uint32_t timing) mmcsd_set_iocfg(host); } -void mmcsd_set_data_timeout(struct rt_mmcsd_data *data, +void mmcsd_set_data_timeout(struct rt_mmcsd_data *data, const struct rt_mmcsd_card *card) { rt_uint32_t mult; @@ -469,7 +482,9 @@ void mmcsd_set_data_timeout(struct rt_mmcsd_data *data, * the r2w factor for writes. */ if (data->flags & DATA_DIR_WRITE) + { mult <<= card->csd.r2w_factor; + } data->timeout_ns = card->tacc_ns * mult; data->timeout_clks = card->tacc_clks * mult; @@ -486,13 +501,17 @@ void mmcsd_set_data_timeout(struct rt_mmcsd_data *data, (card->host->io_cfg.clock / 1000); if (data->flags & DATA_DIR_WRITE) + { /* * The limit is really 250 ms, but that is * insufficient for some crappy cards. */ limit_us = 300000; + } else + { limit_us = 100000; + } /* * SDHC cards always use these fixed values. @@ -509,12 +528,16 @@ void mmcsd_set_data_timeout(struct rt_mmcsd_data *data, if (data->flags & DATA_DIR_WRITE) { if (data->timeout_ns < 1000000000) + { data->timeout_ns = 1000000000; /* 1s */ + } } else { if (data->timeout_ns < 100000000) - data->timeout_ns = 100000000; /* 100ms */ + { + data->timeout_ns = 100000000; /* 100ms */ + } } } } @@ -683,36 +706,202 @@ rt_err_t mmcsd_set_uhs_voltage(struct rt_mmcsd_host *host, rt_uint32_t ocr) return err; } -static const rt_uint8_t tuning_blk_pattern_4bit[] = -{ - 0xff, 0x0f, 0xff, 0x00, 0xff, 0xcc, 0xc3, 0xcc, - 0xc3, 0x3c, 0xcc, 0xff, 0xfe, 0xff, 0xfe, 0xef, - 0xff, 0xdf, 0xff, 0xdd, 0xff, 0xfb, 0xff, 0xfb, - 0xbf, 0xff, 0x7f, 0xff, 0x77, 0xf7, 0xbd, 0xef, - 0xff, 0xf0, 0xff, 0xf0, 0x0f, 0xfc, 0xcc, 0x3c, - 0xcc, 0x33, 0xcc, 0xcf, 0xff, 0xef, 0xff, 0xee, - 0xff, 0xfd, 0xff, 0xfd, 0xdf, 0xff, 0xbf, 0xff, - 0xbb, 0xff, 0xf7, 0xff, 0xf7, 0x7f, 0x7b, 0xde, +static const rt_uint8_t tuning_blk_pattern_4bit[] = { + 0xff, + 0x0f, + 0xff, + 0x00, + 0xff, + 0xcc, + 0xc3, + 0xcc, + 0xc3, + 0x3c, + 0xcc, + 0xff, + 0xfe, + 0xff, + 0xfe, + 0xef, + 0xff, + 0xdf, + 0xff, + 0xdd, + 0xff, + 0xfb, + 0xff, + 0xfb, + 0xbf, + 0xff, + 0x7f, + 0xff, + 0x77, + 0xf7, + 0xbd, + 0xef, + 0xff, + 0xf0, + 0xff, + 0xf0, + 0x0f, + 0xfc, + 0xcc, + 0x3c, + 0xcc, + 0x33, + 0xcc, + 0xcf, + 0xff, + 0xef, + 0xff, + 0xee, + 0xff, + 0xfd, + 0xff, + 0xfd, + 0xdf, + 0xff, + 0xbf, + 0xff, + 0xbb, + 0xff, + 0xf7, + 0xff, + 0xf7, + 0x7f, + 0x7b, + 0xde, }; -static const rt_uint8_t tuning_blk_pattern_8bit[] = -{ - 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, - 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc, 0xcc, - 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff, 0xff, - 0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee, 0xff, - 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd, 0xdd, - 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb, - 0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff, 0xff, - 0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee, 0xff, - 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, - 0x00, 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc, - 0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff, - 0xff, 0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee, - 0xff, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd, - 0xdd, 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff, - 0xbb, 0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff, - 0xff, 0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee, +static const rt_uint8_t tuning_blk_pattern_8bit[] = { + 0xff, + 0xff, + 0x00, + 0xff, + 0xff, + 0xff, + 0x00, + 0x00, + 0xff, + 0xff, + 0xcc, + 0xcc, + 0xcc, + 0x33, + 0xcc, + 0xcc, + 0xcc, + 0x33, + 0x33, + 0xcc, + 0xcc, + 0xcc, + 0xff, + 0xff, + 0xff, + 0xee, + 0xff, + 0xff, + 0xff, + 0xee, + 0xee, + 0xff, + 0xff, + 0xff, + 0xdd, + 0xff, + 0xff, + 0xff, + 0xdd, + 0xdd, + 0xff, + 0xff, + 0xff, + 0xbb, + 0xff, + 0xff, + 0xff, + 0xbb, + 0xbb, + 0xff, + 0xff, + 0xff, + 0x77, + 0xff, + 0xff, + 0xff, + 0x77, + 0x77, + 0xff, + 0x77, + 0xbb, + 0xdd, + 0xee, + 0xff, + 0xff, + 0xff, + 0xff, + 0x00, + 0xff, + 0xff, + 0xff, + 0x00, + 0x00, + 0xff, + 0xff, + 0xcc, + 0xcc, + 0xcc, + 0x33, + 0xcc, + 0xcc, + 0xcc, + 0x33, + 0x33, + 0xcc, + 0xcc, + 0xcc, + 0xff, + 0xff, + 0xff, + 0xee, + 0xff, + 0xff, + 0xff, + 0xee, + 0xee, + 0xff, + 0xff, + 0xff, + 0xdd, + 0xff, + 0xff, + 0xff, + 0xdd, + 0xdd, + 0xff, + 0xff, + 0xff, + 0xbb, + 0xff, + 0xff, + 0xff, + 0xbb, + 0xbb, + 0xff, + 0xff, + 0xff, + 0x77, + 0xff, + 0xff, + 0xff, + 0x77, + 0x77, + 0xff, + 0x77, + 0xbb, + 0xdd, + 0xee, }; rt_err_t mmcsd_send_tuning(struct rt_mmcsd_host *host, rt_uint32_t opcode, rt_err_t *cmd_error) @@ -721,9 +910,9 @@ rt_err_t mmcsd_send_tuning(struct rt_mmcsd_host *host, rt_uint32_t opcode, rt_er int size; rt_uint8_t *data_buf; const rt_uint8_t *tuning_block_pattern; - struct rt_mmcsd_req req = {}; - struct rt_mmcsd_cmd cmd = {}; - struct rt_mmcsd_data data = {}; + struct rt_mmcsd_req req; + struct rt_mmcsd_cmd cmd; + struct rt_mmcsd_data data; struct rt_mmcsd_io_cfg *io_cfg = &host->io_cfg; if (io_cfg->bus_width == MMCSD_BUS_WIDTH_8) @@ -801,7 +990,7 @@ rt_err_t mmcsd_send_tuning(struct rt_mmcsd_host *host, rt_uint32_t opcode, rt_er rt_err_t mmcsd_send_abort_tuning(struct rt_mmcsd_host *host, rt_uint32_t opcode) { - struct rt_mmcsd_cmd cmd = {}; + struct rt_mmcsd_cmd cmd = { 0 }; /* * eMMC specification specifies that CMD12 can be used to stop a tuning @@ -913,8 +1102,8 @@ void mmcsd_change(struct rt_mmcsd_host *host) void mmcsd_detect(void *param) { struct rt_mmcsd_host *host; - rt_uint32_t ocr; - rt_int32_t err; + rt_uint32_t ocr; + rt_int32_t err; while (1) { @@ -932,7 +1121,9 @@ void mmcsd_detect(void *param) if (!err) { if (init_sdio(host, ocr)) + { mmcsd_power_off(host); + } mmcsd_host_unlock(host); continue; } @@ -944,7 +1135,9 @@ void mmcsd_detect(void *param) if (!err) { if (init_sd(host, ocr)) + { mmcsd_power_off(host); + } mmcsd_host_unlock(host); rt_mb_send(&mmcsd_hotpluge_mb, (rt_ubase_t)host); continue; @@ -957,7 +1150,9 @@ void mmcsd_detect(void *param) if (!err) { if (init_mmc(host, ocr)) + { mmcsd_power_off(host); + } mmcsd_host_unlock(host); rt_mb_send(&mmcsd_hotpluge_mb, (rt_ubase_t)host); continue; @@ -1029,14 +1224,21 @@ rt_int32_t mmcsd_excute_tuning(struct rt_mmcsd_card *card) rt_int32_t opcode; if (!host->ops->execute_tuning) + { return RT_EOK; + } if (card->card_type == CARD_TYPE_MMC) + { opcode = SEND_TUNING_BLOCK_HS200; + } else + { opcode = SEND_TUNING_BLOCK; + } - return host->ops->execute_tuning(host, opcode);; + return host->ops->execute_tuning(host, opcode); + ; } int rt_mmcsd_core_init(void) diff --git a/components/drivers/sdio/dev_sd.c b/components/drivers/sdio/dev_sd.c index d0193bdd1d76..634e42998e59 100644 --- a/components/drivers/sdio/dev_sd.c +++ b/components/drivers/sdio/dev_sd.c @@ -12,52 +12,85 @@ #include #include -#define DBG_TAG "SDIO" +#define DBG_TAG "SDIO" #ifdef RT_SDIO_DEBUG -#define DBG_LVL DBG_LOG +#define DBG_LVL DBG_LOG #else -#define DBG_LVL DBG_INFO +#define DBG_LVL DBG_INFO #endif /* RT_SDIO_DEBUG */ #include -static const rt_uint32_t tran_unit[] = -{ +static const rt_uint32_t tran_unit[] = { 10000, 100000, 1000000, 10000000, - 0, 0, 0, 0 + 0, 0, 0, 0 }; -static const rt_uint8_t tran_value[] = -{ - 0, 10, 12, 13, 15, 20, 25, 30, - 35, 40, 45, 50, 55, 60, 70, 80, +static const rt_uint8_t tran_value[] = { + 0, + 10, + 12, + 13, + 15, + 20, + 25, + 30, + 35, + 40, + 45, + 50, + 55, + 60, + 70, + 80, }; -static const rt_uint32_t tacc_uint[] = -{ - 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, +static const rt_uint32_t tacc_uint[] = { + 1, + 10, + 100, + 1000, + 10000, + 100000, + 1000000, + 10000000, }; -static const rt_uint8_t tacc_value[] = -{ - 0, 10, 12, 13, 15, 20, 25, 30, - 35, 40, 45, 50, 55, 60, 70, 80, +static const rt_uint8_t tacc_value[] = { + 0, + 10, + 12, + 13, + 15, + 20, + 25, + 30, + 35, + 40, + 45, + 50, + 55, + 60, + 70, + 80, }; rt_inline rt_uint32_t GET_BITS(rt_uint32_t *resp, - rt_uint32_t start, - rt_uint32_t size) + rt_uint32_t start, + rt_uint32_t size) { - const rt_int32_t __size = size; - const rt_uint32_t __mask = (__size < 32 ? 1U << __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 ? 1U << __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; } static rt_int32_t mmcsd_parse_csd(struct rt_mmcsd_card *card) @@ -91,8 +124,8 @@ static rt_int32_t mmcsd_parse_csd(struct rt_mmcsd_card *card) card->card_capacity *= card->card_blksize; card->card_capacity >>= 10; /* unit:KB */ 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]; + 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]; break; case 1: @@ -123,7 +156,7 @@ static rt_int32_t mmcsd_parse_csd(struct rt_mmcsd_card *card) card->card_sec_cnt = card->card_capacity * 2; card->tacc_clks = 0; card->tacc_ns = 0; - card->max_data_rate = tran_unit[csd->tran_speed&0x07] * tran_value[(csd->tran_speed&0x78)>>3]; + card->max_data_rate = tran_unit[csd->tran_speed & 0x07] * tran_value[(csd->tran_speed & 0x78) >> 3]; break; default: @@ -158,7 +191,7 @@ static rt_int32_t mmcsd_switch(struct rt_mmcsd_card *card) struct rt_mmcsd_data data; rt_uint8_t *buf; - buf = (rt_uint8_t*)rt_malloc(64); + buf = (rt_uint8_t *)rt_malloc(64); if (!buf) { LOG_E("alloc memory failed!"); @@ -167,9 +200,13 @@ static rt_int32_t mmcsd_switch(struct rt_mmcsd_card *card) } if (card->card_type != CARD_TYPE_SD) + { goto err; + } if (card->scr.sd_version < SCR_SPEC_VER_1) + { goto err; + } rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); @@ -199,7 +236,9 @@ static rt_int32_t mmcsd_switch(struct rt_mmcsd_card *card) } if (buf[13] & 0x02) + { card->hs_max_data_rate = 50000000; + } rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); @@ -252,7 +291,7 @@ static rt_int32_t mmcsd_switch(struct rt_mmcsd_card *card) goto err; } - switch(switch_func_timing) + switch (switch_func_timing) { case SD_SWITCH_FUNC_TIMING_SDR104: card->flags |= CARD_FLAG_SDR104; @@ -307,9 +346,13 @@ static rt_int32_t mmcsd_switch(struct rt_mmcsd_card *card) err1: if (cmd.err) + { err = cmd.err; + } if (data.err) + { err = data.err; + } return err; } @@ -318,7 +361,7 @@ static rt_err_t mmcsd_app_cmd(struct rt_mmcsd_host *host, struct rt_mmcsd_card *card) { rt_err_t err; - struct rt_mmcsd_cmd cmd = {0}; + struct rt_mmcsd_cmd cmd = { 0 }; cmd.cmd_code = APP_CMD; @@ -335,11 +378,15 @@ static rt_err_t mmcsd_app_cmd(struct rt_mmcsd_host *host, err = mmcsd_send_cmd(host, &cmd, 0); if (err) + { return err; + } /* Check that card supported application commands */ if (!controller_is_spi(host) && !(cmd.resp[0] & R1_APP_CMD)) + { return -RT_ERROR; + } return RT_EOK; } @@ -347,8 +394,8 @@ static rt_err_t mmcsd_app_cmd(struct rt_mmcsd_host *host, rt_err_t mmcsd_send_app_cmd(struct rt_mmcsd_host *host, struct rt_mmcsd_card *card, - struct rt_mmcsd_cmd *cmd, - int retry) + struct rt_mmcsd_cmd *cmd, + int retry) { struct rt_mmcsd_req req; int i; @@ -371,7 +418,9 @@ rt_err_t mmcsd_send_app_cmd(struct rt_mmcsd_host *host, if (controller_is_spi(host)) { if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND) + { break; + } } continue; } @@ -387,13 +436,17 @@ rt_err_t mmcsd_send_app_cmd(struct rt_mmcsd_host *host, err = cmd->err; if (!cmd->err) + { break; + } /* no point in retrying illegal APP commands */ if (controller_is_spi(host)) { if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND) + { break; + } } } @@ -424,14 +477,16 @@ rt_err_t mmcsd_app_set_bus_width(struct rt_mmcsd_card *card, rt_int32_t width) err = mmcsd_send_app_cmd(card->host, card, &cmd, 3); if (err) + { return err; + } return RT_EOK; } rt_err_t mmcsd_send_app_op_cond(struct rt_mmcsd_host *host, - rt_uint32_t ocr, - rt_uint32_t *rocr) + rt_uint32_t ocr, + rt_uint32_t *rocr) { struct rt_mmcsd_cmd cmd; rt_uint32_t i; @@ -441,31 +496,43 @@ rt_err_t mmcsd_send_app_op_cond(struct rt_mmcsd_host *host, cmd.cmd_code = SD_APP_OP_COND; if (controller_is_spi(host)) + { cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */ + } else + { cmd.arg = ocr; + } cmd.flags = RESP_SPI_R1 | RESP_R3 | CMD_BCR; for (i = 1000; i; i--) { err = mmcsd_send_app_cmd(host, RT_NULL, &cmd, 3); if (err) + { break; + } /* if we're just probing, do a single pass */ if (ocr == 0) + { break; + } /* otherwise wait until reset completes */ if (controller_is_spi(host)) { if (!(cmd.resp[0] & R1_SPI_IDLE)) + { break; + } } else { if (cmd.resp[0] & CARD_BUSY) + { break; + } } err = -RT_ETIMEOUT; @@ -474,7 +541,9 @@ rt_err_t mmcsd_send_app_op_cond(struct rt_mmcsd_host *host, } if (rocr && !controller_is_spi(host)) + { *rocr = cmd.resp[0]; + } return err; } @@ -496,15 +565,23 @@ rt_err_t mmcsd_send_if_cond(struct rt_mmcsd_host *host, rt_uint32_t ocr) err = mmcsd_send_cmd(host, &cmd, 0); if (err) + { return err; + } if (controller_is_spi(host)) + { pattern = cmd.resp[1] & 0xFF; + } else + { pattern = cmd.resp[0] & 0xFF; + } if (pattern != 0xAA) + { return -RT_ERROR; + } return RT_EOK; } @@ -522,18 +599,19 @@ rt_err_t mmcsd_get_card_addr(struct rt_mmcsd_host *host, rt_uint32_t *rca) err = mmcsd_send_cmd(host, &cmd, 3); if (err) + { return err; + } *rca = cmd.resp[0] >> 16; return RT_EOK; } -#define be32_to_cpu(x) ((rt_uint32_t)( \ - (((rt_uint32_t)(x) & (rt_uint32_t)0x000000ffUL) << 24) | \ - (((rt_uint32_t)(x) & (rt_uint32_t)0x0000ff00UL) << 8) | \ - (((rt_uint32_t)(x) & (rt_uint32_t)0x00ff0000UL) >> 8) | \ - (((rt_uint32_t)(x) & (rt_uint32_t)0xff000000UL) >> 24))) +#define be32_to_cpu(x) ((rt_uint32_t)((((rt_uint32_t)(x) & (rt_uint32_t)0x000000ffUL) << 24) | \ + (((rt_uint32_t)(x) & (rt_uint32_t)0x0000ff00UL) << 8) | \ + (((rt_uint32_t)(x) & (rt_uint32_t)0x00ff0000UL) >> 8) | \ + (((rt_uint32_t)(x) & (rt_uint32_t)0xff000000UL) >> 24))) rt_int32_t mmcsd_get_scr(struct rt_mmcsd_card *card, rt_uint32_t *scr) { @@ -544,7 +622,9 @@ rt_int32_t mmcsd_get_scr(struct rt_mmcsd_card *card, rt_uint32_t *scr) err = mmcsd_app_cmd(card->host, card); if (err) + { return err; + } rt_memset(&req, 0, sizeof(struct rt_mmcsd_req)); rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); @@ -567,9 +647,13 @@ rt_int32_t mmcsd_get_scr(struct rt_mmcsd_card *card, rt_uint32_t *scr) mmcsd_send_request(card->host, &req); if (cmd.err) + { return cmd.err; + } if (data.err) + { return data.err; + } scr[0] = be32_to_cpu(scr[0]); scr[1] = be32_to_cpu(scr[1]); @@ -586,7 +670,9 @@ static rt_err_t mmcsd_read_sd_status(struct rt_mmcsd_card *card, rt_uint32_t *sd err = mmcsd_app_cmd(card->host, card); if (err) + { return err; + } rt_memset(&req, 0, sizeof(struct rt_mmcsd_req)); rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); @@ -609,18 +695,22 @@ static rt_err_t mmcsd_read_sd_status(struct rt_mmcsd_card *card, rt_uint32_t *sd mmcsd_send_request(card->host, &req); if (cmd.err) + { return cmd.err; + } if (data.err) + { return data.err; + } /* Convert endian */ - for (uint32_t i=0; i < 8; i++) + for (uint32_t i = 0; i < 8; i++) { uint32_t tmp = sd_status[i]; sd_status[i] = sd_status[15 - i]; sd_status[15 - i] = tmp; } - for (uint32_t i=0; i < 16; i++) + for (uint32_t i = 0; i < 16; i++) { sd_status[i] = be32_to_cpu(sd_status[i]); } @@ -630,7 +720,7 @@ static rt_err_t mmcsd_read_sd_status(struct rt_mmcsd_card *card, rt_uint32_t *sd } static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host, - rt_uint32_t ocr) + rt_uint32_t ocr) { struct rt_mmcsd_card *card; rt_int32_t err; @@ -647,7 +737,9 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host, */ err = mmcsd_send_if_cond(host, ocr); if (!err) + { ocr |= 1 << 30; + } /* Switch to UHS voltage if both Host and the Card support this feature */ if (((host->valid_ocr & VDD_165_195) != 0) && (host->ops->signal_voltage_switch != RT_NULL)) @@ -656,7 +748,9 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host, } err = mmcsd_send_app_op_cond(host, ocr, &ocr); if (err) + { goto err2; + } /* Select voltage */ if (ocr & OCR_S18R) @@ -664,15 +758,23 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host, ocr = VDD_165_195; err = mmcsd_set_uhs_voltage(host, ocr); if (err) + { goto err2; + } } if (controller_is_spi(host)) + { err = mmcsd_get_cid(host, resp); + } else + { err = mmcsd_all_get_cid(host, resp); + } if (err) + { goto err2; + } card = rt_malloc(sizeof(struct rt_mmcsd_card)); if (!card) @@ -694,29 +796,39 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host, { err = mmcsd_get_card_addr(host, &card->rca); if (err) + { goto err1; + } mmcsd_set_bus_mode(host, MMCSD_BUSMODE_PUSHPULL); } err = mmcsd_get_csd(card, card->resp_csd); if (err) + { goto err1; + } err = mmcsd_parse_csd(card); if (err) + { goto err1; + } if (!controller_is_spi(host)) { err = mmcsd_select_card(card); if (err) + { goto err1; + } } err = mmcsd_get_scr(card, card->resp_scr); if (err) + { goto err1; + } mmcsd_parse_scr(card); @@ -724,7 +836,9 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host, { err = mmcsd_spi_use_crc(host, 1); if (err) + { goto err1; + } } mmcsd_set_timing(host, MMCSD_TIMING_LEGACY); @@ -734,7 +848,9 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host, { err = mmcsd_app_set_bus_width(card, MMCSD_BUS_WIDTH_4); if (err) + { goto err1; + } mmcsd_set_bus_width(host, MMCSD_BUS_WIDTH_4); } @@ -743,8 +859,10 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host, union rt_sd_status sd_status; err = mmcsd_read_sd_status(card, sd_status.status_words); if (err) + { goto err1; - if ((sd_status.uhs_speed_grade > 0) && (ocr & VDD_165_195)) + } + if ((RT_SD_STATUS_FIELD(sd_status, uhs_speed_grade) > 0) && (ocr & VDD_165_195)) { /* Assume the card supports all UHS-I modes because we cannot find any mainstreaming card * that can support only part of the following modes. @@ -757,7 +875,9 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host, */ err = mmcsd_switch(card); if (err) + { goto err1; + } /* set bus speed */ max_data_rate = 0U; @@ -788,7 +908,7 @@ static rt_int32_t mmcsd_sd_init_card(struct rt_mmcsd_host *host, rt_int32_t init_sd(struct rt_mmcsd_host *host, rt_uint32_t ocr) { rt_int32_t err = -RT_EINVAL; - rt_uint32_t current_ocr; + rt_uint32_t current_ocr; /* * We need to get OCR a different way for SPI. */ @@ -798,7 +918,9 @@ rt_int32_t init_sd(struct rt_mmcsd_host *host, rt_uint32_t ocr) err = mmcsd_spi_read_ocr(host, 0, &ocr); if (err) + { goto _err; + } } current_ocr = mmcsd_select_voltage(host, ocr); @@ -817,13 +939,17 @@ rt_int32_t init_sd(struct rt_mmcsd_host *host, rt_uint32_t ocr) */ err = mmcsd_sd_init_card(host, current_ocr); if (err) + { goto _err; + } mmcsd_host_unlock(host); err = rt_mmcsd_blk_probe(host->card); if (err) + { goto remove_card; + } mmcsd_host_lock(host); return 0;