1 files changed, 19 insertions, 43 deletions

diff --git a/drivers/mtd/ubi/build.c b/drivers/mtd/ubi/build.c
index f49e49dc5928..65626c1c446d 100644
--- a/drivers/mtd/ubi/build.c
+++ b/drivers/mtd/ubi/build.c
@@ -672,33 +672,7 @@ static int io_init(struct ubi_device *ubi)
                 ubi->nor_flash = 1;
         }
 
-        /*
-         * Set UBI min. I/O size (@ubi->min_io_size). We use @mtd->writebufsize
-         * for these purposes, not @mtd->writesize. At the moment this does not
-         * matter for NAND, because currently @mtd->writebufsize is equivalent to
-         * @mtd->writesize for all NANDs. However, some CFI NOR flashes may
-         * have @mtd->writebufsize which is multiple of @mtd->writesize.
-         *
-         * The reason we use @mtd->writebufsize for @ubi->min_io_size is that
-         * UBI and UBIFS recovery algorithms rely on the fact that if there was
-         * an unclean power cut, then we can find offset of the last corrupted
-         * node, align the offset to @ubi->min_io_size, read the rest of the
-         * eraseblock starting from this offset, and check whether there are
-         * only 0xFF bytes. If yes, then we are probably dealing with a
-         * corruption caused by a power cut, if not, then this is probably some
-         * severe corruption.
-         *
-         * Thus, we have to use the maximum write unit size of the flash, which
-         * is @mtd->writebufsize, because @mtd->writesize is the minimum write
-         * size, not the maximum.
-         */
-        if (ubi->mtd->type == MTD_NANDFLASH)
-                ubi_assert(ubi->mtd->writebufsize == ubi->mtd->writesize);
-        else if (ubi->mtd->type == MTD_NORFLASH)
-                ubi_assert(ubi->mtd->writebufsize % ubi->mtd->writesize == 0);
-
-        ubi->min_io_size = ubi->mtd->writebufsize;
-
+        ubi->min_io_size = ubi->mtd->writesize;
         ubi->hdrs_min_io_size = ubi->mtd->writesize >> ubi->mtd->subpage_sft;
 
         /*
@@ -716,11 +690,25 @@ static int io_init(struct ubi_device *ubi)
         ubi_assert(ubi->hdrs_min_io_size <= ubi->min_io_size);
         ubi_assert(ubi->min_io_size % ubi->hdrs_min_io_size == 0);
 
+        ubi->max_write_size = ubi->mtd->writebufsize;
+        /*
+         * Maximum write size has to be greater or equivalent to min. I/O
+         * size, and be multiple of min. I/O size.
+         */
+        if (ubi->max_write_size < ubi->min_io_size ||
+            ubi->max_write_size % ubi->min_io_size ||
+            !is_power_of_2(ubi->max_write_size)) {
+                ubi_err("bad write buffer size %d for %d min. I/O unit",
+                        ubi->max_write_size, ubi->min_io_size);
+                return -EINVAL;
+        }
+
         /* Calculate default aligned sizes of EC and VID headers */
         ubi->ec_hdr_alsize = ALIGN(UBI_EC_HDR_SIZE, ubi->hdrs_min_io_size);
         ubi->vid_hdr_alsize = ALIGN(UBI_VID_HDR_SIZE, ubi->hdrs_min_io_size);
 
         dbg_msg("min_io_size      %d", ubi->min_io_size);
+        dbg_msg("max_write_size   %d", ubi->max_write_size);
         dbg_msg("hdrs_min_io_size %d", ubi->hdrs_min_io_size);
         dbg_msg("ec_hdr_alsize    %d", ubi->ec_hdr_alsize);
         dbg_msg("vid_hdr_alsize   %d", ubi->vid_hdr_alsize);
@@ -737,7 +725,7 @@ static int io_init(struct ubi_device *ubi)
         }
 
         /* Similar for the data offset */
-        ubi->leb_start = ubi->vid_hdr_offset + UBI_EC_HDR_SIZE;
+        ubi->leb_start = ubi->vid_hdr_offset + UBI_VID_HDR_SIZE;
         ubi->leb_start = ALIGN(ubi->leb_start, ubi->min_io_size);
 
         dbg_msg("vid_hdr_offset   %d", ubi->vid_hdr_offset);
@@ -949,6 +937,8 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
         spin_lock_init(&ubi->volumes_lock);
 
         ubi_msg("attaching mtd%d to ubi%d", mtd->index, ubi_num);
+        dbg_msg("sizeof(struct ubi_scan_leb) %zu", sizeof(struct ubi_scan_leb));
+        dbg_msg("sizeof(struct ubi_wl_entry) %zu", sizeof(struct ubi_wl_entry));
 
         err = io_init(ubi);
         if (err)
@@ -963,13 +953,6 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
         if (!ubi->peb_buf2)
                 goto out_free;
 
-#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
-        mutex_init(&ubi->dbg_buf_mutex);
-        ubi->dbg_peb_buf = vmalloc(ubi->peb_size);
-        if (!ubi->dbg_peb_buf)
-                goto out_free;
-#endif
-
         err = attach_by_scanning(ubi);
         if (err) {
                 dbg_err("failed to attach by scanning, error %d", err);
@@ -1017,8 +1000,7 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
          * checks @ubi->thread_enabled. Otherwise we may fail to wake it up.
          */
         spin_lock(&ubi->wl_lock);
-        if (!DBG_DISABLE_BGT)
-                ubi->thread_enabled = 1;
+        ubi->thread_enabled = 1;
         wake_up_process(ubi->bgt_thread);
         spin_unlock(&ubi->wl_lock);
 
@@ -1035,9 +1017,6 @@ out_detach:
 out_free:
         vfree(ubi->peb_buf1);
         vfree(ubi->peb_buf2);
-#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
-        vfree(ubi->dbg_peb_buf);
-#endif
         if (ref)
                 put_device(&ubi->dev);
         else
@@ -1108,9 +1087,6 @@ int ubi_detach_mtd_dev(int ubi_num, int anyway)
         put_mtd_device(ubi->mtd);
         vfree(ubi->peb_buf1);
         vfree(ubi->peb_buf2);
-#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
-        vfree(ubi->dbg_peb_buf);
-#endif
         ubi_msg("mtd%d is detached from ubi%d", ubi->mtd->index, ubi->ubi_num);
         put_device(&ubi->dev);
         return 0;