[U-Boot] [RFC 0/3] mmc inizialization steps enhanced
I have added some better inizializations and status check. I have created following patchset for Davinci dm365 against git://arago-project.org/git/projects/u-boot-davinci.git git tree. There are two commits more in that tree, but they are not in conflict with my work. I have finally tested this series on basi board, based on Davinci dm365, that contains an eMMC device.
Raffaele Recalcati (3): mmc: checking status after commands with R1b response mmc: SEND_OP_COND considers card capabilities (voltage) mmc: trace added
drivers/mmc/mmc.c | 198 +++++++++++++++++++++++++++++++++++++++++++++-------- include/mmc.h | 6 ++ 2 files changed, 174 insertions(+), 30 deletions(-)
From: Raffaele Recalcati raffaele.recalcati@bticino.it
It is a recommended to check card status after these kind of commands. This is done using CMD13 (SEND_STATUS) JEDEC command. In case of error the previous command is issued again.
Signed-off-by: Raffaele Recalcati raffaele.recalcati@bticino.it --- drivers/mmc/mmc.c | 106 +++++++++++++++++++++++++++++++++++++++-------------- include/mmc.h | 4 ++ 2 files changed, 82 insertions(+), 28 deletions(-)
diff --git a/drivers/mmc/mmc.c b/drivers/mmc/mmc.c index 6805b33..53ed36f 100644 --- a/drivers/mmc/mmc.c +++ b/drivers/mmc/mmc.c @@ -48,6 +48,32 @@ int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data) return mmc->send_cmd(mmc, cmd, data); }
+int mmc_send_status(struct mmc *mmc) +{ + struct mmc_cmd cmd; + int err; + int timeout = 1000; + int status; + + cmd.cmdidx = MMC_CMD_SEND_STATUS; + cmd.resp_type = MMC_RSP_R1; + cmd.cmdarg = 0; + cmd.flags = 0; + + do { + err = mmc_send_cmd(mmc, &cmd, NULL); + if (err) + return err; + udelay(1000); + if (cmd.response[0] & MMC_STATUS_MASK) { + printf("Status Error: 0x%08X\n", cmd.response[0]); + return 1; + } + } while (!(cmd.response[0] & MMC_STATUS_RDY_FOR_DATA) && timeout--); + + return 0; +} + int mmc_set_blocklen(struct mmc *mmc, int len) { struct mmc_cmd cmd; @@ -82,6 +108,7 @@ mmc_write_blocks(struct mmc *mmc, ulong start, lbaint_t blkcnt, const void*src) { struct mmc_cmd cmd; struct mmc_data data; + int timeout = 1000;
if ((start + blkcnt) > mmc->block_dev.lba) { printf("MMC: block number 0x%lx exceeds max(0x%lx)\n", @@ -113,14 +140,22 @@ mmc_write_blocks(struct mmc *mmc, ulong start, lbaint_t blkcnt, const void*src) }
if (blkcnt > 1) { - cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION; - cmd.cmdarg = 0; - cmd.resp_type = MMC_RSP_R1b; - cmd.flags = 0; - if (mmc_send_cmd(mmc, &cmd, NULL)) { - printf("mmc fail to send stop cmd\n"); - return 0; - } + do { + cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION; + cmd.cmdarg = 0; + cmd.resp_type = MMC_RSP_R1b; + cmd.flags = 0; + if (mmc_send_cmd(mmc, &cmd, NULL)) { + printf("mmc fail to send stop cmd\n"); + return 0; + } + + udelay(1000); + + } while (mmc_send_status(mmc) && timeout--); + + if (!timeout) + printf("mmc send status failed\n"); }
return blkcnt; @@ -158,6 +193,7 @@ int mmc_read_blocks(struct mmc *mmc, void *dst, ulong start, lbaint_t blkcnt) { struct mmc_cmd cmd; struct mmc_data data; + int timeout = 1000;
if (blkcnt > 1) cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK; @@ -181,14 +217,17 @@ int mmc_read_blocks(struct mmc *mmc, void *dst, ulong start, lbaint_t blkcnt) return 0;
if (blkcnt > 1) { - cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION; - cmd.cmdarg = 0; - cmd.resp_type = MMC_RSP_R1b; - cmd.flags = 0; - if (mmc_send_cmd(mmc, &cmd, NULL)) { - printf("mmc fail to send stop cmd\n"); - return 0; - } + do { + cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION; + cmd.cmdarg = 0; + cmd.resp_type = MMC_RSP_R1b; + cmd.flags = 0; + if (mmc_send_cmd(mmc, &cmd, NULL)) { + printf("mmc fail to send stop cmd\n"); + return 0; + } + udelay(1000); + } while (mmc_send_status(mmc) && timeout--); }
return blkcnt; @@ -369,15 +408,23 @@ int mmc_send_ext_csd(struct mmc *mmc, char *ext_csd) int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value) { struct mmc_cmd cmd; + int timeout = 1000; + int ret;
- cmd.cmdidx = MMC_CMD_SWITCH; - cmd.resp_type = MMC_RSP_R1b; - cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | - (index << 16) | - (value << 8); - cmd.flags = 0; + do { + cmd.cmdidx = MMC_CMD_SWITCH; + cmd.resp_type = MMC_RSP_R1b; + cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | + (index << 16) | + (value << 8); + cmd.flags = 0; + + ret = mmc_send_cmd(mmc, &cmd, NULL); + udelay(1000); + } while (mmc_send_status(mmc) && timeout--); + + return ret;
- return mmc_send_cmd(mmc, &cmd, NULL); }
int mmc_change_freq(struct mmc *mmc) @@ -610,6 +657,7 @@ int mmc_startup(struct mmc *mmc) u64 cmult, csize; struct mmc_cmd cmd; char ext_csd[512]; + int timeout = 1000;
/* Put the Card in Identify Mode */ cmd.cmdidx = MMC_CMD_ALL_SEND_CID; @@ -716,11 +764,13 @@ int mmc_startup(struct mmc *mmc) mmc->write_bl_len = 512;
/* Select the card, and put it into Transfer Mode */ - cmd.cmdidx = MMC_CMD_SELECT_CARD; - cmd.resp_type = MMC_RSP_R1b; - cmd.cmdarg = mmc->rca << 16; - cmd.flags = 0; - err = mmc_send_cmd(mmc, &cmd, NULL); + do { + cmd.cmdidx = MMC_CMD_SELECT_CARD; + cmd.resp_type = MMC_RSP_R1b; + cmd.cmdarg = mmc->rca << 16; + cmd.flags = 0; + err = mmc_send_cmd(mmc, &cmd, NULL); + } while (mmc_send_status(mmc) && timeout--);
if (err) return err; diff --git a/include/mmc.h b/include/mmc.h index fcd0fd1..4ee8e1c 100644 --- a/include/mmc.h +++ b/include/mmc.h @@ -94,6 +94,10 @@ #define OCR_BUSY 0x80000000 #define OCR_HCS 0x40000000
+#define MMC_STATUS_MASK (~0x0206BF7F) +#define MMC_STATUS_RDY_FOR_DATA (1<<8) +#define MMC_STATUS_CURR_STATE (0xf<<9) + #define MMC_VDD_165_195 0x00000080 /* VDD voltage 1.65 - 1.95 */ #define MMC_VDD_20_21 0x00000100 /* VDD voltage 2.0 ~ 2.1 */ #define MMC_VDD_21_22 0x00000200 /* VDD voltage 2.1 ~ 2.2 */
Hi Raffaele,
On Thu, Mar 10, 2011 at 12:51 AM, Raffaele Recalcati lamiaposta71@gmail.com wrote:
From: Raffaele Recalcati raffaele.recalcati@bticino.it
It is a recommended to check card status after these kind of commands. This is done using CMD13 (SEND_STATUS) JEDEC command. In case of error the previous command is issued again.
Signed-off-by: Raffaele Recalcati raffaele.recalcati@bticino.it
drivers/mmc/mmc.c | 106 +++++++++++++++++++++++++++++++++++++++-------------- include/mmc.h | 4 ++ 2 files changed, 82 insertions(+), 28 deletions(-)
diff --git a/drivers/mmc/mmc.c b/drivers/mmc/mmc.c index 6805b33..53ed36f 100644 --- a/drivers/mmc/mmc.c +++ b/drivers/mmc/mmc.c @@ -48,6 +48,32 @@ int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data) return mmc->send_cmd(mmc, cmd, data); }
+int mmc_send_status(struct mmc *mmc) +{
- struct mmc_cmd cmd;
- int err;
- int timeout = 1000;
- int status;
- cmd.cmdidx = MMC_CMD_SEND_STATUS;
- cmd.resp_type = MMC_RSP_R1;
- cmd.cmdarg = 0;
- cmd.flags = 0;
- do {
- err = mmc_send_cmd(mmc, &cmd, NULL);
- if (err)
- return err;
- udelay(1000);
- if (cmd.response[0] & MMC_STATUS_MASK) {
- printf("Status Error: 0x%08X\n", cmd.response[0]);
- return 1;
- }
- } while (!(cmd.response[0] & MMC_STATUS_RDY_FOR_DATA) && timeout--);
- return 0;
+}
int mmc_set_blocklen(struct mmc *mmc, int len) { struct mmc_cmd cmd; @@ -82,6 +108,7 @@ mmc_write_blocks(struct mmc *mmc, ulong start, lbaint_t blkcnt, const void*src) { struct mmc_cmd cmd; struct mmc_data data;
- int timeout = 1000;
if ((start + blkcnt) > mmc->block_dev.lba) { printf("MMC: block number 0x%lx exceeds max(0x%lx)\n", @@ -113,14 +140,22 @@ mmc_write_blocks(struct mmc *mmc, ulong start, lbaint_t blkcnt, const void*src) }
if (blkcnt > 1) {
- cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
- cmd.cmdarg = 0;
- cmd.resp_type = MMC_RSP_R1b;
- cmd.flags = 0;
- if (mmc_send_cmd(mmc, &cmd, NULL)) {
- printf("mmc fail to send stop cmd\n");
- return 0;
- }
- do {
- cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
- cmd.cmdarg = 0;
- cmd.resp_type = MMC_RSP_R1b;
- cmd.flags = 0;
- if (mmc_send_cmd(mmc, &cmd, NULL)) {
- printf("mmc fail to send stop cmd\n");
- return 0;
- }
- udelay(1000);
- } while (mmc_send_status(mmc) && timeout--);
I apply your patch and test on my board and find this patch mess my sd card... Why you need to keep send the stop command (Also the other command in this patch) if mmc_send_status fail? As my understanding, the command should only send once, and then start to call the mmc_send_status till the status stable.
This is also what kernel does. You could refer to drivers/mmc/core/mmc_ops.c in the linux kernel.
Best regards, Lei
Hi Lei,
I apply your patch and test on my board and find this patch mess my sd card...
Can't you trace the behaviour using the latest patch and send the results to me ?
Why you need to keep send the stop command (Also the other command in this patch) if mmc_send_status fail? As my understanding, the command should only send once, and then start to call the mmc_send_status till the status stable.
Right. I was confused by the possibility to use mmc_send_status to redo also other kind of commands, for example write_block, in the case that the write can go wrong (due to ECC inner nand failure).
This is also what kernel does. You could refer to drivers/mmc/core/mmc_ops.c in the linux kernel.
I'll change every mmc_send_status call in order only to wait that the new state is stable. I can do in about two hours.
Thx for your help, Raffaele
From: Raffaele Recalcati raffaele.recalcati@bticino.it
The first SEND_OP_COND (CMD1) is used only to ask card capabilities, waiting that the card is not busy. After it, an AND operation is done between card capabilities and host capabilities, (at the moment only for the voltage field). Finally the correct value is sent to the MMC.
Signed-off-by: Raffaele Recalcati raffaele.recalcati@bticino.it --- drivers/mmc/mmc.c | 21 +++++++++++++++++++-- include/mmc.h | 2 ++ 2 files changed, 21 insertions(+), 2 deletions(-)
diff --git a/drivers/mmc/mmc.c b/drivers/mmc/mmc.c index 53ed36f..acd7479 100644 --- a/drivers/mmc/mmc.c +++ b/drivers/mmc/mmc.c @@ -348,17 +348,34 @@ sd_send_op_cond(struct mmc *mmc)
int mmc_send_op_cond(struct mmc *mmc) { - int timeout = 1000; + int timeout = 10000; struct mmc_cmd cmd; int err;
/* Some cards seem to need this */ mmc_go_idle(mmc);
+ /* Asking to the card its capabilities */ + do { + cmd.cmdidx = MMC_CMD_SEND_OP_COND; + cmd.resp_type = MMC_RSP_R3; + cmd.cmdarg = 0; + cmd.flags = 0; + + err = mmc_send_cmd(mmc, &cmd, NULL); + + if (err) + return err; + + udelay(1000); + } while (!(cmd.response[0] & OCR_BUSY) && timeout--); + do { cmd.cmdidx = MMC_CMD_SEND_OP_COND; cmd.resp_type = MMC_RSP_R3; - cmd.cmdarg = OCR_HCS | mmc->voltages; + cmd.cmdarg = ((mmc->voltages & + (cmd.response[0] & OCR_VOLTAGE_MASK)) | + (cmd.response[0] & OCR_ACCESS_MODE)); cmd.flags = 0;
err = mmc_send_cmd(mmc, &cmd, NULL); diff --git a/include/mmc.h b/include/mmc.h index 4ee8e1c..d18526d 100644 --- a/include/mmc.h +++ b/include/mmc.h @@ -93,6 +93,8 @@
#define OCR_BUSY 0x80000000 #define OCR_HCS 0x40000000 +#define OCR_VOLTAGE_MASK 0x007FFF80 +#define OCR_ACCESS_MODE 0x60000000
#define MMC_STATUS_MASK (~0x0206BF7F) #define MMC_STATUS_RDY_FOR_DATA (1<<8)
From: Raffaele Recalcati raffaele.recalcati@bticino.it
Defining CONFIG_MMC_TRACE in the include board file it is possible to activate a tracing support. This code helps in case of eMMC hw failure or to investigate possible eMMC initialization issues.
Signed-off-by: Raffaele Recalcati raffaele.recalcati@bticino.it --- drivers/mmc/mmc.c | 71 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 71 insertions(+), 0 deletions(-)
diff --git a/drivers/mmc/mmc.c b/drivers/mmc/mmc.c index acd7479..0dfc83a 100644 --- a/drivers/mmc/mmc.c +++ b/drivers/mmc/mmc.c @@ -45,7 +45,60 @@ int board_mmc_getcd(u8 *cd, struct mmc *mmc)__attribute__((weak,
int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data) { +#ifdef CONFIG_MMC_TRACE + int ret; + int i; + u8 *ptr; + + printf("CMD_SEND:%d\n", cmd->cmdidx); + printf("\t\tARG\t\t\t 0x%08X\n", cmd->cmdarg); + printf("\t\tFLAG\t\t\t %d\n", cmd->flags); + ret = mmc->send_cmd(mmc, cmd, data); + switch (cmd->resp_type) { + case MMC_RSP_NONE: + printf("\t\tMMC_RSP_NONE\n"); + break; + case MMC_RSP_R1: + printf("\t\tMMC_RSP_R1,5,6,7 \t 0x%08X \n", + cmd->response[0]); + break; + case MMC_RSP_R1b: + printf("\t\tMMC_RSP_R1b\t\t 0x%08X \n", + cmd->response[0]); + break; + case MMC_RSP_R2: + printf("\t\tMMC_RSP_R2\t\t 0x%08X \n", + cmd->response[0]); + printf("\t\t \t\t 0x%08X \n", + cmd->response[1]); + printf("\t\t \t\t 0x%08X \n", + cmd->response[2]); + printf("\t\t \t\t 0x%08X \n", + cmd->response[3]); + printf("\n"); + printf("\t\t\t\t\tDUMPING DATA\n"); + for (i = 0; i < 4; i++) { + int j; + printf("\t\t\t\t\t%03d - ", i*4); + ptr = &cmd->response[i]; + ptr += 3; + for (j = 0; j < 4; j++) + printf("%02X ", *ptr--); + printf("\n"); + } + break; + case MMC_RSP_R3: + printf("\t\tMMC_RSP_R3,4\t\t 0x%08X \n", + cmd->response[0]); + break; + default: + printf("\t\tERROR MMC rsp not supported\n"); + break; + } + return ret; +#else return mmc->send_cmd(mmc, cmd, data); +#endif }
int mmc_send_status(struct mmc *mmc) @@ -71,6 +124,10 @@ int mmc_send_status(struct mmc *mmc) } } while (!(cmd.response[0] & MMC_STATUS_RDY_FOR_DATA) && timeout--);
+#ifdef CONFIG_MMC_TRACE + status = (cmd.response[0] & MMC_STATUS_CURR_STATE) >> 9; + printf("CURR STATE:%d\n", status); +#endif return 0; }
@@ -418,6 +475,20 @@ int mmc_send_ext_csd(struct mmc *mmc, char *ext_csd)
err = mmc_send_cmd(mmc, &cmd, &data);
+#ifdef CONFIG_MMC_TRACE + { + int i; + printf("\n"); + printf("MMC_SEND_EXT_CSD: DUMPING DATA\n"); + for (i = 0; i < 32; i++) { + int j; + printf("%03d - ", i*16); + for (j = 0; j < 16; j++) + printf("%02X ", data.dest[j+i*16]); + printf("\n"); + } + } +#endif return err; }
participants (2)
-
Lei Wen -
Raffaele Recalcati