This patch implements read-only test of nand flash devices.
Test reads blocks of NAND flash in normal and raw modes and compares
results. The following statuses can be returned for a block:
* non-ecc reading failed,
* ecc reading failed,
* block is bad,
* bitflips is above maximum,
* actual number of biflips above reported one,
* bitflips reached it maximum value,
* block is ok.
Signed-off-by: Mikhail Kshevetskiy <mikhail.kshevets...@iopsys.eu>
---
cmd/Kconfig | 16 +++++
cmd/mtd.c | 193 ++++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 209 insertions(+)
diff --git a/cmd/Kconfig b/cmd/Kconfig
index ea0491d3155..5a0efb7b173 100644
--- a/cmd/Kconfig
+++ b/cmd/Kconfig
@@ -1471,6 +1471,22 @@ config CMD_MTD_NAND_WRITE_TEST
WARNING: This test will destroy any data on blocks being tested.
+config CMD_MTD_NAND_READ_TEST
+ bool "mtd nand_read_test"
+ depends on CMD_MTD
+ help
+ MTD nand_read_test command support.
+
+ Reads blocks of NAND flash in normal and raw modes and compares
results.
+ The following statuses can be returned for a block:
+ * non-ecc reading failed,
+ * ecc reading failed,
+ * block is bad,
+ * bitflips is above maximum,
+ * actual number of biflips above reported one,
+ * bitflips reached it maximum value,
+ * block is ok.
+
config CMD_MUX
bool "mux"
depends on MULTIPLEXER
diff --git a/cmd/mtd.c b/cmd/mtd.c
index 739a8a52cbd..1bfe9fc97da 100644
--- a/cmd/mtd.c
+++ b/cmd/mtd.c
@@ -931,6 +931,191 @@ out_put_mtd:
}
#endif
+#ifdef CONFIG_CMD_MTD_NAND_READ_TEST
+enum nand_read_status {
+ NAND_READ_STATUS_UNKNOWN = 0,
+ NAND_READ_STATUS_NONECC_READ_FAIL,
+ NAND_READ_STATUS_ECC_READ_FAIL,
+ NAND_READ_STATUS_BAD_BLOCK,
+ NAND_READ_STATUS_BITFLIP_ABOVE_MAX,
+ NAND_READ_STATUS_BITFLIP_MISMATCH,
+ NAND_READ_STATUS_BITFLIP_MAX,
+ NAND_READ_STATUS_OK,
+};
+
+static enum nand_read_status nand_read_block_check(struct mtd_info *mtd,
+ loff_t off, size_t blocksize)
+{
+ struct mtd_oob_ops ops = {};
+ u_char *buf;
+ int i, d, ret, len, pos, cnt, max;
+
+ if (blocksize % mtd->writesize != 0) {
+ printf("\r block at %llx: bad block size\n", off);
+ return NAND_READ_STATUS_UNKNOWN;
+ }
+
+ buf = malloc_cache_aligned(2 * blocksize);
+ if (buf == NULL) {
+ printf("\r block at %llx: can't allocate memory\n", off);
+ return NAND_READ_STATUS_UNKNOWN;
+ }
+
+ ops.mode = MTD_OPS_RAW;
+ ops.len = blocksize;
+ ops.datbuf = buf;
+ ops.ooblen = 0;
+ ops.oobbuf = NULL;
+
+ if (mtd->_read_oob)
+ ret = mtd->_read_oob(mtd, off, &ops);
+ else
+ ret = mtd->_read(mtd, off, ops.len, &ops.retlen, ops.datbuf);
+
+ if (ret != 0) {
+ free(buf);
+ printf("\r block at %llx: non-ecc reading error %d\n",
+ off, ret);
+ return NAND_READ_STATUS_NONECC_READ_FAIL;
+ }
+
+ ops.mode = MTD_OPS_AUTO_OOB;
+ ops.datbuf = buf + blocksize;
+
+ if (mtd->_read_oob)
+ ret = mtd->_read_oob(mtd, off, &ops);
+ else
+ ret = mtd->_read(mtd, off, ops.len, &ops.retlen, ops.datbuf);
+
+ if (ret == -EBADMSG) {
+ free(buf);
+ printf("\r block at %llx: bad block\n", off);
+ return NAND_READ_STATUS_BAD_BLOCK;
+ }
+
+ if (ret < 0) {
+ free(buf);
+ printf("\r block at %llx: ecc reading error %d\n", off, ret);
+ return NAND_READ_STATUS_ECC_READ_FAIL;
+ }
+
+ if (mtd->ecc_strength == 0) {
+ free(buf);
+ return NAND_READ_STATUS_OK;
+ }
+
+ if (ret > mtd->ecc_strength) {
+ free(buf);
+ printf("\r block at %llx: returned bit-flips value %d "
+ "is above maximum value %d\n",
+ off, ret, mtd->ecc_strength);
+ return NAND_READ_STATUS_BITFLIP_ABOVE_MAX;
+ }
+
+ max = 0;
+ pos = 0;
+ len = blocksize;
+ while (len > 0) {
+ cnt = 0;
+ for (i = 0; i < mtd->ecc_step_size; i++) {
+ d = buf[pos + i] ^ buf[blocksize + pos + i];
+ if (d == 0)
+ continue;
+
+ while (d > 0) {
+ d &= (d - 1);
+ cnt++;
+ }
+ }
+ if (cnt > max)
+ max = cnt;
+
+ len -= mtd->ecc_step_size;
+ pos += mtd->ecc_step_size;
+ }
+
+ free(buf);
+
+ if (max > ret) {
+ printf("\r block at %llx: bitflip mismatch, "
+ "read %d but actual %d\n", off, ret, max);
+ return NAND_READ_STATUS_BITFLIP_MISMATCH;
+ }
+
+ if (ret == mtd->ecc_strength) {
+ printf("\r block at %llx: max bitflip reached, "
+ "block is unreliable\n", off);
+ return NAND_READ_STATUS_BITFLIP_MAX;
+ }
+
+ return NAND_READ_STATUS_OK;
+}
+
+static int do_mtd_nand_read_test(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
+{
+ struct mtd_info *mtd;
+ u64 off;
+ int stat[NAND_READ_STATUS_OK + 1];
+ enum nand_read_status ret;
+
+ if (argc < 2)
+ return CMD_RET_USAGE;
+
+ mtd = get_mtd_by_name(argv[1]);
+ if (IS_ERR_OR_NULL(mtd))
+ return CMD_RET_FAILURE;
+
+ if (!mtd_can_have_bb(mtd)) {
+ printf("Only NAND-based devices can be checked\n");
+ goto out_put_mtd;
+ }
+
+ printf("ECC strength: %d\n", mtd->ecc_strength);
+ printf("ECC step size: %d\n", mtd->ecc_step_size);
+ printf("Erase block size: 0x%x\n", mtd->erasesize);
+ printf("Total blocks: %d\n", do_div(mtd->size, mtd->erasesize));
+
+ memset(stat, 0, sizeof(stat));
+ for (off = 0; off < mtd->size; off += mtd->erasesize) {
+ ret = nand_read_block_check(mtd, off, mtd->erasesize);
+ stat[ret]++;
+
+ switch (ret) {
+ case NAND_READ_STATUS_BAD_BLOCK:
+ case NAND_READ_STATUS_BITFLIP_MAX:
+ if (!mtd_block_isbad(mtd, off))
+ printf("\r block at %llx: should be marked "
+ "as BAD\n", off);
+ break;
+
+ case NAND_READ_STATUS_OK:
+ if (mtd_block_isbad(mtd, off))
+ printf("\r block at %llx: marked as BAD, but "
+ "probably is GOOD\n", off);
+ break;
+
+ default:
+ break;
+ }
+ }
+
+out_put_mtd:
+ put_mtd_device(mtd);
+ printf("\n");
+ printf("results:\n");
+ printf(" Good blocks: %d\n", stat[NAND_READ_STATUS_OK]);
+ printf(" Physically bad blocks: %d\n",
stat[NAND_READ_STATUS_BAD_BLOCK]);
+ printf(" Unreliable blocks: %d\n",
stat[NAND_READ_STATUS_BITFLIP_MAX]);
+ printf(" Non checked blocks: %d\n",
stat[NAND_READ_STATUS_UNKNOWN]);
+ printf(" Failed to check blocks: %d\n",
stat[NAND_READ_STATUS_NONECC_READ_FAIL] +
+
stat[NAND_READ_STATUS_ECC_READ_FAIL]);
+ printf(" Suspictious blocks: %d\n",
stat[NAND_READ_STATUS_BITFLIP_ABOVE_MAX] +
+
stat[NAND_READ_STATUS_BITFLIP_MISMATCH]);
+ return CMD_RET_SUCCESS;
+}
+#endif
+
static int do_mtd_bad(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
@@ -1019,6 +1204,9 @@ U_BOOT_LONGHELP(mtd,
#endif
#ifdef CONFIG_CMD_MTD_TORTURE
"mtd torture <name> [<off> [<size>]]\n"
+#endif
+#ifdef CONFIG_CMD_MTD_NANDTEST
+ "mtd nandtest <name>\n"
#endif
"\n"
"With:\n"
@@ -1061,6 +1249,11 @@ U_BOOT_CMD_WITH_SUBCMDS(mtd, "MTD utils", mtd_help_text,
U_BOOT_SUBCMD_MKENT_COMPLETE(nand_write_test, 4, 0,
do_nand_write_test,
mtd_name_complete),
+#endif
+#ifdef CONFIG_CMD_MTD_NAND_READ_TEST
+ U_BOOT_SUBCMD_MKENT_COMPLETE(nand_read_test, 2, 0,
+ do_mtd_nand_read_test,
+ mtd_name_complete),
#endif
U_BOOT_SUBCMD_MKENT_COMPLETE(bad, 2, 1, do_mtd_bad,
mtd_name_complete));
--
2.45.2
