Merge tag 'for-linus-3.3' of git://git.infradead.org/mtd-2.6

MTD pull for 3.3

* tag 'for-linus-3.3' of git://git.infradead.org/mtd-2.6: (113 commits)
  mtd: Fix dependency for MTD_DOC200x
  mtd: do not use mtd->block_markbad directly
  logfs: do not use 'mtd->block_isbad' directly
  mtd: introduce mtd_can_have_bb helper
  mtd: do not use mtd->suspend and mtd->resume directly
  mtd: do not use mtd->lock, unlock and is_locked directly
  mtd: do not use mtd->sync directly
  mtd: harmonize mtd_writev usage
  mtd: do not use mtd->lock_user_prot_reg directly
  mtd: mtd->write_user_prot_reg directly
  mtd: do not use mtd->read_*_prot_reg directly
  mtd: do not use mtd->get_*_prot_info directly
  mtd: do not use mtd->read_oob directly
  mtd: mtdoops: do not use mtd->panic_write directly
  romfs: do not use mtd->get_unmapped_area directly
  mtd: do not use mtd->get_unmapped_area directly
  mtd: do use mtd->point directly
  mtd: introduce mtd_has_oob helper
  mtd: mtdcore: export symbols cleanup
  mtd: clean-up the default_mtd_writev function
  ...

Fix up trivial edit/remove conflict in drivers/staging/spectra/lld_mtd.c

9 files changed, 98 insertions, 134 deletions

