mtd: spinand: Add read retry support

When the host ECC fails to correct the data error of NAND device,
there's a special read for data recovery method which can be setup
by the host for the next read. There are several retry levels that
can be attempted until the lost data is recovered or definitely
assumed lost.

Signed-off-by: Cheng Ming Lin <chengminglin@mxic.com.tw>
Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com>

diff --git a/drivers/mtd/nand/spi/core.c b/drivers/mtd/nand/spi/core.c
index dc5b11fa7a1583ea0bae22b0d01e0b0d88c34f21..d16e42cf8faebd032ca08d54c33c73d8a8fd79d9 100644 (file)
--- a/drivers/mtd/nand/spi/core.c
+++ b/drivers/mtd/nand/spi/core.c
@@ -700,11 +700,15 @@ static int spinand_mtd_regular_page_read(struct mtd_info *mtd, loff_t from,
 {
        struct spinand_device *spinand = mtd_to_spinand(mtd);
        struct nand_device *nand = mtd_to_nanddev(mtd);
+       struct mtd_ecc_stats old_stats;
        struct nand_io_iter iter;
        bool disable_ecc = false;
        bool ecc_failed = false;
+       unsigned int retry_mode = 0;
        int ret;
 
+       old_stats = mtd->ecc_stats;
+
        if (ops->mode == MTD_OPS_RAW || !mtd->ooblayout)
                disable_ecc = true;
 
@@ -716,18 +720,43 @@ static int spinand_mtd_regular_page_read(struct mtd_info *mtd, loff_t from,
                if (ret)
                        break;
 
+read_retry:
                ret = spinand_read_page(spinand, &iter.req);
                if (ret < 0 && ret != -EBADMSG)
                        break;
 
-               if (ret == -EBADMSG)
+               if (ret == -EBADMSG && spinand->set_read_retry) {
+                       if (spinand->read_retries && (++retry_mode <= spinand->read_retries)) {
+                               ret = spinand->set_read_retry(spinand, retry_mode);
+                               if (ret < 0) {
+                                       spinand->set_read_retry(spinand, 0);
+                                       return ret;
+                               }
+
+                               /* Reset ecc_stats; retry */
+                               mtd->ecc_stats = old_stats;
+                               goto read_retry;
+                       } else {
+                               /* No more retry modes; real failure */
+                               ecc_failed = true;
+                       }
+               } else if (ret == -EBADMSG) {
                        ecc_failed = true;
-               else
+               } else {
                        *max_bitflips = max_t(unsigned int, *max_bitflips, ret);
+               }
 
                ret = 0;
                ops->retlen += iter.req.datalen;
                ops->oobretlen += iter.req.ooblen;
+
+               /* Reset to retry mode 0 */
+               if (retry_mode) {
+                       retry_mode = 0;
+                       ret = spinand->set_read_retry(spinand, retry_mode);
+                       if (ret < 0)
+                               return ret;
+               }
        }
 
        if (ecc_failed && !ret)
@@ -1320,6 +1349,8 @@ int spinand_match_and_init(struct spinand_device *spinand,
                spinand->set_cont_read = table[i].set_cont_read;
                spinand->fact_otp = &table[i].fact_otp;
                spinand->user_otp = &table[i].user_otp;
+               spinand->read_retries = table[i].read_retries;
+               spinand->set_read_retry = table[i].set_read_retry;
 
                op = spinand_select_op_variant(spinand,
                                               info->op_variants.read_cache);

diff --git a/include/linux/mtd/spinand.h b/include/linux/mtd/spinand.h
index 73424405232abb782b5b2fa5b320b8cb3fa6a311..5837a09ab9d8350f83e7899a2302336ee573fa8a 100644 (file)
--- a/include/linux/mtd/spinand.h
+++ b/include/linux/mtd/spinand.h
@@ -452,6 +452,8 @@ struct spinand_user_otp {
  * @set_cont_read: enable/disable continuous cached reads
  * @fact_otp: SPI NAND factory OTP info.
  * @user_otp: SPI NAND user OTP info.
+ * @read_retries: the number of read retry modes supported
+ * @set_read_retry: enable/disable read retry for data recovery
  *
  * Each SPI NAND manufacturer driver should have a spinand_info table
  * describing all the chips supported by the driver.
@@ -474,6 +476,9 @@ struct spinand_info {
                             bool enable);
        struct spinand_fact_otp fact_otp;
        struct spinand_user_otp user_otp;
+       unsigned int read_retries;
+       int (*set_read_retry)(struct spinand_device *spinand,
+                            unsigned int read_retry);
 };
 
 #define SPINAND_ID(__method, ...)                                      \
@@ -520,6 +525,10 @@ struct spinand_info {
                .ops = __ops,                                           \
        }
 
+#define SPINAND_READ_RETRY(__read_retries, __set_read_retry)           \
+       .read_retries = __read_retries,                         \
+       .set_read_retry = __set_read_retry,
+
 #define SPINAND_INFO(__model, __id, __memorg, __eccreq, __op_variants, \
                     __flags, ...)                                      \
        {                                                               \
@@ -572,6 +581,8 @@ struct spinand_dirmap {
  * @priv: manufacturer private data
  * @fact_otp: SPI NAND factory OTP info.
  * @user_otp: SPI NAND user OTP info.
+ * @read_retries: the number of read retry modes supported
+ * @set_read_retry: Enable/disable the read retry feature
  */
 struct spinand_device {
        struct nand_device base;
@@ -607,6 +618,10 @@ struct spinand_device {
 
        const struct spinand_fact_otp *fact_otp;
        const struct spinand_user_otp *user_otp;
+
+       unsigned int read_retries;
+       int (*set_read_retry)(struct spinand_device *spinand,
+                            unsigned int retry_mode);
 };
 
 /**