mtd: add support for bad blocks in NAND flash

[lede-git/.git] / package / system / mtd / src / mtd.c

diff --git a/package/system/mtd/src/mtd.c b/package/system/mtd/src/mtd.c
index 2ec02a871b1be84b65d9893ad9d94896a36b7461..604ca28ae29e7411739285cf66fc8a1fa97b3cae 100644 (file)
--- a/package/system/mtd/src/mtd.c
+++ b/package/system/mtd/src/mtd.c
@@ -44,6 +44,8 @@
 #include "fis.h"
 #include "mtd.h"
 
+#include <libubox/md5.h>
+
 #define MAX_ARGS 8
 #define JFFS2_DEFAULT_DIR      "" /* directory name without /, empty means root dir */
 
@@ -56,6 +58,7 @@ int no_erase;
 int mtdsize = 0;
 int erasesize = 0;
 int jffs2_skip_bytes=0;
+int mtdtype = 0;
 
 int mtd_open(const char *mtd, bool block)
 {
@@ -101,10 +104,28 @@ int mtd_check_open(const char *mtd)
        }
        mtdsize = mtdInfo.size;
        erasesize = mtdInfo.erasesize;
+       mtdtype = mtdInfo.type;
 
        return fd;
 }
 
+int mtd_block_is_bad(int fd, int offset)
+{
+       int r = 0;
+       loff_t o = offset;
+
+       if (mtdtype == MTD_NANDFLASH)
+       {
+               r = ioctl(fd, MEMGETBADBLOCK, &o);
+               if (r < 0)
+               {
+                       fprintf(stderr, "Failed to get erase block status\n");
+                       exit(1);
+               }
+       }
+       return r;
+}
+
 int mtd_erase_block(int fd, int offset)
 {
        struct erase_info_user mtdEraseInfo;
@@ -234,10 +255,14 @@ mtd_erase(const char *mtd)
        for (mtdEraseInfo.start = 0;
                 mtdEraseInfo.start < mtdsize;
                 mtdEraseInfo.start += erasesize) {
-
-               ioctl(fd, MEMUNLOCK, &mtdEraseInfo);
-               if(ioctl(fd, MEMERASE, &mtdEraseInfo))
-                       fprintf(stderr, "Failed to erase block on %s at 0x%x\n", mtd, mtdEraseInfo.start);
+               if (mtd_block_is_bad(fd, mtdEraseInfo.start)) {
+                       if (!quiet)
+                               fprintf(stderr, "\nSkipping bad block at 0x%x   ", mtdEraseInfo.start);
+               } else {
+                       ioctl(fd, MEMUNLOCK, &mtdEraseInfo);
+                       if(ioctl(fd, MEMERASE, &mtdEraseInfo))
+                               fprintf(stderr, "Failed to erase block on %s at 0x%x\n", mtd, mtdEraseInfo.start);
+               }
        }
 
        close(fd);
@@ -245,6 +270,63 @@ mtd_erase(const char *mtd)
 
 }
 
