7 files changed, 205 insertions, 100 deletions

diff --git a/drivers/mtd/nand/mxc_nand.c b/drivers/mtd/nand/mxc_nand.c
index 82e94389824e..0d76b169482f 100644
--- a/drivers/mtd/nand/mxc_nand.c
+++ b/drivers/mtd/nand/mxc_nand.c
@@ -623,8 +623,7 @@ static void mxc_nand_command(struct mtd_info *mtd, unsigned command,
                 else
                         host->buf_start = column + mtd->writesize;
 
-                if (mtd->writesize > 512)
-                        command = NAND_CMD_READ0; /* only READ0 is valid */
+                command = NAND_CMD_READ0; /* only READ0 is valid */
 
                 send_cmd(host, command, false);
                 mxc_do_addr_cycle(mtd, column, page_addr);
@@ -639,31 +638,11 @@ static void mxc_nand_command(struct mtd_info *mtd, unsigned command,
                 break;
 
         case NAND_CMD_SEQIN:
-                if (column >= mtd->writesize) {
-                        /*
-                         * FIXME: before send SEQIN command for write OOB,
-                         * We must read one page out.
-                         * For K9F1GXX has no READ1 command to set current HW
-                         * pointer to spare area, we must write the whole page
-                         * including OOB together.
-                         */
-                        if (mtd->writesize > 512)
-                                /* call ourself to read a page */
-                                mxc_nand_command(mtd, NAND_CMD_READ0, 0,
-                                                page_addr);
-
-                        host->buf_start = column;
-
-                        /* Set program pointer to spare region */
-                        if (mtd->writesize == 512)
-                                send_cmd(host, NAND_CMD_READOOB, false);
-                } else {
-                        host->buf_start = column;
+                if (column >= mtd->writesize)
+                        /* call ourself to read a page */
+                        mxc_nand_command(mtd, NAND_CMD_READ0, 0, page_addr);
 
-                        /* Set program pointer to page start */
-                        if (mtd->writesize == 512)
-                                send_cmd(host, NAND_CMD_READ0, false);
-                }
+                host->buf_start = column;
 
                 send_cmd(host, command, false);
                 mxc_do_addr_cycle(mtd, column, page_addr);
@@ -853,6 +832,8 @@ static int __init mxcnd_probe(struct platform_device *pdev)
             parse_mtd_partitions(mtd, part_probes, &host->parts, 0);
         if (nr_parts > 0)
                 add_mtd_partitions(mtd, host->parts, nr_parts);
+        else if (pdata->parts)
+                add_mtd_partitions(mtd, pdata->parts, pdata->nr_parts);
         else
 #endif
         {
diff --git a/drivers/mtd/ubi/build.c b/drivers/mtd/ubi/build.c
index 13b05cb33b08..78ae89488a4f 100644
--- a/drivers/mtd/ubi/build.c
+++ b/drivers/mtd/ubi/build.c
@@ -593,6 +593,7 @@ static int attach_by_scanning(struct ubi_device *ubi)
         ubi->good_peb_count = ubi->peb_count - ubi->bad_peb_count;
         ubi->max_ec = si->max_ec;
         ubi->mean_ec = si->mean_ec;
+        ubi_msg("max. sequence number:       %llu", si->max_sqnum);
 
         err = ubi_read_volume_table(ubi, si);
         if (err)
@@ -981,7 +982,7 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
         ubi_msg("number of PEBs reserved for bad PEB handling: %d",
                 ubi->beb_rsvd_pebs);
         ubi_msg("max/mean erase counter: %d/%d", ubi->max_ec, ubi->mean_ec);
-        ubi_msg("image sequence number: %d", ubi->image_seq);
+        ubi_msg("image sequence number:  %d", ubi->image_seq);
 
         /*
          * The below lock makes sure we do not race with 'ubi_thread()' which
diff --git a/drivers/mtd/ubi/eba.c b/drivers/mtd/ubi/eba.c
index 9f87c99189a9..fe74749e0dae 100644
--- a/drivers/mtd/ubi/eba.c
+++ b/drivers/mtd/ubi/eba.c
@@ -418,7 +418,8 @@ retry:
                                  * may try to recover data. FIXME: but this is
                                  * not implemented.
                                  */
-                                if (err == UBI_IO_BAD_VID_HDR) {
+                                if (err == UBI_IO_BAD_HDR_READ ||
+                                    err == UBI_IO_BAD_HDR) {
                                         ubi_warn("corrupted VID header at PEB "
                                                  "%d, LEB %d:%d", pnum, vol_id,
                                                  lnum);
@@ -961,8 +962,8 @@ write_error:
  */
 static int is_error_sane(int err)
 {
-        if (err == -EIO || err == -ENOMEM || err == UBI_IO_BAD_VID_HDR ||
-            err == -ETIMEDOUT)
+        if (err == -EIO || err == -ENOMEM || err == UBI_IO_BAD_HDR ||
+            err == UBI_IO_BAD_HDR_READ || err == -ETIMEDOUT)
                 return 0;
         return 1;
 }
@@ -1165,6 +1166,44 @@ out_unlock_leb:
 }
 
 /**
+ * print_rsvd_warning - warn about not having enough reserved PEBs.
+ * @ubi: UBI device description object
+ *
+ * This is a helper function for 'ubi_eba_init_scan()' which is called when UBI
+ * cannot reserve enough PEBs for bad block handling. This function makes a
+ * decision whether we have to print a warning or not. The algorithm is as
+ * follows:
+ *   o if this is a new UBI image, then just print the warning
+ *   o if this is an UBI image which has already been used for some time, print
+ *     a warning only if we can reserve less than 10% of the expected amount of
+ *     the reserved PEB.
+ *
+ * The idea is that when UBI is used, PEBs become bad, and the reserved pool
+ * of PEBs becomes smaller, which is normal and we do not want to scare users
+ * with a warning every time they attach the MTD device. This was an issue
+ * reported by real users.
+ */
+static void print_rsvd_warning(struct ubi_device *ubi,
+                               struct ubi_scan_info *si)
+{
+        /*
+         * The 1 << 18 (256KiB) number is picked randomly, just a reasonably
+         * large number to distinguish between newly flashed and used images.
+         */
+        if (si->max_sqnum > (1 << 18)) {
+                int min = ubi->beb_rsvd_level / 10;
+
+                if (!min)
+                        min = 1;
+                if (ubi->beb_rsvd_pebs > min)
+                        return;
+        }
+
+        ubi_warn("cannot reserve enough PEBs for bad PEB handling, reserved %d,"
+                 " need %d", ubi->beb_rsvd_pebs, ubi->beb_rsvd_level);
+}
+
+/**
  * ubi_eba_init_scan - initialize the EBA sub-system using scanning information.
  * @ubi: UBI device description object
  * @si: scanning information
@@ -1236,9 +1275,7 @@ int ubi_eba_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si)
                 if (ubi->avail_pebs < ubi->beb_rsvd_level) {
                         /* No enough free physical eraseblocks */
                         ubi->beb_rsvd_pebs = ubi->avail_pebs;
-                        ubi_warn("cannot reserve enough PEBs for bad PEB "
-                                 "handling, reserved %d, need %d",
-                                 ubi->beb_rsvd_pebs, ubi->beb_rsvd_level);
+                        print_rsvd_warning(ubi, si);
                 } else
                         ubi->beb_rsvd_pebs = ubi->beb_rsvd_level;
 
diff --git a/drivers/mtd/ubi/io.c b/drivers/mtd/ubi/io.c
index 4b979e34b159..332f992f13d9 100644
--- a/drivers/mtd/ubi/io.c
+++ b/drivers/mtd/ubi/io.c
@@ -150,6 +150,8 @@ int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset,
 retry:
         err = ubi->mtd->read(ubi->mtd, addr, len, &read, buf);
         if (err) {
+                const char *errstr = (err == -EBADMSG) ? " (ECC error)" : "";
+
                 if (err == -EUCLEAN) {
                         /*
                          * -EUCLEAN is reported if there was a bit-flip which
@@ -165,15 +167,15 @@ retry:
                 }
 
                 if (read != len && retries++ < UBI_IO_RETRIES) {
-                        dbg_io("error %d while reading %d bytes from PEB %d:%d,"
+                        dbg_io("error %d%s while reading %d bytes from PEB %d:%d,"
                                " read only %zd bytes, retry",
-                               err, len, pnum, offset, read);
+                               err, errstr, len, pnum, offset, read);
                         yield();
                         goto retry;
                 }
 
-                ubi_err("error %d while reading %d bytes from PEB %d:%d, "
-                        "read %zd bytes", err, len, pnum, offset, read);
+                ubi_err("error %d%s while reading %d bytes from PEB %d:%d, "
+                        "read %zd bytes", err, errstr, len, pnum, offset, read);
                 ubi_dbg_dump_stack();
 
                 /*
@@ -515,7 +517,7 @@ static int nor_erase_prepare(struct ubi_device *ubi, int pnum)
          * In this case we probably anyway have garbage in this PEB.
          */
         err1 = ubi_io_read_vid_hdr(ubi, pnum, &vid_hdr, 0);
-        if (err1 == UBI_IO_BAD_VID_HDR)
+        if (err1 == UBI_IO_BAD_HDR_READ || err1 == UBI_IO_BAD_HDR)
                 /*
                  * The VID header is corrupted, so we can safely erase this
                  * PEB and not afraid that it will be treated as a valid PEB in
@@ -709,7 +711,7 @@ bad:
  * o %UBI_IO_BITFLIPS if the CRC is correct, but bit-flips were detected
  *   and corrected by the flash driver; this is harmless but may indicate that
  *   this eraseblock may become bad soon (but may be not);
- * o %UBI_IO_BAD_EC_HDR if the erase counter header is corrupted (a CRC error);
+ * o %UBI_IO_BAD_HDR if the erase counter header is corrupted (a CRC error);
  * o %UBI_IO_PEB_EMPTY if the physical eraseblock is empty;
  * o a negative error code in case of failure.
  */
@@ -736,23 +738,21 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
                  * header is still OK, we just report this as there was a
                  * bit-flip.
                  */
-                read_err = err;
+                if (err == -EBADMSG)
+                        read_err = UBI_IO_BAD_HDR_READ;
         }
 
         magic = be32_to_cpu(ec_hdr->magic);
         if (magic != UBI_EC_HDR_MAGIC) {
+                if (read_err)
+                        return read_err;
+
                 /*
                  * The magic field is wrong. Let's check if we have read all
                  * 0xFF. If yes, this physical eraseblock is assumed to be
                  * empty.
-                 *
-                 * But if there was a read error, we do not test it for all
-                 * 0xFFs. Even if it does contain all 0xFFs, this error
-                 * indicates that something is still wrong with this physical
-                 * eraseblock and we anyway cannot treat it as empty.
                  */
-                if (read_err != -EBADMSG &&
-                    check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {
+                if (check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {
                         /* The physical eraseblock is supposedly empty */
                         if (verbose)
                                 ubi_warn("no EC header found at PEB %d, "
@@ -774,7 +774,7 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
                 } else if (UBI_IO_DEBUG)
                         dbg_msg("bad magic number at PEB %d: %08x instead of "
                                 "%08x", pnum, magic, UBI_EC_HDR_MAGIC);
-                return UBI_IO_BAD_EC_HDR;
+                return UBI_IO_BAD_HDR;
         }
 
         crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
@@ -788,7 +788,7 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
                 } else if (UBI_IO_DEBUG)
                         dbg_msg("bad EC header CRC at PEB %d, calculated "
                                 "%#08x, read %#08x", pnum, crc, hdr_crc);
-                return UBI_IO_BAD_EC_HDR;
+                return read_err ?: UBI_IO_BAD_HDR;
         }
 
         /* And of course validate what has just been read from the media */
@@ -798,6 +798,10 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
                 return -EINVAL;
         }
 
+        /*
+         * If there was %-EBADMSG, but the header CRC is still OK, report about
+         * a bit-flip to force scrubbing on this PEB.
+         */
         return read_err ? UBI_IO_BITFLIPS : 0;
 }
 
@@ -977,7 +981,7 @@ bad:
  * o %UBI_IO_BITFLIPS if the CRC is correct, but bit-flips were detected
  *   and corrected by the flash driver; this is harmless but may indicate that
  *   this eraseblock may become bad soon;
- * o %UBI_IO_BAD_VID_HDR if the volume identifier header is corrupted (a CRC
+ * o %UBI_IO_BAD_HDR if the volume identifier header is corrupted (a CRC
  *   error detected);
  * o %UBI_IO_PEB_FREE if the physical eraseblock is free (i.e., there is no VID
  *   header there);
@@ -1008,22 +1012,20 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
                  * CRC check-sum and we will identify this. If the VID header is
                  * still OK, we just report this as there was a bit-flip.
                  */
-                read_err = err;
+                if (err == -EBADMSG)
+                        read_err = UBI_IO_BAD_HDR_READ;
         }
 
         magic = be32_to_cpu(vid_hdr->magic);
         if (magic != UBI_VID_HDR_MAGIC) {
+                if (read_err)
+                        return read_err;
+
                 /*
                  * If we have read all 0xFF bytes, the VID header probably does
                  * not exist and the physical eraseblock is assumed to be free.
-                 *
-                 * But if there was a read error, we do not test the data for
-                 * 0xFFs. Even if it does contain all 0xFFs, this error
-                 * indicates that something is still wrong with this physical
-                 * eraseblock and it cannot be regarded as free.
                  */
-                if (read_err != -EBADMSG &&
-                    check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) {
+                if (check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) {
                         /* The physical eraseblock is supposedly free */
                         if (verbose)
                                 ubi_warn("no VID header found at PEB %d, "
@@ -1045,7 +1047,7 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
                 } else if (UBI_IO_DEBUG)
                         dbg_msg("bad magic number at PEB %d: %08x instead of "
                                 "%08x", pnum, magic, UBI_VID_HDR_MAGIC);
-                return UBI_IO_BAD_VID_HDR;
+                return UBI_IO_BAD_HDR;
         }
 
         crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
@@ -1059,7 +1061,7 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
                 } else if (UBI_IO_DEBUG)
                         dbg_msg("bad CRC at PEB %d, calculated %#08x, "
                                 "read %#08x", pnum, crc, hdr_crc);
-                return UBI_IO_BAD_VID_HDR;
+                return read_err ?: UBI_IO_BAD_HDR;
         }
 
         /* Validate the VID header that we have just read */
@@ -1069,6 +1071,10 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
                 return -EINVAL;
         }
 
+        /*
+         * If there was a read error (%-EBADMSG), but the header CRC is still
+         * OK, report about a bit-flip to force scrubbing on this PEB.
+         */
         return read_err ? UBI_IO_BITFLIPS : 0;
 }
 
diff --git a/drivers/mtd/ubi/scan.c b/drivers/mtd/ubi/scan.c
index aed19f33b8f3..372a15ac9995 100644
--- a/drivers/mtd/ubi/scan.c
+++ b/drivers/mtd/ubi/scan.c
@@ -44,6 +44,7 @@
 #include <linux/slab.h>
 #include <linux/crc32.h>
 #include <linux/math64.h>
+#include <linux/random.h>
 #include "ubi.h"
 
 #ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
@@ -72,16 +73,19 @@ static int add_to_list(struct ubi_scan_info *si, int pnum, int ec,
 {
         struct ubi_scan_leb *seb;
 
-        if (list == &si->free)
+        if (list == &si->free) {
                 dbg_bld("add to free: PEB %d, EC %d", pnum, ec);
-        else if (list == &si->erase)
+                si->free_peb_count += 1;
+        } else if (list == &si->erase) {
                 dbg_bld("add to erase: PEB %d, EC %d", pnum, ec);
-        else if (list == &si->corr) {
+                si->erase_peb_count += 1;
+        } else if (list == &si->corr) {
                 dbg_bld("add to corrupted: PEB %d, EC %d", pnum, ec);
-                si->corr_count += 1;
-        } else if (list == &si->alien)
+                si->corr_peb_count += 1;
+        } else if (list == &si->alien) {
                 dbg_bld("add to alien: PEB %d, EC %d", pnum, ec);
-        else
+                si->alien_peb_count += 1;
+        } else
                 BUG();
 
         seb = kmalloc(sizeof(struct ubi_scan_leb), GFP_KERNEL);
@@ -517,6 +521,7 @@ int ubi_scan_add_used(struct ubi_device *ubi, struct ubi_scan_info *si,
         sv->leb_count += 1;
         rb_link_node(&seb->u.rb, parent, p);
         rb_insert_color(&seb->u.rb, &sv->root);
+        si->used_peb_count += 1;
         return 0;
 }
 
@@ -745,19 +750,17 @@ static int process_eb(struct ubi_device *ubi, struct ubi_scan_info *si,
                 bitflips = 1;
         else if (err == UBI_IO_PEB_EMPTY)
                 return add_to_list(si, pnum, UBI_SCAN_UNKNOWN_EC, &si->erase);
-        else if (err == UBI_IO_BAD_EC_HDR) {
+        else if (err == UBI_IO_BAD_HDR_READ || err == UBI_IO_BAD_HDR) {
                 /*
                  * We have to also look at the VID header, possibly it is not
                  * corrupted. Set %bitflips flag in order to make this PEB be
                  * moved and EC be re-created.
                  */
-                ec_corr = 1;
+                ec_corr = err;
                 ec = UBI_SCAN_UNKNOWN_EC;
                 bitflips = 1;
         }
 
-        si->is_empty = 0;
-
         if (!ec_corr) {
                 int image_seq;
 
@@ -813,9 +816,12 @@ static int process_eb(struct ubi_device *ubi, struct ubi_scan_info *si,
                 return err;
         else if (err == UBI_IO_BITFLIPS)
                 bitflips = 1;
-        else if (err == UBI_IO_BAD_VID_HDR ||
+        else if (err == UBI_IO_BAD_HDR_READ || err == UBI_IO_BAD_HDR ||
                  (err == UBI_IO_PEB_FREE && ec_corr)) {
                 /* VID header is corrupted */
+                if (err == UBI_IO_BAD_HDR_READ ||
+                    ec_corr == UBI_IO_BAD_HDR_READ)
+                        si->read_err_count += 1;
                 err = add_to_list(si, pnum, ec, &si->corr);
                 if (err)
                         return err;
@@ -836,11 +842,11 @@ static int process_eb(struct ubi_device *ubi, struct ubi_scan_info *si,
                 switch (vidh->compat) {
                 case UBI_COMPAT_DELETE:
                         ubi_msg("\"delete\" compatible internal volume %d:%d"
-                                " found, remove it", vol_id, lnum);
+                                " found, will remove it", vol_id, lnum);
                         err = add_to_list(si, pnum, ec, &si->corr);
                         if (err)
                                 return err;
-                        break;
+                        return 0;
 
                 case UBI_COMPAT_RO:
                         ubi_msg("read-only compatible internal volume %d:%d"
@@ -855,7 +861,6 @@ static int process_eb(struct ubi_device *ubi, struct ubi_scan_info *si,
                         err = add_to_list(si, pnum, ec, &si->alien);
                         if (err)
                                 return err;
-                        si->alien_peb_count += 1;
                         return 0;
 
                 case UBI_COMPAT_REJECT:
@@ -886,6 +891,85 @@ adjust_mean_ec:
 }
 
 /**
+ * check_what_we_have - check what PEB were found by scanning.
+ * @ubi: UBI device description object
+ * @si: scanning information
+ *
+ * This is a helper function which takes a look what PEBs were found by
+ * scanning, and decides whether the flash is empty and should be formatted and
+ * whether there are too many corrupted PEBs and we should not attach this
+ * MTD device. Returns zero if we should proceed with attaching the MTD device,
+ * and %-EINVAL if we should not.
+ */
+static int check_what_we_have(struct ubi_device *ubi, struct ubi_scan_info *si)
+{
+        struct ubi_scan_leb *seb;
+        int max_corr;
+
+        max_corr = ubi->peb_count - si->bad_peb_count - si->alien_peb_count;
+        max_corr = max_corr / 20 ?: 8;
+
+        /*
+         * Few corrupted PEBs are not a problem and may be just a result of
+         * unclean reboots. However, many of them may indicate some problems
+         * with the flash HW or driver.
+         */
+        if (si->corr_peb_count >= 8) {
+                ubi_warn("%d PEBs are corrupted", si->corr_peb_count);
+                printk(KERN_WARNING "corrupted PEBs are:");
+                list_for_each_entry(seb, &si->corr, u.list)
+                        printk(KERN_CONT " %d", seb->pnum);
+                printk(KERN_CONT "\n");
+
+                /*
+                 * If too many PEBs are corrupted, we refuse attaching,
+                 * otherwise, only print a warning.
+                 */
+                if (si->corr_peb_count >= max_corr) {
+                        ubi_err("too many corrupted PEBs, refusing this device");
+                        return -EINVAL;
+                }
+        }
+
+        if (si->free_peb_count + si->used_peb_count +
+            si->alien_peb_count == 0) {
+                /* No UBI-formatted eraseblocks were found */
+                if (si->corr_peb_count == si->read_err_count &&
+                    si->corr_peb_count < 8) {
+                        /* No or just few corrupted PEBs, and all of them had a
+                         * read error. We assume that those are bad PEBs, which
+                         * were just not marked as bad so far.
+                         *
+                         * This piece of code basically tries to distinguish
+                         * between the following 2 situations:
+                         *
+                         * 1. Flash is empty, but there are few bad PEBs, which
+                         *    are not marked as bad so far, and which were read
+                         *    with error. We want to go ahead and format this
+                         *    flash. While formating, the faulty PEBs will
+                         *    probably be marked as bad.
+                         *
+                         * 2. Flash probably contains non-UBI data and we do
+                         * not want to format it and destroy possibly needed
+                         * data (e.g., consider the case when the bootloader
+                         * MTD partition was accidentally fed to UBI).
+                         */
+                        si->is_empty = 1;
+                        ubi_msg("empty MTD device detected");
+                        get_random_bytes(&ubi->image_seq, sizeof(ubi->image_seq));
+                } else {
+                        ubi_err("MTD device possibly contains non-UBI data, "
+                                "refusing it");
+                        return -EINVAL;
+                }
+        }
+
+        if (si->corr_peb_count > 0)
+                ubi_msg("corrupted PEBs will be formatted");
+        return 0;
+}
+
+/**
  * ubi_scan - scan an MTD device.
  * @ubi: UBI device description object
  *
@@ -909,7 +993,6 @@ struct ubi_scan_info *ubi_scan(struct ubi_device *ubi)
         INIT_LIST_HEAD(&si->erase);
         INIT_LIST_HEAD(&si->alien);
         si->volumes = RB_ROOT;
-        si->is_empty = 1;
 
         err = -ENOMEM;
         ech = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
@@ -935,21 +1018,9 @@ struct ubi_scan_info *ubi_scan(struct ubi_device *ubi)
         if (si->ec_count)
                 si->mean_ec = div_u64(si->ec_sum, si->ec_count);
 
-        if (si->is_empty)
-                ubi_msg("empty MTD device detected");
-
-        /*
-         * Few corrupted PEBs are not a problem and may be just a result of
-         * unclean reboots. However, many of them may indicate some problems
-         * with the flash HW or driver. Print a warning in this case.
-         */
-        if (si->corr_count >= 8 || si->corr_count >= ubi->peb_count / 4) {
-                ubi_warn("%d PEBs are corrupted", si->corr_count);
-                printk(KERN_WARNING "corrupted PEBs are:");
-                list_for_each_entry(seb, &si->corr, u.list)
-                        printk(KERN_CONT " %d", seb->pnum);
-                printk(KERN_CONT "\n");
-        }
+        err = check_what_we_have(ubi, si);
+        if (err)
+                goto out_vidh;
 
         /*
          * In case of unknown erase counter we use the mean erase counter
diff --git a/drivers/mtd/ubi/scan.h b/drivers/mtd/ubi/scan.h
index ff179ad7ca55..2576a8d1532b 100644
--- a/drivers/mtd/ubi/scan.h
+++ b/drivers/mtd/ubi/scan.h
@@ -91,10 +91,16 @@ struct ubi_scan_volume {
  * @erase: list of physical eraseblocks which have to be erased
  * @alien: list of physical eraseblocks which should not be used by UBI (e.g.,
  *         those belonging to "preserve"-compatible internal volumes)
+ * @used_peb_count: count of used PEBs
+ * @corr_peb_count: count of PEBs in the @corr list
+ * @read_err_count: count of PEBs read with error (%UBI_IO_BAD_HDR_READ was
+ *                  returned)
+ * @free_peb_count: count of PEBs in the @free list
+ * @erase_peb_count: count of PEBs in the @erase list
+ * @alien_peb_count: count of PEBs in the @alien list
  * @bad_peb_count: count of bad physical eraseblocks
  * @vols_found: number of volumes found during scanning
  * @highest_vol_id: highest volume ID
- * @alien_peb_count: count of physical eraseblocks in the @alien list
  * @is_empty: flag indicating whether the MTD device is empty or not
  * @min_ec: lowest erase counter value
  * @max_ec: highest erase counter value
@@ -102,7 +108,6 @@ struct ubi_scan_volume {
  * @mean_ec: mean erase counter value
  * @ec_sum: a temporary variable used when calculating @mean_ec
  * @ec_count: a temporary variable used when calculating @mean_ec
- * @corr_count: count of corrupted PEBs
  *
  * This data structure contains the result of scanning and may be used by other
  * UBI sub-systems to build final UBI data structures, further error-recovery
@@ -114,10 +119,15 @@ struct ubi_scan_info {
         struct list_head free;
         struct list_head erase;
         struct list_head alien;
+        int used_peb_count;
+        int corr_peb_count;
+        int read_err_count;
+        int free_peb_count;
+        int erase_peb_count;
+        int alien_peb_count;
         int bad_peb_count;
         int vols_found;
         int highest_vol_id;
-        int alien_peb_count;
         int is_empty;
         int min_ec;
         int max_ec;
@@ -125,7 +135,6 @@ struct ubi_scan_info {
         int mean_ec;
         uint64_t ec_sum;
         int ec_count;
-        int corr_count;
 };
 
 struct ubi_device;
@@ -135,7 +144,7 @@ struct ubi_vid_hdr;
  * ubi_scan_move_to_list - move a PEB from the volume tree to a list.
  *
  * @sv: volume scanning information
- * @seb: scanning eraseblock infprmation
+ * @seb: scanning eraseblock information
  * @list: the list to move to
  */
 static inline void ubi_scan_move_to_list(struct ubi_scan_volume *sv,
diff --git a/drivers/mtd/ubi/ubi.h b/drivers/mtd/ubi/ubi.h
index a637f0283add..0359e0cce482 100644
--- a/drivers/mtd/ubi/ubi.h
+++ b/drivers/mtd/ubi/ubi.h
@@ -89,16 +89,16 @@
  *                   %0xFF bytes
  * UBI_IO_PEB_FREE: the physical eraseblock is free, i.e. it contains only a
  *                  valid erase counter header, and the rest are %0xFF bytes
- * UBI_IO_BAD_EC_HDR: the erase counter header is corrupted (bad magic or CRC)
- * UBI_IO_BAD_VID_HDR: the volume identifier header is corrupted (bad magic or
- *                     CRC)
+ * UBI_IO_BAD_HDR: the EC or VID header is corrupted (bad magic or CRC)
+ * UBI_IO_BAD_HDR_READ: the same as %UBI_IO_BAD_HDR, but also there was a read
+ *                      error reported by the flash driver
  * UBI_IO_BITFLIPS: bit-flips were detected and corrected
  */
 enum {
         UBI_IO_PEB_EMPTY = 1,
         UBI_IO_PEB_FREE,
-        UBI_IO_BAD_EC_HDR,
-        UBI_IO_BAD_VID_HDR,
+        UBI_IO_BAD_HDR,
+        UBI_IO_BAD_HDR_READ,
         UBI_IO_BITFLIPS
 };