Add timeout in mmc_cmd, we can use this in driver code. Add mmc_sd_erase_timeout, this function is modified from linux kernel.

Signed-off-by: Peng Fan peng.fan@nxp.com Cc: Jaehoon Chung jh80.chung@samsung.com Cc: Simon Glass sjg@chromium.org Cc: Bin Meng bmeng.cn@gmail.com Cc: Stefan Wahren stefan.wahren@i2se.com Cc: Clemens Gruber clemens.gruber@pqgruber.com Cc: Kever Yang kever.yang@rock-chips.com Cc: Eric Nelson eric@nelint.com Cc: Stephen Warren swarren@nvidia.com --- drivers/mmc/mmc_write.c | 29 +++++++++++++++++++++++++++++ include/mmc.h | 1 + 2 files changed, 30 insertions(+)

diff --git a/drivers/mmc/mmc_write.c b/drivers/mmc/mmc_write.c index 4149f4a..3589f8e 100644 --- a/drivers/mmc/mmc_write.c +++ b/drivers/mmc/mmc_write.c @@ -15,6 +15,33 @@ #include <linux/math64.h> #include "mmc_private.h"

+/* + * Modified from from Linux kernel mmc_sd_erase_timeout. + */ +static unsigned int mmc_sd_erase_timeout(struct mmc *mmc, + unsigned int nr) +{ + unsigned int erase_timeout; + + if (mmc->ssr.erase_timeout) { + /* Erase timeout specified in SD Status Register (SSR) */ + erase_timeout = mmc->ssr.erase_timeout * nr + + mmc->ssr.erase_offset; + } else { + /* + * Erase timeout not specified in SD Status Register (SSR) so + * use 250ms per write block. + */ + erase_timeout = 250 * nr; + } + + /* Must not be less than 1 second */ + if (erase_timeout < 1000) + erase_timeout = 1000; + + return erase_timeout; +} + static ulong mmc_erase_t(struct mmc *mmc, ulong start, lbaint_t blkcnt) { struct mmc_cmd cmd = {0}; @@ -54,6 +81,8 @@ static ulong mmc_erase_t(struct mmc *mmc, ulong start, lbaint_t blkcnt) cmd.cmdidx = MMC_CMD_ERASE; cmd.cmdarg = MMC_ERASE_ARG; cmd.resp_type = MMC_RSP_R1b; + if (IS_SD(mmc)) + cmd.timeout = mmc_sd_erase_timeout(mmc, blkcnt);

err = mmc_send_cmd(mmc, &cmd, NULL); if (err) diff --git a/include/mmc.h b/include/mmc.h index f09c36f..c72495c 100644 --- a/include/mmc.h +++ b/include/mmc.h @@ -303,6 +303,7 @@ struct mmc_cmd { uint resp_type; uint cmdarg; uint response[4]; + int timeout; };

struct mmc_data {

To SD, there is no erase group, then the value erase_grp_size will be default 1. When erasing SD blocks, the blocks will be erased one by one, which is time consuming.

use AU_SIZE as a group to speed up the erasing.

Signed-off-by: Peng Fan peng.fan@nxp.com Cc: Jaehoon Chung jh80.chung@samsung.com Cc: Simon Glass sjg@chromium.org Cc: Bin Meng bmeng.cn@gmail.com Cc: Stefan Wahren stefan.wahren@i2se.com Cc: Clemens Gruber clemens.gruber@pqgruber.com Cc: Kever Yang kever.yang@rock-chips.com Cc: Eric Nelson eric@nelint.com Cc: Stephen Warren swarren@nvidia.com --- drivers/mmc/mmc_write.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/drivers/mmc/mmc_write.c b/drivers/mmc/mmc_write.c index 3589f8e..6221b4a 100644 --- a/drivers/mmc/mmc_write.c +++ b/drivers/mmc/mmc_write.c @@ -129,8 +129,13 @@ unsigned long mmc_berase(struct blk_desc *block_dev, lbaint_t start, & ~(mmc->erase_grp_size - 1)) - 1);

while (blk < blkcnt) { - blk_r = ((blkcnt - blk) > mmc->erase_grp_size) ? - mmc->erase_grp_size : (blkcnt - blk); + if (IS_SD(mmc) && mmc->ssr.au) { + blk_r = ((blkcnt - blk) > mmc->ssr.au) ? + mmc->ssr.au : (blkcnt - blk); + } else { + blk_r = ((blkcnt - blk) > mmc->erase_grp_size) ? + mmc->erase_grp_size : (blkcnt - blk); + } err = mmc_erase_t(mmc, start + blk, blk_r); if (err) break;

Hi Peng,

On 08/11/2016 08:00 PM, Peng Fan wrote:

Add function to read SD_STATUS information. According to the information, get erase_timeout/erase_size/erase_offset. Add a structure sd_ssr to include the erase related information.

Signed-off-by: Peng Fan peng.fan@nxp.com Cc: Jaehoon Chung jh80.chung@samsung.com Cc: Simon Glass sjg@chromium.org Cc: Bin Meng bmeng.cn@gmail.com Cc: Stefan Wahren stefan.wahren@i2se.com Cc: Clemens Gruber clemens.gruber@pqgruber.com Cc: Kever Yang kever.yang@rock-chips.com Cc: Eric Nelson eric@nelint.com Cc: Stephen Warren swarren@nvidia.com

---

drivers/mmc/mmc.c | 70 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ include/mmc.h | 8 +++++++ 2 files changed, 78 insertions(+)

diff --git a/drivers/mmc/mmc.c b/drivers/mmc/mmc.c index 3daa748..efe517a 100644 --- a/drivers/mmc/mmc.c +++ b/drivers/mmc/mmc.c @@ -21,6 +21,13 @@ #include <div64.h> #include "mmc_private.h"

+static const unsigned int sd_au_size[] = {

• 0, SZ_16K / 512, SZ_32K / 512, SZ_64K / 512,
• SZ_128K / 512, SZ_256K / 512, SZ_512K / 512, SZ_1M / 512,
• SZ_2M / 512, SZ_4M / 512, SZ_8M / 512, (SZ_8M + SZ_4M) / 512,
• SZ_16M / 512, (SZ_16M + SZ_8M) / 512, SZ_32M / 512, SZ_64M / 512,

+};

WARNING: line over 80 characters #37: FILE: drivers/mmc/mmc.c:27: + SZ_2M / 512, SZ_4M / 512, SZ_8M / 512, (SZ_8M + SZ_4M) / 512,

#ifndef CONFIG_DM_MMC_OPS __weak int board_mmc_getwp(struct mmc *mmc) { @@ -942,6 +949,65 @@ retry_scr: return 0; }

+static int sd_read_ssr(struct mmc *mmc) +{

• int err, i;
• struct mmc_cmd cmd;
• ALLOC_CACHE_ALIGN_BUFFER(uint, ssr, 16);
• struct mmc_data data;
• int timeout;
• unsigned int au, eo, et, es;
• cmd.cmdidx = MMC_CMD_APP_CMD;
• cmd.resp_type = MMC_RSP_R1;
• cmd.cmdarg = mmc->rca << 16;
• err = mmc_send_cmd(mmc, &cmd, NULL);
• if (err)

• return err;
  

• cmd.cmdidx = SD_CMD_APP_SD_STATUS;
• cmd.resp_type = MMC_RSP_R1;
• cmd.cmdarg = 0;
• timeout = 3;

Don't need to assign at here.

+retry_ssr:

• data.dest = (char *)ssr;
• data.blocksize = 64;
• data.blocks = 1;
• data.flags = MMC_DATA_READ;
• err = mmc_send_cmd(mmc, &cmd, &data);
• if (err) {

• if (timeout--)
  

• 	goto retry_ssr;
  

• return err;
  

• }
• for (i = 0; i < 16; i++)

• ssr[i] = be32_to_cpu(ssr[i]);
  

• au = (ssr[2] >> 12) & 0xF;
• if ((au <= 9) || (mmc->version == SD_VERSION_3)) {

• mmc->ssr.au = sd_au_size[au];
  

• es = (ssr[3] >> 24) & 0xFF;
  

• es |= (ssr[2] & 0xFF) << 8;
  

• et = (ssr[3] >> 18) & 0x3F;
  

• if (es && et) {
  

• 	eo = (ssr[3] >> 16) & 0x3;
  

• 	mmc->ssr.erase_timeout = (et * 1000) / es;
  

• 	mmc->ssr.erase_offset = eo * 1000;
  

• }
  

• } else {

• printf("Invalid Allocation Unit Size.\n");
  

• return -EINVAL;
  

If AU size can't read, then your patch can't also initialize the SD-card. AU-size is critical things enough to go to non-initialize??

• }
• return 0;

+}

/* frequency bases */ /* divided by 10 to be nice to platforms without floating point */ static const int fbase[] = { @@ -1347,6 +1413,10 @@ static int mmc_startup(struct mmc *mmc) mmc_set_bus_width(mmc, 4); }

• err = sd_read_ssr(mmc);
  

• if (err)
  

• 	return err;
  

• if (mmc->card_caps & MMC_MODE_HS) mmc->tran_speed = 50000000; else

diff --git a/include/mmc.h b/include/mmc.h index aa6d5d1..f09c36f 100644 --- a/include/mmc.h +++ b/include/mmc.h @@ -102,6 +102,7 @@ #define SD_CMD_SWITCH_UHS18V 11

#define SD_CMD_APP_SET_BUS_WIDTH 6 +#define SD_CMD_APP_SD_STATUS 13 #define SD_CMD_ERASE_WR_BLK_START 32 #define SD_CMD_ERASE_WR_BLK_END 33 #define SD_CMD_APP_SEND_OP_COND 41 @@ -392,6 +393,12 @@ struct mmc_config { unsigned char part_type; };

+struct sd_ssr {

• unsigned int au; /* In sectors */
• unsigned int erase_timeout; /* In milliseconds */
• unsigned int erase_offset; /* In milliseconds */

+};

/*

• With CONFIG_DM_MMC enabled, struct mmc can be accessed from the MMC device
• with mmc_get_mmc_dev().

@@ -426,6 +433,7 @@ struct mmc { uint write_bl_len; uint erase_grp_size; /* in 512-byte sectors */ uint hc_wp_grp_size; /* in 512-byte sectors */

• struct sd_ssr ssr;

Add the comment what is SSR.

Best Regards, Jaehoon Chung

u64 capacity; u64 capacity_user; u64 capacity_boot;