diff --git a/fs/jffs2/erase.c b/fs/jffs2/erase.c
index e513f1913c15..a01cdad6aad1 100644
--- a/fs/jffs2/erase.c
+++ b/fs/jffs2/erase.c
@@ -74,7 +74,7 @@ static void jffs2_erase_block(struct jffs2_sb_info *c,
         ((struct erase_priv_struct *)instr->priv)->jeb = jeb;
         ((struct erase_priv_struct *)instr->priv)->c = c;
 
-        ret = c->mtd->erase(c->mtd, instr);
+        ret = mtd_erase(c->mtd, instr);
         if (!ret)
                 return;
 
@@ -336,12 +336,11 @@ static int jffs2_block_check_erase(struct jffs2_sb_info *c, struct jffs2_erasebl
         uint32_t ofs;
         size_t retlen;
         int ret = -EIO;
+        unsigned long *wordebuf;
 
-        if (c->mtd->point) {
-                unsigned long *wordebuf;
-
-                ret = c->mtd->point(c->mtd, jeb->offset, c->sector_size,
-                                    &retlen, &ebuf, NULL);
+        ret = mtd_point(c->mtd, jeb->offset, c->sector_size, &retlen,
+                        &ebuf, NULL);
+        if (ret != -EOPNOTSUPP) {
                 if (ret) {
                         D1(printk(KERN_DEBUG "MTD point failed %d\n", ret));
                         goto do_flash_read;
@@ -349,7 +348,7 @@ static int jffs2_block_check_erase(struct jffs2_sb_info *c, struct jffs2_erasebl
                 if (retlen < c->sector_size) {
                         /* Don't muck about if it won't let us point to the whole erase sector */
                         D1(printk(KERN_DEBUG "MTD point returned len too short: 0x%zx\n", retlen));
-                        c->mtd->unpoint(c->mtd, jeb->offset, retlen);
+                        mtd_unpoint(c->mtd, jeb->offset, retlen);
                         goto do_flash_read;
                 }
                 wordebuf = ebuf-sizeof(*wordebuf);
@@ -358,7 +357,7 @@ static int jffs2_block_check_erase(struct jffs2_sb_info *c, struct jffs2_erasebl
                    if (*++wordebuf != ~0)
                            break;
                 } while(--retlen);
-                c->mtd->unpoint(c->mtd, jeb->offset, c->sector_size);
+                mtd_unpoint(c->mtd, jeb->offset, c->sector_size);
                 if (retlen) {
                         printk(KERN_WARNING "Newly-erased block contained word 0x%lx at offset 0x%08tx\n",
                                *wordebuf, jeb->offset + c->sector_size-retlen*sizeof(*wordebuf));
@@ -381,7 +380,7 @@ static int jffs2_block_check_erase(struct jffs2_sb_info *c, struct jffs2_erasebl
 
                 *bad_offset = ofs;
 
-                ret = c->mtd->read(c->mtd, ofs, readlen, &retlen, ebuf);
+                ret = mtd_read(c->mtd, ofs, readlen, &retlen, ebuf);
                 if (ret) {
                         printk(KERN_WARNING "Read of newly-erased block at 0x%08x failed: %d. Putting on bad_list\n", ofs, ret);
                         ret = -EIO;
diff --git a/fs/jffs2/fs.c b/fs/jffs2/fs.c
index 4b8afe39a87f..2e0123867cb1 100644
--- a/fs/jffs2/fs.c
+++ b/fs/jffs2/fs.c
@@ -466,7 +466,6 @@ struct inode *jffs2_new_inode (struct inode *dir_i, umode_t mode, struct jffs2_r
 
         if (insert_inode_locked(inode) < 0) {
                 make_bad_inode(inode);
-                unlock_new_inode(inode);
                 iput(inode);
                 return ERR_PTR(-EINVAL);
         }
diff --git a/fs/jffs2/readinode.c b/fs/jffs2/readinode.c
index ee57bac1ba6d..3093ac4fb24c 100644
--- a/fs/jffs2/readinode.c
+++ b/fs/jffs2/readinode.c
@@ -62,17 +62,15 @@ static int check_node_data(struct jffs2_sb_info *c, struct jffs2_tmp_dnode_info
 #ifndef __ECOS
         /* TODO: instead, incapsulate point() stuff to jffs2_flash_read(),
          * adding and jffs2_flash_read_end() interface. */
-        if (c->mtd->point) {
-                err = c->mtd->point(c->mtd, ofs, len, &retlen,
-                                    (void **)&buffer, NULL);
-                if (!err && retlen < len) {
-                        JFFS2_WARNING("MTD point returned len too short: %zu instead of %u.\n", retlen, tn->csize);
-                        c->mtd->unpoint(c->mtd, ofs, retlen);
-                } else if (err)
+        err = mtd_point(c->mtd, ofs, len, &retlen, (void **)&buffer, NULL);
+        if (!err && retlen < len) {
+                JFFS2_WARNING("MTD point returned len too short: %zu instead of %u.\n", retlen, tn->csize);
+                mtd_unpoint(c->mtd, ofs, retlen);
+        } else if (err) {
+                if (err != -EOPNOTSUPP)
                         JFFS2_WARNING("MTD point failed: error code %d.\n", err);
-                else
-                        pointed = 1; /* succefully pointed to device */
-        }
+        } else
+                pointed = 1; /* succefully pointed to device */
 #endif
 
         if (!pointed) {
@@ -101,7 +99,7 @@ static int check_node_data(struct jffs2_sb_info *c, struct jffs2_tmp_dnode_info
                 kfree(buffer);
 #ifndef __ECOS
         else
-                c->mtd->unpoint(c->mtd, ofs, len);
+                mtd_unpoint(c->mtd, ofs, len);
 #endif
 
         if (crc != tn->data_crc) {
@@ -137,7 +135,7 @@ free_out:
                 kfree(buffer);
 #ifndef __ECOS
         else
-                c->mtd->unpoint(c->mtd, ofs, len);
+                mtd_unpoint(c->mtd, ofs, len);
 #endif
         return err;
 }
diff --git a/fs/jffs2/scan.c b/fs/jffs2/scan.c
index 28107ca136e4..f99464833bb2 100644
--- a/fs/jffs2/scan.c
+++ b/fs/jffs2/scan.c
@@ -97,15 +97,15 @@ int jffs2_scan_medium(struct jffs2_sb_info *c)
         size_t pointlen, try_size;
 
         if (c->mtd->point) {
-                ret = c->mtd->point(c->mtd, 0, c->mtd->size, &pointlen,
-                                    (void **)&flashbuf, NULL);
+                ret = mtd_point(c->mtd, 0, c->mtd->size, &pointlen,
+                                (void **)&flashbuf, NULL);
                 if (!ret && pointlen < c->mtd->size) {
                         /* Don't muck about if it won't let us point to the whole flash */
                         D1(printk(KERN_DEBUG "MTD point returned len too short: 0x%zx\n", pointlen));
-                        c->mtd->unpoint(c->mtd, 0, pointlen);
+                        mtd_unpoint(c->mtd, 0, pointlen);
                         flashbuf = NULL;
                 }
-                if (ret)
+                if (ret && ret != -EOPNOTSUPP)
                         D1(printk(KERN_DEBUG "MTD point failed %d\n", ret));
         }
 #endif
@@ -273,7 +273,7 @@ int jffs2_scan_medium(struct jffs2_sb_info *c)
                 kfree(flashbuf);
 #ifndef __ECOS
         else
-                c->mtd->unpoint(c->mtd, 0, c->mtd->size);
+                mtd_unpoint(c->mtd, 0, c->mtd->size);
 #endif
         kfree(s);
         return ret;
@@ -455,7 +455,7 @@ static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblo
         if (jffs2_cleanmarker_oob(c)) {
                 int ret;
 
-                if (c->mtd->block_isbad(c->mtd, jeb->offset))
+                if (mtd_block_isbad(c->mtd, jeb->offset))
                         return BLK_STATE_BADBLOCK;
 
                 ret = jffs2_check_nand_cleanmarker(c, jeb);
diff --git a/fs/jffs2/super.c b/fs/jffs2/super.c
index 8be4925296cf..f2d96b5e64f6 100644
--- a/fs/jffs2/super.c
+++ b/fs/jffs2/super.c
@@ -335,9 +335,7 @@ static void jffs2_put_super (struct super_block *sb)
         jffs2_flash_cleanup(c);
         kfree(c->inocache_list);
         jffs2_clear_xattr_subsystem(c);
-        if (c->mtd->sync)
-                c->mtd->sync(c->mtd);
-
+        mtd_sync(c->mtd);
         D1(printk(KERN_DEBUG "jffs2_put_super returning\n"));
 }
 
diff --git a/fs/jffs2/wbuf.c b/fs/jffs2/wbuf.c
index b09e51d2f81f..30e8f47e8a23 100644
--- a/fs/jffs2/wbuf.c
+++ b/fs/jffs2/wbuf.c
@@ -228,7 +228,7 @@ static int jffs2_verify_write(struct jffs2_sb_info *c, unsigned char *buf,
         size_t retlen;
         char *eccstr;
 
-        ret = c->mtd->read(c->mtd, ofs, c->wbuf_pagesize, &retlen, c->wbuf_verify);
+        ret = mtd_read(c->mtd, ofs, c->wbuf_pagesize, &retlen, c->wbuf_verify);
         if (ret && ret != -EUCLEAN && ret != -EBADMSG) {
                 printk(KERN_WARNING "jffs2_verify_write(): Read back of page at %08x failed: %d\n", c->wbuf_ofs, ret);
                 return ret;
@@ -337,7 +337,8 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
                 }
 
                 /* Do the read... */
-                ret = c->mtd->read(c->mtd, start, c->wbuf_ofs - start, &retlen, buf);
+                ret = mtd_read(c->mtd, start, c->wbuf_ofs - start, &retlen,
+                               buf);
 
                 /* ECC recovered ? */
                 if ((ret == -EUCLEAN || ret == -EBADMSG) &&
@@ -413,13 +414,12 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
                 if (breakme++ == 20) {
                         printk(KERN_NOTICE "Faking write error at 0x%08x\n", ofs);
                         breakme = 0;
-                        c->mtd->write(c->mtd, ofs, towrite, &retlen,
-                                      brokenbuf);
+                        mtd_write(c->mtd, ofs, towrite, &retlen, brokenbuf);
                         ret = -EIO;
                 } else
 #endif
-                        ret = c->mtd->write(c->mtd, ofs, towrite, &retlen,
-                                            rewrite_buf);
+                        ret = mtd_write(c->mtd, ofs, towrite, &retlen,
+                                        rewrite_buf);
 
                 if (ret || retlen != towrite || jffs2_verify_write(c, rewrite_buf, ofs)) {
                         /* Argh. We tried. Really we did. */
@@ -619,13 +619,14 @@ static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
         if (breakme++ == 20) {
                 printk(KERN_NOTICE "Faking write error at 0x%08x\n", c->wbuf_ofs);
                 breakme = 0;
-                c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen,
-                              brokenbuf);
+                mtd_write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen,
+                          brokenbuf);
                 ret = -EIO;
         } else
 #endif
 
-                ret = c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf);
+                ret = mtd_write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize,
+                                &retlen, c->wbuf);
 
         if (ret) {
                 printk(KERN_WARNING "jffs2_flush_wbuf(): Write failed with %d\n", ret);
@@ -861,8 +862,8 @@ int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs,
                 v += wbuf_retlen;
 
                 if (vlen >= c->wbuf_pagesize) {
-                        ret = c->mtd->write(c->mtd, outvec_to, PAGE_DIV(vlen),
-                                            &wbuf_retlen, v);
+                        ret = mtd_write(c->mtd, outvec_to, PAGE_DIV(vlen),
+                                        &wbuf_retlen, v);
                         if (ret < 0 || wbuf_retlen != PAGE_DIV(vlen))
                                 goto outfile;
 
@@ -948,11 +949,11 @@ int jffs2_flash_read(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *re
         int     ret;
 
         if (!jffs2_is_writebuffered(c))
-                return c->mtd->read(c->mtd, ofs, len, retlen, buf);
+                return mtd_read(c->mtd, ofs, len, retlen, buf);
 
         /* Read flash */
         down_read(&c->wbuf_sem);
-        ret = c->mtd->read(c->mtd, ofs, len, retlen, buf);
+        ret = mtd_read(c->mtd, ofs, len, retlen, buf);
 
         if ( (ret == -EBADMSG || ret == -EUCLEAN) && (*retlen == len) ) {
                 if (ret == -EBADMSG)
@@ -1031,7 +1032,7 @@ int jffs2_check_oob_empty(struct jffs2_sb_info *c,
         ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
         ops.datbuf = NULL;
 
-        ret = c->mtd->read_oob(c->mtd, jeb->offset, &ops);
+        ret = mtd_read_oob(c->mtd, jeb->offset, &ops);
         if (ret || ops.oobretlen != ops.ooblen) {
                 printk(KERN_ERR "cannot read OOB for EB at %08x, requested %zd"
                                 " bytes, read %zd bytes, error %d\n",
@@ -1074,7 +1075,7 @@ int jffs2_check_nand_cleanmarker(struct jffs2_sb_info *c,
         ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
         ops.datbuf = NULL;
 
-        ret = c->mtd->read_oob(c->mtd, jeb->offset, &ops);
+        ret = mtd_read_oob(c->mtd, jeb->offset, &ops);
         if (ret || ops.oobretlen != ops.ooblen) {
                 printk(KERN_ERR "cannot read OOB for EB at %08x, requested %zd"
                                 " bytes, read %zd bytes, error %d\n",
@@ -1100,7 +1101,7 @@ int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c,
         ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
         ops.datbuf = NULL;
 
-        ret = c->mtd->write_oob(c->mtd, jeb->offset, &ops);
+        ret = mtd_write_oob(c->mtd, jeb->offset, &ops);
         if (ret || ops.oobretlen != ops.ooblen) {
                 printk(KERN_ERR "cannot write OOB for EB at %08x, requested %zd"
                                 " bytes, read %zd bytes, error %d\n",
@@ -1129,11 +1130,8 @@ int jffs2_write_nand_badblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *
         if( ++jeb->bad_count < MAX_ERASE_FAILURES)
                 return 0;
 
-        if (!c->mtd->block_markbad)
-                return 1; // What else can we do?
-
         printk(KERN_WARNING "JFFS2: marking eraseblock at %08x\n as bad", bad_offset);
-        ret = c->mtd->block_markbad(c->mtd, bad_offset);
+        ret = mtd_block_markbad(c->mtd, bad_offset);
 
         if (ret) {
                 D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
diff --git a/fs/jffs2/writev.c b/fs/jffs2/writev.c
index b9276b11bac6..a1bda9dab3f8 100644
--- a/fs/jffs2/writev.c
+++ b/fs/jffs2/writev.c
@@ -13,30 +13,6 @@
 #include <linux/mtd/mtd.h>
 #include "nodelist.h"
 
-/* This ought to be in core MTD code. All registered MTD devices
-   without writev should have this put in place. Bug the MTD
-   maintainer */
-static inline int mtd_fake_writev(struct mtd_info *mtd, const struct kvec *vecs,
-                                  unsigned long count, loff_t to, size_t *retlen)
-{
-        unsigned long i;
-        size_t totlen = 0, thislen;
-        int ret = 0;
-
-        for (i=0; i<count; i++) {
-                if (!vecs[i].iov_len)
-                        continue;
-                ret = mtd->write(mtd, to, vecs[i].iov_len, &thislen, vecs[i].iov_base);
-                totlen += thislen;
-                if (ret || thislen != vecs[i].iov_len)
-                        break;
-                to += vecs[i].iov_len;
-        }
-        if (retlen)
-                *retlen = totlen;
-        return ret;
-}
-
 int jffs2_flash_direct_writev(struct jffs2_sb_info *c, const struct kvec *vecs,
                               unsigned long count, loff_t to, size_t *retlen)
 {
@@ -50,18 +26,14 @@ int jffs2_flash_direct_writev(struct jffs2_sb_info *c, const struct kvec *vecs,
                 }
         }
 
-        if (c->mtd->writev)
-                return c->mtd->writev(c->mtd, vecs, count, to, retlen);
-        else {
-                return mtd_fake_writev(c->mtd, vecs, count, to, retlen);
-        }
+        return mtd_writev(c->mtd, vecs, count, to, retlen);
 }
 
 int jffs2_flash_direct_write(struct jffs2_sb_info *c, loff_t ofs, size_t len,
                         size_t *retlen, const u_char *buf)
 {
         int ret;
-        ret = c->mtd->write(c->mtd, ofs, len, retlen, buf);
+        ret = mtd_write(c->mtd, ofs, len, retlen, buf);
 
         if (jffs2_sum_active()) {
                 struct kvec vecs[1];
diff --git a/fs/logfs/dev_mtd.c b/fs/logfs/dev_mtd.c
index 339e17e9133d..e97404d611e0 100644
--- a/fs/logfs/dev_mtd.c
+++ b/fs/logfs/dev_mtd.c
@@ -13,13 +13,14 @@
 
 #define PAGE_OFS(ofs) ((ofs) & (PAGE_SIZE-1))
 
-static int mtd_read(struct super_block *sb, loff_t ofs, size_t len, void *buf)
+static int logfs_mtd_read(struct super_block *sb, loff_t ofs, size_t len,
+                        void *buf)
 {
         struct mtd_info *mtd = logfs_super(sb)->s_mtd;
         size_t retlen;
         int ret;
 
-        ret = mtd->read(mtd, ofs, len, &retlen, buf);
+        ret = mtd_read(mtd, ofs, len, &retlen, buf);
         BUG_ON(ret == -EINVAL);
         if (ret)
                 return ret;
@@ -31,7 +32,8 @@ static int mtd_read(struct super_block *sb, loff_t ofs, size_t len, void *buf)
         return 0;
 }
 
-static int mtd_write(struct super_block *sb, loff_t ofs, size_t len, void *buf)
+static int loffs_mtd_write(struct super_block *sb, loff_t ofs, size_t len,
+                        void *buf)
 {
         struct logfs_super *super = logfs_super(sb);
         struct mtd_info *mtd = super->s_mtd;
@@ -47,7 +49,7 @@ static int mtd_write(struct super_block *sb, loff_t ofs, size_t len, void *buf)
         BUG_ON(len > PAGE_CACHE_SIZE);
         page_start = ofs & PAGE_CACHE_MASK;
         page_end = PAGE_CACHE_ALIGN(ofs + len) - 1;
-        ret = mtd->write(mtd, ofs, len, &retlen, buf);
+        ret = mtd_write(mtd, ofs, len, &retlen, buf);
         if (ret || (retlen != len))
                 return -EIO;
 
@@ -60,14 +62,15 @@ static int mtd_write(struct super_block *sb, loff_t ofs, size_t len, void *buf)
  * asynchronous properties.  So just to prevent the first implementor of such
  * a thing from breaking logfs in 2350, we do the usual pointless dance to
  * declare a completion variable and wait for completion before returning
- * from mtd_erase().  What an exercise in futility!
+ * from logfs_mtd_erase().  What an exercise in futility!
  */
 static void logfs_erase_callback(struct erase_info *ei)
 {
         complete((struct completion *)ei->priv);
 }
 
-static int mtd_erase_mapping(struct super_block *sb, loff_t ofs, size_t len)
+static int logfs_mtd_erase_mapping(struct super_block *sb, loff_t ofs,
+                                size_t len)
 {
         struct logfs_super *super = logfs_super(sb);
         struct address_space *mapping = super->s_mapping_inode->i_mapping;
@@ -84,7 +87,7 @@ static int mtd_erase_mapping(struct super_block *sb, loff_t ofs, size_t len)
         return 0;
 }
 
-static int mtd_erase(struct super_block *sb, loff_t ofs, size_t len,
+static int logfs_mtd_erase(struct super_block *sb, loff_t ofs, size_t len,
                 int ensure_write)
 {
         struct mtd_info *mtd = logfs_super(sb)->s_mtd;
@@ -102,30 +105,29 @@ static int mtd_erase(struct super_block *sb, loff_t ofs, size_t len,
         ei.len = len;
         ei.callback = logfs_erase_callback;
         ei.priv = (long)&complete;
-        ret = mtd->erase(mtd, &ei);
+        ret = mtd_erase(mtd, &ei);
         if (ret)
                 return -EIO;
 
         wait_for_completion(&complete);
         if (ei.state != MTD_ERASE_DONE)
                 return -EIO;
-        return mtd_erase_mapping(sb, ofs, len);
+        return logfs_mtd_erase_mapping(sb, ofs, len);
 }
 
-static void mtd_sync(struct super_block *sb)
+static void logfs_mtd_sync(struct super_block *sb)
 {
         struct mtd_info *mtd = logfs_super(sb)->s_mtd;
 
-        if (mtd->sync)
-                mtd->sync(mtd);
+        mtd_sync(mtd);
 }
 
-static int mtd_readpage(void *_sb, struct page *page)
+static int logfs_mtd_readpage(void *_sb, struct page *page)
 {
         struct super_block *sb = _sb;
         int err;
 
-        err = mtd_read(sb, page->index << PAGE_SHIFT, PAGE_SIZE,
+        err = logfs_mtd_read(sb, page->index << PAGE_SHIFT, PAGE_SIZE,
                         page_address(page));
         if (err == -EUCLEAN || err == -EBADMSG) {
                 /* -EBADMSG happens regularly on power failures */
@@ -143,18 +145,18 @@ static int mtd_readpage(void *_sb, struct page *page)
         return err;
 }
 
-static struct page *mtd_find_first_sb(struct super_block *sb, u64 *ofs)
+static struct page *logfs_mtd_find_first_sb(struct super_block *sb, u64 *ofs)
 {
         struct logfs_super *super = logfs_super(sb);
         struct address_space *mapping = super->s_mapping_inode->i_mapping;
-        filler_t *filler = mtd_readpage;
+        filler_t *filler = logfs_mtd_readpage;
         struct mtd_info *mtd = super->s_mtd;
 
-        if (!mtd->block_isbad)
+        if (!mtd_can_have_bb(mtd))
                 return NULL;
 
         *ofs = 0;
-        while (mtd->block_isbad(mtd, *ofs)) {
+        while (mtd_block_isbad(mtd, *ofs)) {
                 *ofs += mtd->erasesize;
                 if (*ofs >= mtd->size)
                         return NULL;
@@ -163,18 +165,18 @@ static struct page *mtd_find_first_sb(struct super_block *sb, u64 *ofs)
         return read_cache_page(mapping, *ofs >> PAGE_SHIFT, filler, sb);
 }
 
-static struct page *mtd_find_last_sb(struct super_block *sb, u64 *ofs)
+static struct page *logfs_mtd_find_last_sb(struct super_block *sb, u64 *ofs)
 {
         struct logfs_super *super = logfs_super(sb);
         struct address_space *mapping = super->s_mapping_inode->i_mapping;
-        filler_t *filler = mtd_readpage;
+        filler_t *filler = logfs_mtd_readpage;
         struct mtd_info *mtd = super->s_mtd;
 
-        if (!mtd->block_isbad)
+        if (!mtd_can_have_bb(mtd))
                 return NULL;
 
         *ofs = mtd->size - mtd->erasesize;
-        while (mtd->block_isbad(mtd, *ofs)) {
+        while (mtd_block_isbad(mtd, *ofs)) {
                 *ofs -= mtd->erasesize;
                 if (*ofs <= 0)
                         return NULL;
@@ -184,7 +186,7 @@ static struct page *mtd_find_last_sb(struct super_block *sb, u64 *ofs)
         return read_cache_page(mapping, *ofs >> PAGE_SHIFT, filler, sb);
 }
 
-static int __mtd_writeseg(struct super_block *sb, u64 ofs, pgoff_t index,
+static int __logfs_mtd_writeseg(struct super_block *sb, u64 ofs, pgoff_t index,
                 size_t nr_pages)
 {
         struct logfs_super *super = logfs_super(sb);
@@ -196,8 +198,8 @@ static int __mtd_writeseg(struct super_block *sb, u64 ofs, pgoff_t index,
                 page = find_lock_page(mapping, index + i);
                 BUG_ON(!page);
 
-                err = mtd_write(sb, page->index << PAGE_SHIFT, PAGE_SIZE,
-                                page_address(page));
+                err = loffs_mtd_write(sb, page->index << PAGE_SHIFT, PAGE_SIZE,
+                                        page_address(page));
                 unlock_page(page);
                 page_cache_release(page);
                 if (err)
@@ -206,7 +208,7 @@ static int __mtd_writeseg(struct super_block *sb, u64 ofs, pgoff_t index,
         return 0;
 }
 
-static void mtd_writeseg(struct super_block *sb, u64 ofs, size_t len)
+static void logfs_mtd_writeseg(struct super_block *sb, u64 ofs, size_t len)
 {
         struct logfs_super *super = logfs_super(sb);
         int head;
@@ -227,15 +229,15 @@ static void mtd_writeseg(struct super_block *sb, u64 ofs, size_t len)
                 len += head;
         }
         len = PAGE_ALIGN(len);
-        __mtd_writeseg(sb, ofs, ofs >> PAGE_SHIFT, len >> PAGE_SHIFT);
+        __logfs_mtd_writeseg(sb, ofs, ofs >> PAGE_SHIFT, len >> PAGE_SHIFT);
 }
 
-static void mtd_put_device(struct logfs_super *s)
+static void logfs_mtd_put_device(struct logfs_super *s)
 {
         put_mtd_device(s->s_mtd);
 }
 
-static int mtd_can_write_buf(struct super_block *sb, u64 ofs)
+static int logfs_mtd_can_write_buf(struct super_block *sb, u64 ofs)
 {
         struct logfs_super *super = logfs_super(sb);
         void *buf;
@@ -244,7 +246,7 @@ static int mtd_can_write_buf(struct super_block *sb, u64 ofs)
         buf = kmalloc(super->s_writesize, GFP_KERNEL);
         if (!buf)
                 return -ENOMEM;
-        err = mtd_read(sb, ofs, super->s_writesize, buf);
+        err = logfs_mtd_read(sb, ofs, super->s_writesize, buf);
         if (err)
                 goto out;
         if (memchr_inv(buf, 0xff, super->s_writesize))
@@ -255,14 +257,14 @@ out:
 }
 
 static const struct logfs_device_ops mtd_devops = {
-        .find_first_sb  = mtd_find_first_sb,
-        .find_last_sb   = mtd_find_last_sb,
-        .readpage       = mtd_readpage,
-        .writeseg       = mtd_writeseg,
-        .erase          = mtd_erase,
-        .can_write_buf  = mtd_can_write_buf,
-        .sync           = mtd_sync,
-        .put_device     = mtd_put_device,
+        .find_first_sb  = logfs_mtd_find_first_sb,
+        .find_last_sb   = logfs_mtd_find_last_sb,
+        .readpage       = logfs_mtd_readpage,
+        .writeseg       = logfs_mtd_writeseg,
+        .erase          = logfs_mtd_erase,
+        .can_write_buf  = logfs_mtd_can_write_buf,
+        .sync           = logfs_mtd_sync,
+        .put_device     = logfs_mtd_put_device,
 };
 
 int logfs_get_sb_mtd(struct logfs_super *s, int mtdnr)
diff --git a/fs/romfs/mmap-nommu.c b/fs/romfs/mmap-nommu.c
index eed99428f104..e1a7779dd3cb 100644
--- a/fs/romfs/mmap-nommu.c
+++ b/fs/romfs/mmap-nommu.c
@@ -28,9 +28,10 @@ static unsigned long romfs_get_unmapped_area(struct file *file,
         struct inode *inode = file->f_mapping->host;
         struct mtd_info *mtd = inode->i_sb->s_mtd;
         unsigned long isize, offset, maxpages, lpages;
+        int ret;
 
         if (!mtd)
-                goto cant_map_directly;
+                return (unsigned long) -ENOSYS;
 
         /* the mapping mustn't extend beyond the EOF */
         lpages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
@@ -41,23 +42,20 @@ static unsigned long romfs_get_unmapped_area(struct file *file,
         if ((pgoff >= maxpages) || (maxpages - pgoff < lpages))
                 return (unsigned long) -EINVAL;
 
-        /* we need to call down to the MTD layer to do the actual mapping */
-        if (mtd->get_unmapped_area) {
-                if (addr != 0)
-                        return (unsigned long) -EINVAL;
-
-                if (len > mtd->size || pgoff >= (mtd->size >> PAGE_SHIFT))
-                        return (unsigned long) -EINVAL;
+        if (addr != 0)
+                return (unsigned long) -EINVAL;
 
-                offset += ROMFS_I(inode)->i_dataoffset;
-                if (offset > mtd->size - len)
-                        return (unsigned long) -EINVAL;
+        if (len > mtd->size || pgoff >= (mtd->size >> PAGE_SHIFT))
+                return (unsigned long) -EINVAL;
 
-                return mtd->get_unmapped_area(mtd, len, offset, flags);
-        }
+        offset += ROMFS_I(inode)->i_dataoffset;
+        if (offset > mtd->size - len)
+                return (unsigned long) -EINVAL;
 
-cant_map_directly:
-        return (unsigned long) -ENOSYS;
+        ret = mtd_get_unmapped_area(mtd, len, offset, flags);
+        if (ret == -EOPNOTSUPP)
+                ret = -ENOSYS;
+        return (unsigned long) ret;
 }
 
 /*