+static int
+mtd_verify(const char *mtd, char *file)
+{
+       uint32_t f_md5[4], m_md5[4];
+       struct stat s;
+       md5_ctx_t ctx;
+       int ret = 0;
+       int fd;
+
+       if (quiet < 2)
+               fprintf(stderr, "Verifying %s against %s ...\n", mtd, file);
+
+       if (stat(file, &s) || md5sum(file, f_md5)) {
+               fprintf(stderr, "Failed to hash %s\n", file);
+               return -1;
+       }
+
+       fd = mtd_check_open(mtd);
+       if(fd < 0) {
+               fprintf(stderr, "Could not open mtd device: %s\n", mtd);
+               return -1;
+       }
+
+       md5_begin(&ctx);
+       do {
+               char buf[256];
+               int len = (s.st_size > sizeof(buf)) ? (sizeof(buf)) : (s.st_size);
+               int rlen = read(fd, buf, len);
+
+               if (rlen < 0) {
+                       if (errno == EINTR)
+                               continue;
+                       ret = -1;
+                       goto out;
+               }
+               if (!rlen)
+                       break;
+               md5_hash(buf, rlen, &ctx);
+               s.st_size -= rlen;
+       } while (s.st_size > 0);
+
+       md5_end(m_md5, &ctx);
+
+       fprintf(stderr, "%08x%08x%08x%08x - %s\n", m_md5[0], m_md5[1], m_md5[2], m_md5[3], mtd);
+       fprintf(stderr, "%08x%08x%08x%08x - %s\n", f_md5[0], f_md5[1], f_md5[2], f_md5[3], file);
+
+       ret = memcmp(f_md5, m_md5, sizeof(m_md5));
+       if (!ret)
+               fprintf(stderr, "Success\n");
+       else
+               fprintf(stderr, "Failed\n");
+
+out:
+       close(fd);
+       return ret;
+}
+
 static void
 indicate_writing(const char *mtd)
 {
@@ -265,6 +347,7 @@ mtd_write(int imagefd, const char *mtd, char *fis_layout, size_t part_offset)
        ssize_t skip = 0;
        uint32_t offset = 0;
        int jffs2_replaced = 0;
+       int skip_bad_blocks = 0;
 
 #ifdef FIS_SUPPORT
        static struct fis_part new_parts[MAX_ARGS];
@@ -341,7 +424,7 @@ resume:
                exit(1);
        }
        if (part_offset > 0) {
-               fprintf(stderr, "Seeking on mtd device '%s' to: %u\n", mtd, part_offset);
+               fprintf(stderr, "Seeking on mtd device '%s' to: %zu\n", mtd, part_offset);
                lseek(fd, part_offset, SEEK_SET);
        }
 
@@ -370,6 +453,12 @@ resume:
                if (buflen == 0)
                        break;
 
+               if (buflen < erasesize) {
+                       /* Pad block to eraseblock size */
+                       memset(&buf[buflen], 0xff, erasesize - buflen);
+                       buflen = erasesize;
+               }
+
                if (skip > 0) {
                        skip -= buflen;
                        buflen = 0;
@@ -407,10 +496,21 @@ resume:
                /* need to erase the next block before writing data to it */
                if(!no_erase)
                {
-                       while (w + buflen > e) {
+                       while (w + buflen > e - skip_bad_blocks) {
                                if (!quiet)
                                        fprintf(stderr, "\b\b\b[e]");
 
+                               if (mtd_block_is_bad(fd, e)) {
+                                       if (!quiet)
+                                               fprintf(stderr, "\nSkipping bad block at 0x%08x   ", e);
+
+                                       skip_bad_blocks += erasesize;
+                                       e += erasesize;
+
+                                       // Move the file pointer along over the bad block.
+                                       lseek(fd, erasesize, SEEK_CUR);
+                                       continue;
+                               }
 
                                if (mtd_erase_block(fd, e) < 0) {
                                        if (next) {
@@ -483,6 +583,7 @@ static void usage(void)
        "        unlock                  unlock the device\n"
        "        refresh                 refresh mtd partition\n"
        "        erase                   erase all data on device\n"
+       "        verify <imagefile>|-    verify <imagefile> (use - for stdin) to device\n"
        "        write <imagefile>|-     write <imagefile> (use - for stdin) to device\n"
        "        jffs2write <file>       append <file> to the jffs2 partition on the device\n");
        if (mtd_fixtrx) {
@@ -548,6 +649,7 @@ int main (int argc, char **argv)
                CMD_JFFS2WRITE,
                CMD_FIXTRX,
                CMD_FIXSEAMA,
+               CMD_VERIFY,
        } cmd = -1;
 
        erase[0] = NULL;
@@ -644,6 +746,10 @@ int main (int argc, char **argv)
        } else if (((strcmp(argv[0], "fixseama") == 0) && (argc == 2)) && mtd_fixseama) {
                cmd = CMD_FIXSEAMA;
                device = argv[1];
+       } else if ((strcmp(argv[0], "verify") == 0) && (argc == 3)) {
+               cmd = CMD_VERIFY;
+               imagefile = argv[1];
+               device = argv[2];
        } else if ((strcmp(argv[0], "write") == 0) && (argc == 3)) {
                cmd = CMD_WRITE;
                device = argv[2];
@@ -698,6 +804,9 @@ int main (int argc, char **argv)
                        if (!unlocked)
                                mtd_unlock(device);
                        break;
+               case CMD_VERIFY:
+                       mtd_verify(device, imagefile);
+                       break;
                case CMD_ERASE:
                        if (!unlocked)
                                mtd_unlock(device);