mtd: tests: introduce helper functions

This introduces the helper functions which can be used by several
mtd/tests modules.

The following three functions are used all over the test modules.

- mtdtest_erase_eraseblock()
- mtdtest_scan_for_bad_eraseblocks()
- mtdtest_erase_good_eraseblocks()

The following are wrapper functions for mtd_read() and mtd_write()
which can simplify the return value check.

- mtdtest_read()
- mtdtest_write()

All helpers are put into a single .c file and it will be linked to
every test module later.  The code will actually be copied to every
test module, but it is fine for our small test infrastructure.

[dwmw2: merge later 'return -EIO when mtdtest_read() failed' fix]

Signed-off-by: Akinobu Mita <akinobu.mita@gmail.com>
Cc: Brian Norris <computersforpeace@gmail.com>
Cc: Vikram Narayanan <vikram186@gmail.com>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>
Signed-off-by: Huang Shijie <b32955@freescale.com>

2 files changed, 121 insertions, 0 deletions

diff --git a/drivers/mtd/tests/mtd_test.c b/drivers/mtd/tests/mtd_test.c
new file mode 100644
index 000000000000..bda8c4de3433
--- /dev/null
+++ b/drivers/mtd/tests/mtd_test.c
@@ -0,0 +1,110 @@
+#define pr_fmt(fmt) "mtd_test: " fmt
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <linux/printk.h>
+
+#include "mtd_test.h"
+
+int mtdtest_erase_eraseblock(struct mtd_info *mtd, unsigned int ebnum)
+{
+        int err;
+        struct erase_info ei;
+        loff_t addr = ebnum * mtd->erasesize;
+
+        memset(&ei, 0, sizeof(struct erase_info));
+        ei.mtd  = mtd;
+        ei.addr = addr;
+        ei.len  = mtd->erasesize;
+
+        err = mtd_erase(mtd, &ei);
+        if (err) {
+                pr_info("error %d while erasing EB %d\n", err, ebnum);
+                return err;
+        }
+
+        if (ei.state == MTD_ERASE_FAILED) {
+                pr_info("some erase error occurred at EB %d\n", ebnum);
+                return -EIO;
+        }
+        return 0;
+}
+
+static int is_block_bad(struct mtd_info *mtd, unsigned int ebnum)
+{
+        int ret;
+        loff_t addr = ebnum * mtd->erasesize;
+
+        ret = mtd_block_isbad(mtd, addr);
+        if (ret)
+                pr_info("block %d is bad\n", ebnum);
+
+        return ret;
+}
+
+int mtdtest_scan_for_bad_eraseblocks(struct mtd_info *mtd, unsigned char *bbt,
+                                        unsigned int eb, int ebcnt)
+{
+        int i, bad = 0;
+
+        if (!mtd_can_have_bb(mtd))
+                return 0;
+
+        pr_info("scanning for bad eraseblocks\n");
+        for (i = 0; i < ebcnt; ++i) {
+                bbt[i] = is_block_bad(mtd, eb + i) ? 1 : 0;
+                if (bbt[i])
+                        bad += 1;
+                cond_resched();
+        }
+        pr_info("scanned %d eraseblocks, %d are bad\n", i, bad);
+
+        return 0;
+}
+
+int mtdtest_erase_good_eraseblocks(struct mtd_info *mtd, unsigned char *bbt,
+                                unsigned int eb, int ebcnt)
+{
+        int err;
+        unsigned int i;
+
+        for (i = 0; i < ebcnt; ++i) {
+                if (bbt[i])
+                        continue;
+                err = mtdtest_erase_eraseblock(mtd, eb + i);
+                if (err)
+                        return err;
+                cond_resched();
+        }
+
+        return 0;
+}
+
+int mtdtest_read(struct mtd_info *mtd, loff_t addr, size_t size, void *buf)
+{
+        size_t read;
+        int err;
+
+        err = mtd_read(mtd, addr, size, &read, buf);
+        /* Ignore corrected ECC errors */
+        if (mtd_is_bitflip(err))
+                err = 0;
+        if (!err && read != size)
+                err = -EIO;
+
+        return err;
+}
+
+int mtdtest_write(struct mtd_info *mtd, loff_t addr, size_t size,
+                const void *buf)
+{
+        size_t written;
+        int err;
+
+        err = mtd_write(mtd, addr, size, &written, buf);
+        if (!err && written != size)
+                err = -EIO;
+
+        return err;
+}
diff --git a/drivers/mtd/tests/mtd_test.h b/drivers/mtd/tests/mtd_test.h
new file mode 100644
index 000000000000..f437c776c54f
--- /dev/null
+++ b/drivers/mtd/tests/mtd_test.h
@@ -0,0 +1,11 @@
+#include <linux/mtd/mtd.h>
+
+int mtdtest_erase_eraseblock(struct mtd_info *mtd, unsigned int ebnum);
+int mtdtest_scan_for_bad_eraseblocks(struct mtd_info *mtd, unsigned char *bbt,
+                                        unsigned int eb, int ebcnt);
+int mtdtest_erase_good_eraseblocks(struct mtd_info *mtd, unsigned char *bbt,
+                                unsigned int eb, int ebcnt);
+
+int mtdtest_read(struct mtd_info *mtd, loff_t addr, size_t size, void *buf);
+int mtdtest_write(struct mtd_info *mtd, loff_t addr, size_t size,
+                const void *buf);