Tow minor changes of eMMC sanitize
v2 cover Tow minor changes of eMMC sanitize
From: Bean Huo <[email protected]>
Changelog:
V1--V2:
1. change wrong nouns in patch 1/2 commit message
Bean Huo (2):
mmc: core: Let sanitize timeout readable/writable via sysfs
mmc: core: Let sanitize not retry in case timeout
drivers/mmc/core/block.c | 13 +++--- drivers/mmc/core/mmc.c | 81 ++++++++++++++++++++++++++++---------- drivers/mmc/core/mmc_ops.c | 20 +++++----- drivers/mmc/core/mmc_ops.h | 4 +- include/linux/mmc/card.h | 1 + 5 files changed, 82 insertions(+), 37 deletions(-)
Signature · 1 line
2.25.1
PATCH v2 1/2 mmc: core: Let sanitize timeout readable/writable via sysfs
From: Bean Huo <[email protected]>
As the density increases, the 4-minute timeout value for sanitize is no longer feasible. At the same time, devices of different densities have different timeout values, and it is difficult to obtain a unified standard timeout value. Therefore, it is better to let the user explicitly change sanitize timeout value according to the eMMC density on the board.
--- drivers/mmc/core/mmc.c | 34 ++++++++++++++++++++++++++++++++++ drivers/mmc/core/mmc_ops.c | 3 +-- include/linux/mmc/card.h | 1 + 3 files changed, 36 insertions(+), 2 deletions(-)
drivers/mmc/core/mmc.c +34 -0
@@ -28,6 +28,7 @@#define DEFAULT_CMD6_TIMEOUT_MS 500#define MIN_CACHE_EN_TIMEOUT_MS 1600 +#define MMC_SANITIZE_TIMEOUT_MS (240 * 1000)/* 240s */ static const unsigned int tran_exp[] = {10000 ,100000 ,1000000 ,10000000 ,
@@ -835,6 +836,37 @@ static ssize_t mmc_dsr_show(struct device *dev, static DEVICE_ATTR(dsr, S_IRUGO, mmc_dsr_show, NULL); +static ssize_t sanitize_timeout_ms_show (struct device *dev, +struct device_attribute *attr, +char *buf) +{ +struct mmc_card *card =mmc_dev_to_card (dev); + +return sysfs_emit (buf,"%d\n" , card->sanitize_timeout_ms); +} + +static ssize_t sanitize_timeout_ms_store (struct device *dev, +struct device_attribute *attr, +const char *buf,size_t len) +{ +struct mmc_card *card =mmc_dev_to_card (dev); +unsigned int new; +int ret; + + ret =kstrtouint (buf,0 , &new); +if (ret <0 ) +return ret; + +if (new ==0 ) +return -EINVAL ; + + card->sanitize_timeout_ms = new; + +return len; +} +static DEVICE_ATTR_RW (sanitize_timeout_ms); + +static struct attribute *mmc_std_attrs[] = { &dev_attr_cid.attr, &dev_attr_csd.attr,
@@ -861,6 +893,7 @@ static struct attribute *mmc_std_attrs[] = { &dev_attr_rca.attr, &dev_attr_dsr.attr, &dev_attr_cmdq_en.attr, + &dev_attr_sanitize_timeout_ms.attr,NULL , };ATTRIBUTE_GROUPS (mmc_std);
@@ -1623,6 +1656,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr, card->ocr = ocr; card->type =MMC_TYPE_MMC ; card->rca =1 ; + card->sanitize_timeout_ms =MMC_SANITIZE_TIMEOUT_MS ;memcpy (card->raw_cid, cid,sizeof (card->raw_cid)); }
drivers/mmc/core/mmc_ops.c +1 -2
@@ -21,7 +21,6 @@#define MMC_BKOPS_TIMEOUT_MS (120 * 1000)/* 120s */ #define MMC_CACHE_FLUSH_TIMEOUT_MS (30 * 1000)/* 30s */ -#define MMC_SANITIZE_TIMEOUT_MS (240 * 1000)/* 240s */ static const u8 tuning_blk_pattern_4bit[] = {0xff ,0x0f ,0xff ,0x00 ,0xff ,0xcc ,0xc3 ,0xcc ,
@@ -1025,7 +1024,7 @@ int mmc_sanitize(struct mmc_card *card)mmc_retune_hold (host); err =mmc_switch (card,EXT_CSD_CMD_SET_NORMAL ,EXT_CSD_SANITIZE_START , -1 ,MMC_SANITIZE_TIMEOUT_MS ); +1 , card->sanitize_timeout_ms);if (err)pr_err ("%s: Sanitize failed err=%d\n" ,mmc_hostname (host), err);
include/linux/mmc/card.h +1 -0
@@ -273,6 +273,7 @@ struct mmc_card {bool reenable_cmdq;/* Re-enable Command Queue */ +unsigned int sanitize_timeout_ms;unsigned int erase_size;/* erase size in sectors */ unsigned int erase_shift;/* if erase unit is power 2 */ unsigned int pref_erase;/* in sectors */
Signature · 1 line
2.25.1
Re: [PATCH v2 1/2] mmc: core: Let sanitize timeout readable/writable via sysfs
Quoted 9 lines · Bean Huo
From: Bean Huo <[email protected]>
As the density increases, the 4-minute timeout value for sanitize is no longer feasible. At the same time, devices of different densities have different timeout values, and it is difficult to obtain a unified standard timeout value. Therefore, it is better to let the user explicitly change sanitize timeout value according to the eMMC density on the board.
This makes sense. The current timeout in the mmc core isn't good enough. However, I think there is a better option than inventing a sysfs node to allow userspace to specify the timeout.
First, we have the card quirks that the mmc core uses to allow us to modify a common behaviour (in this case timeouts values for sanitize operations). This can be used to enforce a specific timeout for the eMMC card. I think this should take precedence over anything else.
Second, the ioctl command allows you to specify a specific command timeout in the struct mmc_ioc_cmd (.cmd_timeout_ms). If this is specified from user space we could forward it to mmc_santize() and use that rather than the default MMC_SANITIZE_TIMEOUT_MS.
Would this satisfy your needs?
Kind regards
Uffe
Quoted 110 lines
Signed-off-by Bean Huo <[email protected]>--- drivers/mmc/core/mmc.c | 34 ++++++++++++++++++++++++++++++++++ drivers/mmc/core/mmc_ops.c | 3 +-- include/linux/mmc/card.h | 1 + 3 files changed, 36 insertions(+), 2 deletions(-)drivers/mmc/core/mmc.c +34
-0@@ -28,6 +28,7 @@#define DEFAULT_CMD6_TIMEOUT_MS 500#define MIN_CACHE_EN_TIMEOUT_MS 1600 +#define MMC_SANITIZE_TIMEOUT_MS (240 * 1000)/* 240s */ static const unsigned int tran_exp[] = {10000 ,100000 ,1000000 ,10000000 ,@@ -835,6 +836,37 @@ static ssize_t mmc_dsr_show(struct device *dev, static DEVICE_ATTR(dsr, S_IRUGO, mmc_dsr_show, NULL); +static ssize_t sanitize_timeout_ms_show (struct device *dev, +struct device_attribute *attr, +char *buf) +{ +struct mmc_card *card =mmc_dev_to_card (dev); + +return sysfs_emit (buf,"%d\n" , card->sanitize_timeout_ms); +} + +static ssize_t sanitize_timeout_ms_store (struct device *dev, +struct device_attribute *attr, +const char *buf,size_t len) +{ +struct mmc_card *card =mmc_dev_to_card (dev); +unsigned int new; +int ret; + + ret =kstrtouint (buf,0 , &new); +if (ret <0 ) +return ret; + +if (new ==0 ) +return -EINVAL ; + + card->sanitize_timeout_ms = new; + +return len; +} +static DEVICE_ATTR_RW (sanitize_timeout_ms); + +static struct attribute *mmc_std_attrs[] = { &dev_attr_cid.attr, &dev_attr_csd.attr,@@ -861,6 +893,7 @@ static struct attribute *mmc_std_attrs[] = { &dev_attr_rca.attr, &dev_attr_dsr.attr, &dev_attr_cmdq_en.attr, + &dev_attr_sanitize_timeout_ms.attr,NULL , };ATTRIBUTE_GROUPS (mmc_std);@@ -1623,6 +1656,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr, card->ocr = ocr; card->type =MMC_TYPE_MMC ; card->rca =1 ; + card->sanitize_timeout_ms =MMC_SANITIZE_TIMEOUT_MS ;memcpy (card->raw_cid, cid,sizeof (card->raw_cid)); }drivers/mmc/core/mmc_ops.c +1
-2@@ -21,7 +21,6 @@#define MMC_BKOPS_TIMEOUT_MS (120 * 1000)/* 120s */ #define MMC_CACHE_FLUSH_TIMEOUT_MS (30 * 1000)/* 30s */ -#define MMC_SANITIZE_TIMEOUT_MS (240 * 1000)/* 240s */ static const u8 tuning_blk_pattern_4bit[] = {0xff ,0x0f ,0xff ,0x00 ,0xff ,0xcc ,0xc3 ,0xcc ,@@ -1025,7 +1024,7 @@ int mmc_sanitize(struct mmc_card *card)mmc_retune_hold (host); err =mmc_switch (card,EXT_CSD_CMD_SET_NORMAL ,EXT_CSD_SANITIZE_START , -1 ,MMC_SANITIZE_TIMEOUT_MS ); +1 , card->sanitize_timeout_ms);if (err)pr_err ("%s: Sanitize failed err=%d\n" ,mmc_hostname (host), err);include/linux/mmc/card.h +1
-1@@ -273,6 +273,7 @@ struct mmc_card {bool reenable_cmdq;/* Re-enable Command Queue */ +unsigned int sanitize_timeout_ms;unsigned int erase_size;/* erase size in sectors */ unsigned int erase_shift;/* if erase unit is power 2 */ unsigned int pref_erase;/* in sectors */ --2.25.1
Re: [PATCH v2 1/2] mmc: core: Let sanitize timeout readable/writable via sysfs
Quoted 33 lines · Ulf Hansson
Quoted 7 lines · Bean Huo
From: Bean Huo <[email protected]>
As the density increases, the 4-minute timeout value for sanitize is no longer feasible. At the same time, devices of different densities have different timeout values, and it is difficult to obtain a unified standard timeout value. Therefore, it is better to let the user explicitly change sanitize timeout value according to the eMMC density on the board.This makes sense. The current timeout in the mmc core isn't good
enough. However, I think there is a better option than inventing a
sysfs node to allow userspace to specify the timeout.
First, we have the card quirks that the mmc core uses to allow us to
modify a common behaviour (in this case timeouts values for sanitize
operations). This can be used to enforce a specific timeout for the
eMMC card. I think this should take precedence over anything else.
Second, the ioctl command allows you to specify a specific command
timeout in the struct
mmc_ioc_cmd(.cmd_timeout_ms). If this is
Quoted 9 lines
specified from user space we could forward it to
mmc_santize()and usethat rather than the default
MMC_SANITIZE_TIMEOUT_MS.Would this satisfy your needs?
Hi Ulf,
Add card quirk is diffcult since different card with different timeout. I prefer to your second one. I will change this patch based on your comments.
Thanks,
Bean
Quoted 5 lines
Kind regards
Uffe
PATCH v2 2/2 mmc: core: Let sanitize not retry in case timeout
In reply to Bean HuoFrom: Bean Huo <[email protected]>
Not any commands need to retry in case of timeout/failure. Currently, the sanitize command is issued by the IOCTL interface, and once its timeouts, the user normally decides to retry or not . Just blindly retry three times sanitize in the driver, it doesn't help sanitize retry succeed in the end, on the contrary, it only makes the user feel sanitize timeouts after 12 minutes.
--- drivers/mmc/core/block.c | 13 +++++++---- drivers/mmc/core/mmc.c | 47 ++++++++++++++++++++++---------------- drivers/mmc/core/mmc_ops.c | 19 +++++++-------- drivers/mmc/core/mmc_ops.h | 4 ++-- 4 files changed, 47 insertions(+), 36 deletions(-)
drivers/mmc/core/block.c +8 -5
@@ -836,7 +836,7 @@ static inline int mmc_blk_part_switch(struct mmc_card *card, ret =mmc_switch (card,EXT_CSD_CMD_SET_NORMAL ,EXT_CSD_PART_CONFIG , part_config, - card->ext_csd.part_time); + card->ext_csd.part_time,MMC_CMD_RETRIES );if (ret) {mmc_blk_part_switch_post (card, part_type);return ret;
@@ -1007,7 +1007,7 @@ static void mmc_blk_issue_drv_op(struct mmc_queue *mq, struct request *req) ret =mmc_switch (card,EXT_CSD_CMD_SET_NORMAL ,EXT_CSD_BOOT_WP , card->ext_csd.boot_ro_lock |EXT_CSD_BOOT_WP_B_PWR_WP_EN , - card->ext_csd.part_time); + card->ext_csd.part_time,MMC_CMD_RETRIES );if (ret)pr_err ("%s: Locking boot partition ro until next power on failed: %d\n" , md->disk->disk_name, ret);
@@ -1058,7 +1058,8 @@ static void mmc_blk_issue_discard_rq(struct mmc_queue *mq, struct request *req) card->erase_arg ==MMC_TRIM_ARG ?INAND_CMD38_ARG_TRIM :INAND_CMD38_ARG_ERASE , - card->ext_csd.generic_cmd6_time); + card->ext_csd.generic_cmd6_time, + MMC_CMD_RETRIES); }if (!err) err =mmc_erase (card, from, nr, card->erase_arg);
@@ -1100,7 +1101,8 @@ static void mmc_blk_issue_secdiscard_rq(struct mmc_queue *mq, arg ==MMC_SECURE_TRIM1_ARG ?INAND_CMD38_ARG_SECTRIM1 :INAND_CMD38_ARG_SECERASE , - card->ext_csd.generic_cmd6_time); + card->ext_csd.generic_cmd6_time, + MMC_CMD_RETRIES);if (err) goto out_retry; }
@@ -1118,7 +1120,8 @@ static void mmc_blk_issue_secdiscard_rq(struct mmc_queue *mq, err =mmc_switch (card,EXT_CSD_CMD_SET_NORMAL ,INAND_CMD38_ARG_EXT_CSD ,INAND_CMD38_ARG_SECTRIM2 , - card->ext_csd.generic_cmd6_time); + card->ext_csd.generic_cmd6_time, +MMC_CMD_RETRIES );if (err) goto out_retry; }
drivers/mmc/core/mmc.c +27 -20
167 lines not on this page · raw message
drivers/mmc/core/mmc_ops.c +10 -9
@@ -531,12 +531,13 @@ int mmc_poll_for_busy(struct mmc_card *card, unsigned int timeout_ms,* @timing: new timing to change to * @send_status: send status cmd to poll for busy * @retry_crc_err: retry when CRC errors when polling with CMD13 for busy +* @retries: number of retries * * Modifies the EXT_CSD register for selected card. */ int __mmc_switch (struct mmc_card *card,u8 set,u8 index,u8 value,unsigned int timeout_ms,unsigned char timing, -bool send_status,bool retry_crc_err) +bool send_status,bool retry_crc_err,unsigned int retries) {struct mmc_host *host = card->host;int err;
@@ -562,7 +563,6 @@ int __mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,if (!(host->caps &MMC_CAP_NEED_RSP_BUSY ) && host->max_busy_timeout && (timeout_ms > host->max_busy_timeout)) use_r1b_resp = false; - cmd.opcode =MMC_SWITCH ; cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE <<24 ) | (index << 16) |
@@ -576,7 +576,7 @@ int __mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value, cmd.flags |=MMC_RSP_SPI_R1 |MMC_RSP_R1 ; } - err =mmc_wait_for_cmd (host, &cmd,MMC_CMD_RETRIES ); + err =mmc_wait_for_cmd (host, &cmd, retries);if (err) goto out;
@@ -608,10 +608,10 @@ int __mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value, }int mmc_switch (struct mmc_card *card,u8 set,u8 index,u8 value, -unsigned int timeout_ms) +unsigned int timeout_ms,unsigned int retries) {return __mmc_switch (card, set, index, value, timeout_ms,0 , - true, false); + true, false, retries); }EXPORT_SYMBOL_GPL (mmc_switch);
@@ -950,7 +950,8 @@ void mmc_run_bkops(struct mmc_card *card)* urgent levels by using an asynchronous background task, when idle. */ err =mmc_switch (card,EXT_CSD_CMD_SET_NORMAL , -EXT_CSD_BKOPS_START ,1 ,MMC_BKOPS_TIMEOUT_MS ); +EXT_CSD_BKOPS_START ,1 ,MMC_BKOPS_TIMEOUT_MS , +MMC_CMD_RETRIES );if (err)pr_warn ("%s: Error %d starting bkops\n" ,mmc_hostname (card->host), err);
@@ -971,7 +972,7 @@ int mmc_flush_cache(struct mmc_card *card) (card->ext_csd.cache_ctrl & 1)) { err =mmc_switch (card,EXT_CSD_CMD_SET_NORMAL ,EXT_CSD_FLUSH_CACHE ,1 , -MMC_CACHE_FLUSH_TIMEOUT_MS ); +MMC_CACHE_FLUSH_TIMEOUT_MS ,MMC_CMD_RETRIES );if (err)pr_err ("%s: cache flush error %d\n" ,mmc_hostname (card->host), err);
@@ -990,7 +991,7 @@ static int mmc_cmdq_switch(struct mmc_card *card, bool enable)return -EOPNOTSUPP ; err =mmc_switch (card,EXT_CSD_CMD_SET_NORMAL ,EXT_CSD_CMDQ_MODE_EN , - val, card->ext_csd.generic_cmd6_time); + val, card->ext_csd.generic_cmd6_time,MMC_CMD_RETRIES );if (!err) card->ext_csd.cmdq_en = enable;
@@ -1024,7 +1025,7 @@ int mmc_sanitize(struct mmc_card *card)mmc_retune_hold (host); err =mmc_switch (card,EXT_CSD_CMD_SET_NORMAL ,EXT_CSD_SANITIZE_START , -1 , card->sanitize_timeout_ms); +1 , card->sanitize_timeout_ms,0 );if (err)pr_err ("%s: Sanitize failed err=%d\n" ,mmc_hostname (host), err);
drivers/mmc/core/mmc_ops.h +2 -2
@@ -39,9 +39,9 @@ int mmc_poll_for_busy(struct mmc_card *card, unsigned int timeout_ms, enum mmc_busy_cmd busy_cmd);int __mmc_switch (struct mmc_card *card,u8 set,u8 index,u8 value,unsigned int timeout_ms,unsigned char timing, -bool send_status,bool retry_crc_err); +bool send_status,bool retry_crc_err,unsigned int retries);int mmc_switch (struct mmc_card *card,u8 set,u8 index,u8 value, -unsigned int timeout_ms); +unsigned int timeout_ms,unsigned int retries);void mmc_run_bkops (struct mmc_card *card);int mmc_flush_cache (struct mmc_card *card);int mmc_cmdq_enable (struct mmc_card *card);
Signature · 1 line
2.25.1