Patched in Tegra support.

1 files changed, 101 insertions, 157 deletions

diff --git a/fs/jffs2/wbuf.c b/fs/jffs2/wbuf.c
index a6597d60d76..4515bea0268 100644
--- a/fs/jffs2/wbuf.c
+++ b/fs/jffs2/wbuf.c
@@ -11,8 +11,6 @@
  *
  */
 
-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
-
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/mtd/mtd.h>
@@ -20,7 +18,6 @@
 #include <linux/mtd/nand.h>
 #include <linux/jiffies.h>
 #include <linux/sched.h>
-#include <linux/writeback.h>
 
 #include "nodelist.h"
 
@@ -86,7 +83,7 @@ static void jffs2_wbuf_dirties_inode(struct jffs2_sb_info *c, uint32_t ino)
 {
         struct jffs2_inodirty *new;
 
-        /* Schedule delayed write-buffer write-out */
+        /* Mark the superblock dirty so that kupdated will flush... */
         jffs2_dirty_trigger(c);
 
         if (jffs2_wbuf_pending_for_ino(c, ino))
@@ -94,7 +91,7 @@ static void jffs2_wbuf_dirties_inode(struct jffs2_sb_info *c, uint32_t ino)
 
         new = kmalloc(sizeof(*new), GFP_KERNEL);
         if (!new) {
-                jffs2_dbg(1, "No memory to allocate inodirty. Fallback to all considered dirty\n");
+                D1(printk(KERN_DEBUG "No memory to allocate inodirty. Fallback to all considered dirty\n"));
                 jffs2_clear_wbuf_ino_list(c);
                 c->wbuf_inodes = &inodirty_nomem;
                 return;
@@ -116,20 +113,19 @@ static inline void jffs2_refile_wbuf_blocks(struct jffs2_sb_info *c)
         list_for_each_safe(this, next, &c->erasable_pending_wbuf_list) {
                 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
 
-                jffs2_dbg(1, "Removing eraseblock at 0x%08x from erasable_pending_wbuf_list...\n",
-                          jeb->offset);
+                D1(printk(KERN_DEBUG "Removing eraseblock at 0x%08x from erasable_pending_wbuf_list...\n", jeb->offset));
                 list_del(this);
                 if ((jiffies + (n++)) & 127) {
                         /* Most of the time, we just erase it immediately. Otherwise we
                            spend ages scanning it on mount, etc. */
-                        jffs2_dbg(1, "...and adding to erase_pending_list\n");
+                        D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n"));
                         list_add_tail(&jeb->list, &c->erase_pending_list);
                         c->nr_erasing_blocks++;
                         jffs2_garbage_collect_trigger(c);
                 } else {
                         /* Sometimes, however, we leave it elsewhere so it doesn't get
                            immediately reused, and we spread the load a bit. */
-                        jffs2_dbg(1, "...and adding to erasable_list\n");
+                        D1(printk(KERN_DEBUG "...and adding to erasable_list\n"));
                         list_add_tail(&jeb->list, &c->erasable_list);
                 }
         }
@@ -140,7 +136,7 @@ static inline void jffs2_refile_wbuf_blocks(struct jffs2_sb_info *c)
 
 static void jffs2_block_refile(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int allow_empty)
 {
-        jffs2_dbg(1, "About to refile bad block at %08x\n", jeb->offset);
+        D1(printk("About to refile bad block at %08x\n", jeb->offset));
 
         /* File the existing block on the bad_used_list.... */
         if (c->nextblock == jeb)
@@ -148,14 +144,12 @@ static void jffs2_block_refile(struct jffs2_sb_info *c, struct jffs2_eraseblock
         else /* Not sure this should ever happen... need more coffee */
                 list_del(&jeb->list);
         if (jeb->first_node) {
-                jffs2_dbg(1, "Refiling block at %08x to bad_used_list\n",
-                          jeb->offset);
+                D1(printk("Refiling block at %08x to bad_used_list\n", jeb->offset));
                 list_add(&jeb->list, &c->bad_used_list);
         } else {
                 BUG_ON(allow_empty == REFILE_NOTEMPTY);
                 /* It has to have had some nodes or we couldn't be here */
-                jffs2_dbg(1, "Refiling block at %08x to erase_pending_list\n",
-                          jeb->offset);
+                D1(printk("Refiling block at %08x to erase_pending_list\n", jeb->offset));
                 list_add(&jeb->list, &c->erase_pending_list);
                 c->nr_erasing_blocks++;
                 jffs2_garbage_collect_trigger(c);
@@ -234,14 +228,12 @@ static int jffs2_verify_write(struct jffs2_sb_info *c, unsigned char *buf,
         size_t retlen;
         char *eccstr;
 
-        ret = mtd_read(c->mtd, ofs, c->wbuf_pagesize, &retlen, c->wbuf_verify);
+        ret = c->mtd->read(c->mtd, ofs, c->wbuf_pagesize, &retlen, c->wbuf_verify);
         if (ret && ret != -EUCLEAN && ret != -EBADMSG) {
-                pr_warn("%s(): Read back of page at %08x failed: %d\n",
-                        __func__, c->wbuf_ofs, ret);
+                printk(KERN_WARNING "jffs2_verify_write(): Read back of page at %08x failed: %d\n", c->wbuf_ofs, ret);
                 return ret;
         } else if (retlen != c->wbuf_pagesize) {
-                pr_warn("%s(): Read back of page at %08x gave short read: %zd not %d\n",
-                        __func__, ofs, retlen, c->wbuf_pagesize);
+                printk(KERN_WARNING "jffs2_verify_write(): Read back of page at %08x gave short read: %zd not %d.\n", ofs, retlen, c->wbuf_pagesize);
                 return -EIO;
         }
         if (!memcmp(buf, c->wbuf_verify, c->wbuf_pagesize))
@@ -254,12 +246,12 @@ static int jffs2_verify_write(struct jffs2_sb_info *c, unsigned char *buf,
         else
                 eccstr = "OK or unused";
 
-        pr_warn("Write verify error (ECC %s) at %08x. Wrote:\n",
-                eccstr, c->wbuf_ofs);
+        printk(KERN_WARNING "Write verify error (ECC %s) at %08x. Wrote:\n",
+               eccstr, c->wbuf_ofs);
         print_hex_dump(KERN_WARNING, "", DUMP_PREFIX_OFFSET, 16, 1,
                        c->wbuf, c->wbuf_pagesize, 0);
 
-        pr_warn("Read back:\n");
+        printk(KERN_WARNING "Read back:\n");
         print_hex_dump(KERN_WARNING, "", DUMP_PREFIX_OFFSET, 16, 1,
                        c->wbuf_verify, c->wbuf_pagesize, 0);
 
@@ -316,7 +308,7 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
 
         if (!first_raw) {
                 /* All nodes were obsolete. Nothing to recover. */
-                jffs2_dbg(1, "No non-obsolete nodes to be recovered. Just filing block bad\n");
+                D1(printk(KERN_DEBUG "No non-obsolete nodes to be recovered. Just filing block bad\n"));
                 c->wbuf_len = 0;
                 return;
         }
@@ -339,14 +331,13 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
 
                 buf = kmalloc(end - start, GFP_KERNEL);
                 if (!buf) {
-                        pr_crit("Malloc failure in wbuf recovery. Data loss ensues.\n");
+                        printk(KERN_CRIT "Malloc failure in wbuf recovery. Data loss ensues.\n");
 
                         goto read_failed;
                 }
 
                 /* Do the read... */
-                ret = mtd_read(c->mtd, start, c->wbuf_ofs - start, &retlen,
-                               buf);
+                ret = c->mtd->read(c->mtd, start, c->wbuf_ofs - start, &retlen, buf);
 
                 /* ECC recovered ? */
                 if ((ret == -EUCLEAN || ret == -EBADMSG) &&
@@ -354,7 +345,7 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
                         ret = 0;
 
                 if (ret || retlen != c->wbuf_ofs - start) {
-                        pr_crit("Old data are already lost in wbuf recovery. Data loss ensues.\n");
+                        printk(KERN_CRIT "Old data are already lost in wbuf recovery. Data loss ensues.\n");
 
                         kfree(buf);
                         buf = NULL;
@@ -388,7 +379,7 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
         /* ... and get an allocation of space from a shiny new block instead */
         ret = jffs2_reserve_space_gc(c, end-start, &len, JFFS2_SUMMARY_NOSUM_SIZE);
         if (ret) {
-                pr_warn("Failed to allocate space for wbuf recovery. Data loss ensues.\n");
+                printk(KERN_WARNING "Failed to allocate space for wbuf recovery. Data loss ensues.\n");
                 kfree(buf);
                 return;
         }
@@ -398,7 +389,7 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
 
         ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, nr_refile);
         if (ret) {
-                pr_warn("Failed to allocate node refs for wbuf recovery. Data loss ensues.\n");
+                printk(KERN_WARNING "Failed to allocate node refs for wbuf recovery. Data loss ensues.\n");
                 kfree(buf);
                 return;
         }
@@ -414,24 +405,25 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
                 unsigned char *rewrite_buf = buf?:c->wbuf;
                 uint32_t towrite = (end-start) - ((end-start)%c->wbuf_pagesize);
 
-                jffs2_dbg(1, "Write 0x%x bytes at 0x%08x in wbuf recover\n",
-                          towrite, ofs);
+                D1(printk(KERN_DEBUG "Write 0x%x bytes at 0x%08x in wbuf recover\n",
+                          towrite, ofs));
 
 #ifdef BREAKMEHEADER
                 static int breakme;
                 if (breakme++ == 20) {
-                        pr_notice("Faking write error at 0x%08x\n", ofs);
+                        printk(KERN_NOTICE "Faking write error at 0x%08x\n", ofs);
                         breakme = 0;
-                        mtd_write(c->mtd, ofs, towrite, &retlen, brokenbuf);
+                        c->mtd->write(c->mtd, ofs, towrite, &retlen,
+                                      brokenbuf);
                         ret = -EIO;
                 } else
 #endif
-                        ret = mtd_write(c->mtd, ofs, towrite, &retlen,
-                                        rewrite_buf);
+                        ret = c->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. */
-                        pr_crit("Recovery of wbuf failed due to a second write error\n");
+                        printk(KERN_CRIT "Recovery of wbuf failed due to a second write error\n");
                         kfree(buf);
 
                         if (retlen)
@@ -439,7 +431,7 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
 
                         return;
                 }
-                pr_notice("Recovery of wbuf succeeded to %08x\n", ofs);
+                printk(KERN_NOTICE "Recovery of wbuf succeeded to %08x\n", ofs);
 
                 c->wbuf_len = (end - start) - towrite;
                 c->wbuf_ofs = ofs + towrite;
@@ -467,8 +459,8 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
                 struct jffs2_raw_node_ref **adjust_ref = NULL;
                 struct jffs2_inode_info *f = NULL;
 
-                jffs2_dbg(1, "Refiling block of %08x at %08x(%d) to %08x\n",
-                          rawlen, ref_offset(raw), ref_flags(raw), ofs);
+                D1(printk(KERN_DEBUG "Refiling block of %08x at %08x(%d) to %08x\n",
+                          rawlen, ref_offset(raw), ref_flags(raw), ofs));
 
                 ic = jffs2_raw_ref_to_ic(raw);
 
@@ -548,8 +540,7 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
 
         /* Fix up the original jeb now it's on the bad_list */
         if (first_raw == jeb->first_node) {
-                jffs2_dbg(1, "Failing block at %08x is now empty. Moving to erase_pending_list\n",
-                          jeb->offset);
+                D1(printk(KERN_DEBUG "Failing block at %08x is now empty. Moving to erase_pending_list\n", jeb->offset));
                 list_move(&jeb->list, &c->erase_pending_list);
                 c->nr_erasing_blocks++;
                 jffs2_garbage_collect_trigger(c);
@@ -563,8 +554,7 @@ static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
 
         spin_unlock(&c->erase_completion_lock);
 
-        jffs2_dbg(1, "wbuf recovery completed OK. wbuf_ofs 0x%08x, len 0x%x\n",
-                  c->wbuf_ofs, c->wbuf_len);
+        D1(printk(KERN_DEBUG "wbuf recovery completed OK. wbuf_ofs 0x%08x, len 0x%x\n", c->wbuf_ofs, c->wbuf_len));
 
 }
 
@@ -588,8 +578,9 @@ static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
         if (!jffs2_is_writebuffered(c))
                 return 0;
 
-        if (!mutex_is_locked(&c->alloc_sem)) {
-                pr_crit("jffs2_flush_wbuf() called with alloc_sem not locked!\n");
+        if (mutex_trylock(&c->alloc_sem)) {
+                mutex_unlock(&c->alloc_sem);
+                printk(KERN_CRIT "jffs2_flush_wbuf() called with alloc_sem not locked!\n");
                 BUG();
         }
 
@@ -627,23 +618,22 @@ static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
 #ifdef BREAKME
         static int breakme;
         if (breakme++ == 20) {
-                pr_notice("Faking write error at 0x%08x\n", c->wbuf_ofs);
+                printk(KERN_NOTICE "Faking write error at 0x%08x\n", c->wbuf_ofs);
                 breakme = 0;
-                mtd_write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen,
-                          brokenbuf);
+                c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen,
+                              brokenbuf);
                 ret = -EIO;
         } else
 #endif
 
-                ret = mtd_write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize,
-                                &retlen, c->wbuf);
+                ret = c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf);
 
         if (ret) {
-                pr_warn("jffs2_flush_wbuf(): Write failed with %d\n", ret);
+                printk(KERN_WARNING "jffs2_flush_wbuf(): Write failed with %d\n", ret);
                 goto wfail;
         } else if (retlen != c->wbuf_pagesize) {
-                pr_warn("jffs2_flush_wbuf(): Write was short: %zd instead of %d\n",
-                        retlen, c->wbuf_pagesize);
+                printk(KERN_WARNING "jffs2_flush_wbuf(): Write was short: %zd instead of %d\n",
+                       retlen, c->wbuf_pagesize);
                 ret = -EIO;
                 goto wfail;
         } else if ((ret = jffs2_verify_write(c, c->wbuf, c->wbuf_ofs))) {
@@ -657,18 +647,17 @@ static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
         if (pad) {
                 uint32_t waste = c->wbuf_pagesize - c->wbuf_len;
 
-                jffs2_dbg(1, "jffs2_flush_wbuf() adjusting free_size of %sblock at %08x\n",
-                          (wbuf_jeb == c->nextblock) ? "next" : "",
-                          wbuf_jeb->offset);
+                D1(printk(KERN_DEBUG "jffs2_flush_wbuf() adjusting free_size of %sblock at %08x\n",
+                          (wbuf_jeb==c->nextblock)?"next":"", wbuf_jeb->offset));
 
                 /* wbuf_pagesize - wbuf_len is the amount of space that's to be
                    padded. If there is less free space in the block than that,
                    something screwed up */
                 if (wbuf_jeb->free_size < waste) {
-                        pr_crit("jffs2_flush_wbuf(): Accounting error. wbuf at 0x%08x has 0x%03x bytes, 0x%03x left.\n",
-                                c->wbuf_ofs, c->wbuf_len, waste);
-                        pr_crit("jffs2_flush_wbuf(): But free_size for block at 0x%08x is only 0x%08x\n",
-                                wbuf_jeb->offset, wbuf_jeb->free_size);
+                        printk(KERN_CRIT "jffs2_flush_wbuf(): Accounting error. wbuf at 0x%08x has 0x%03x bytes, 0x%03x left.\n",
+                               c->wbuf_ofs, c->wbuf_len, waste);
+                        printk(KERN_CRIT "jffs2_flush_wbuf(): But free_size for block at 0x%08x is only 0x%08x\n",
+                               wbuf_jeb->offset, wbuf_jeb->free_size);
                         BUG();
                 }
 
@@ -705,14 +694,14 @@ int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino)
         uint32_t old_wbuf_len;
         int ret = 0;
 
-        jffs2_dbg(1, "jffs2_flush_wbuf_gc() called for ino #%u...\n", ino);
+        D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() called for ino #%u...\n", ino));
 
         if (!c->wbuf)
                 return 0;
 
         mutex_lock(&c->alloc_sem);
         if (!jffs2_wbuf_pending_for_ino(c, ino)) {
-                jffs2_dbg(1, "Ino #%d not pending in wbuf. Returning\n", ino);
+                D1(printk(KERN_DEBUG "Ino #%d not pending in wbuf. Returning\n", ino));
                 mutex_unlock(&c->alloc_sem);
                 return 0;
         }
@@ -722,8 +711,7 @@ int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino)
 
         if (c->unchecked_size) {
                 /* GC won't make any progress for a while */
-                jffs2_dbg(1, "%s(): padding. Not finished checking\n",
-                          __func__);
+                D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() padding. Not finished checking\n"));
                 down_write(&c->wbuf_sem);
                 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
                 /* retry flushing wbuf in case jffs2_wbuf_recover
@@ -736,7 +724,7 @@ int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino)
 
                 mutex_unlock(&c->alloc_sem);
 
-                jffs2_dbg(1, "%s(): calls gc pass\n", __func__);
+                D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() calls gc pass\n"));
 
                 ret = jffs2_garbage_collect_pass(c);
                 if (ret) {
@@ -754,7 +742,7 @@ int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino)
                 mutex_lock(&c->alloc_sem);
         }
 
-        jffs2_dbg(1, "%s(): ends...\n", __func__);
+        D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() ends...\n"));
 
         mutex_unlock(&c->alloc_sem);
         return ret;
@@ -823,8 +811,9 @@ int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs,
         if (SECTOR_ADDR(to) != SECTOR_ADDR(c->wbuf_ofs)) {
                 /* It's a write to a new block */
                 if (c->wbuf_len) {
-                        jffs2_dbg(1, "%s(): to 0x%lx causes flush of wbuf at 0x%08x\n",
-                                  __func__, (unsigned long)to, c->wbuf_ofs);
+                        D1(printk(KERN_DEBUG "jffs2_flash_writev() to 0x%lx "
+                                  "causes flush of wbuf at 0x%08x\n",
+                                  (unsigned long)to, c->wbuf_ofs));
                         ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
                         if (ret)
                                 goto outerr;
@@ -836,11 +825,11 @@ int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs,
 
         if (to != PAD(c->wbuf_ofs + c->wbuf_len)) {
                 /* We're not writing immediately after the writebuffer. Bad. */
-                pr_crit("%s(): Non-contiguous write to %08lx\n",
-                        __func__, (unsigned long)to);
+                printk(KERN_CRIT "jffs2_flash_writev(): Non-contiguous write "
+                       "to %08lx\n", (unsigned long)to);
                 if (c->wbuf_len)
-                        pr_crit("wbuf was previously %08x-%08x\n",
-                                c->wbuf_ofs, c->wbuf_ofs + c->wbuf_len);
+                        printk(KERN_CRIT "wbuf was previously %08x-%08x\n",
+                               c->wbuf_ofs, c->wbuf_ofs+c->wbuf_len);
                 BUG();
         }
 
@@ -873,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 = mtd_write(c->mtd, outvec_to, PAGE_DIV(vlen),
-                                        &wbuf_retlen, v);
+                        ret = c->mtd->write(c->mtd, outvec_to, PAGE_DIV(vlen),
+                                            &wbuf_retlen, v);
                         if (ret < 0 || wbuf_retlen != PAGE_DIV(vlen))
                                 goto outfile;
 
@@ -960,16 +949,16 @@ 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 mtd_read(c->mtd, ofs, len, retlen, buf);
+                return c->mtd->read(c->mtd, ofs, len, retlen, buf);
 
         /* Read flash */
         down_read(&c->wbuf_sem);
-        ret = mtd_read(c->mtd, ofs, len, retlen, buf);
+        ret = c->mtd->read(c->mtd, ofs, len, retlen, buf);
 
         if ( (ret == -EBADMSG || ret == -EUCLEAN) && (*retlen == len) ) {
                 if (ret == -EBADMSG)
-                        pr_warn("mtd->read(0x%zx bytes from 0x%llx) returned ECC error\n",
-                                len, ofs);
+                        printk(KERN_WARNING "mtd->read(0x%zx bytes from 0x%llx)"
+                               " returned ECC error\n", len, ofs);
                 /*
                  * We have the raw data without ECC correction in the buffer,
                  * maybe we are lucky and all data or parts are correct. We
@@ -1037,17 +1026,18 @@ int jffs2_check_oob_empty(struct jffs2_sb_info *c,
         int cmlen = min_t(int, c->oobavail, OOB_CM_SIZE);
         struct mtd_oob_ops ops;
 
-        ops.mode = MTD_OPS_AUTO_OOB;
+        ops.mode = MTD_OOB_AUTO;
         ops.ooblen = NR_OOB_SCAN_PAGES * c->oobavail;
         ops.oobbuf = c->oobbuf;
         ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
         ops.datbuf = NULL;
 
-        ret = mtd_read_oob(c->mtd, jeb->offset, &ops);
-        if ((ret && !mtd_is_bitflip(ret)) || ops.oobretlen != ops.ooblen) {
-                pr_err("cannot read OOB for EB at %08x, requested %zd bytes, read %zd bytes, error %d\n",
-                       jeb->offset, ops.ooblen, ops.oobretlen, ret);
-                if (!ret || mtd_is_bitflip(ret))
+        ret = c->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",
+                                jeb->offset, ops.ooblen, ops.oobretlen, ret);
+                if (!ret)
                         ret = -EIO;
                 return ret;
         }
@@ -1058,8 +1048,8 @@ int jffs2_check_oob_empty(struct jffs2_sb_info *c,
                         continue;
 
                 if (ops.oobbuf[i] != 0xFF) {
-                        jffs2_dbg(2, "Found %02x at %x in OOB for "
-                                  "%08x\n", ops.oobbuf[i], i, jeb->offset);
+                        D2(printk(KERN_DEBUG "Found %02x at %x in OOB for "
+                                  "%08x\n", ops.oobbuf[i], i, jeb->offset));
                         return 1;
                 }
         }
@@ -1079,17 +1069,18 @@ int jffs2_check_nand_cleanmarker(struct jffs2_sb_info *c,
         struct mtd_oob_ops ops;
         int ret, cmlen = min_t(int, c->oobavail, OOB_CM_SIZE);
 
-        ops.mode = MTD_OPS_AUTO_OOB;
+        ops.mode = MTD_OOB_AUTO;
         ops.ooblen = cmlen;
         ops.oobbuf = c->oobbuf;
         ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
         ops.datbuf = NULL;
 
-        ret = mtd_read_oob(c->mtd, jeb->offset, &ops);
-        if ((ret && !mtd_is_bitflip(ret)) || ops.oobretlen != ops.ooblen) {
-                pr_err("cannot read OOB for EB at %08x, requested %zd bytes, read %zd bytes, error %d\n",
-                       jeb->offset, ops.ooblen, ops.oobretlen, ret);
-                if (!ret || mtd_is_bitflip(ret))
+        ret = c->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",
+                                jeb->offset, ops.ooblen, ops.oobretlen, ret);
+                if (!ret)
                         ret = -EIO;
                 return ret;
         }
@@ -1104,16 +1095,17 @@ int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c,
         struct mtd_oob_ops ops;
         int cmlen = min_t(int, c->oobavail, OOB_CM_SIZE);
 
-        ops.mode = MTD_OPS_AUTO_OOB;
+        ops.mode = MTD_OOB_AUTO;
         ops.ooblen = cmlen;
         ops.oobbuf = (uint8_t *)&oob_cleanmarker;
         ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
         ops.datbuf = NULL;
 
-        ret = mtd_write_oob(c->mtd, jeb->offset, &ops);
+        ret = c->mtd->write_oob(c->mtd, jeb->offset, &ops);
         if (ret || ops.oobretlen != ops.ooblen) {
-                pr_err("cannot write OOB for EB at %08x, requested %zd bytes, read %zd bytes, error %d\n",
-                       jeb->offset, ops.ooblen, ops.oobretlen, ret);
+                printk(KERN_ERR "cannot write OOB for EB at %08x, requested %zd"
+                                " bytes, read %zd bytes, error %d\n",
+                                jeb->offset, ops.ooblen, ops.oobretlen, ret);
                 if (!ret)
                         ret = -EIO;
                 return ret;
@@ -1138,58 +1130,19 @@ int jffs2_write_nand_badblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *
         if( ++jeb->bad_count < MAX_ERASE_FAILURES)
                 return 0;
 
-        pr_warn("marking eraseblock at %08x as bad\n", bad_offset);
-        ret = mtd_block_markbad(c->mtd, bad_offset);
+        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);
 
         if (ret) {
-                jffs2_dbg(1, "%s(): Write failed for block at %08x: error %d\n",
-                          __func__, jeb->offset, ret);
+                D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
                 return ret;
         }
         return 1;
 }
 
-static struct jffs2_sb_info *work_to_sb(struct work_struct *work)
-{
-        struct delayed_work *dwork;
-
-        dwork = container_of(work, struct delayed_work, work);
-        return container_of(dwork, struct jffs2_sb_info, wbuf_dwork);
-}
-
-static void delayed_wbuf_sync(struct work_struct *work)
-{
-        struct jffs2_sb_info *c = work_to_sb(work);
-        struct super_block *sb = OFNI_BS_2SFFJ(c);
-
-        spin_lock(&c->wbuf_dwork_lock);
-        c->wbuf_queued = 0;
-        spin_unlock(&c->wbuf_dwork_lock);
-
-        if (!(sb->s_flags & MS_RDONLY)) {
-                jffs2_dbg(1, "%s()\n", __func__);
-                jffs2_flush_wbuf_gc(c, 0);
-        }
-}
-
-void jffs2_dirty_trigger(struct jffs2_sb_info *c)
-{
-        struct super_block *sb = OFNI_BS_2SFFJ(c);
-        unsigned long delay;
-
-        if (sb->s_flags & MS_RDONLY)
-                return;
-
-        spin_lock(&c->wbuf_dwork_lock);
-        if (!c->wbuf_queued) {
-                jffs2_dbg(1, "%s()\n", __func__);
-                delay = msecs_to_jiffies(dirty_writeback_interval * 10);
-                queue_delayed_work(system_long_wq, &c->wbuf_dwork, delay);
-                c->wbuf_queued = 1;
-        }
-        spin_unlock(&c->wbuf_dwork_lock);
-}
-
 int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
 {
         struct nand_ecclayout *oinfo = c->mtd->ecclayout;
@@ -1201,18 +1154,16 @@ int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
         c->cleanmarker_size = 0;
 
         if (!oinfo || oinfo->oobavail == 0) {
-                pr_err("inconsistent device description\n");
+                printk(KERN_ERR "inconsistent device description\n");
                 return -EINVAL;
         }
 
-        jffs2_dbg(1, "using OOB on NAND\n");
+        D1(printk(KERN_DEBUG "JFFS2 using OOB on NAND\n"));
 
         c->oobavail = oinfo->oobavail;
 
         /* Initialise write buffer */
         init_rwsem(&c->wbuf_sem);
-        spin_lock_init(&c->wbuf_dwork_lock);
-        INIT_DELAYED_WORK(&c->wbuf_dwork, delayed_wbuf_sync);
         c->wbuf_pagesize = c->mtd->writesize;
         c->wbuf_ofs = 0xFFFFFFFF;
 
@@ -1251,8 +1202,8 @@ int jffs2_dataflash_setup(struct jffs2_sb_info *c) {
 
         /* Initialize write buffer */
         init_rwsem(&c->wbuf_sem);
-        spin_lock_init(&c->wbuf_dwork_lock);
-        INIT_DELAYED_WORK(&c->wbuf_dwork, delayed_wbuf_sync);
+
+
         c->wbuf_pagesize =  c->mtd->erasesize;
 
         /* Find a suitable c->sector_size
@@ -1274,7 +1225,7 @@ int jffs2_dataflash_setup(struct jffs2_sb_info *c) {
 
         if ((c->flash_size % c->sector_size) != 0) {
                 c->flash_size = (c->flash_size / c->sector_size) * c->sector_size;
-                pr_warn("flash size adjusted to %dKiB\n", c->flash_size);
+                printk(KERN_WARNING "JFFS2 flash size adjusted to %dKiB\n", c->flash_size);
         };
 
         c->wbuf_ofs = 0xFFFFFFFF;
@@ -1291,8 +1242,7 @@ int jffs2_dataflash_setup(struct jffs2_sb_info *c) {
         }
 #endif
 
-        pr_info("write-buffering enabled buffer (%d) erasesize (%d)\n",
-                c->wbuf_pagesize, c->sector_size);
+        printk(KERN_INFO "JFFS2 write-buffering enabled buffer (%d) erasesize (%d)\n", c->wbuf_pagesize, c->sector_size);
 
         return 0;
 }
@@ -1311,9 +1261,6 @@ int jffs2_nor_wbuf_flash_setup(struct jffs2_sb_info *c) {
 
         /* Initialize write buffer */
         init_rwsem(&c->wbuf_sem);
-        spin_lock_init(&c->wbuf_dwork_lock);
-        INIT_DELAYED_WORK(&c->wbuf_dwork, delayed_wbuf_sync);
-
         c->wbuf_pagesize = c->mtd->writesize;
         c->wbuf_ofs = 0xFFFFFFFF;
 
@@ -1346,8 +1293,6 @@ int jffs2_ubivol_setup(struct jffs2_sb_info *c) {
                 return 0;
 
         init_rwsem(&c->wbuf_sem);
-        spin_lock_init(&c->wbuf_dwork_lock);
-        INIT_DELAYED_WORK(&c->wbuf_dwork, delayed_wbuf_sync);
 
         c->wbuf_pagesize =  c->mtd->writesize;
         c->wbuf_ofs = 0xFFFFFFFF;
@@ -1355,8 +1300,7 @@ int jffs2_ubivol_setup(struct jffs2_sb_info *c) {
         if (!c->wbuf)
                 return -ENOMEM;
 
-        pr_info("write-buffering enabled buffer (%d) erasesize (%d)\n",
-                c->wbuf_pagesize, c->sector_size);
+        printk(KERN_INFO "JFFS2 write-buffering enabled buffer (%d) erasesize (%d)\n", c->wbuf_pagesize, c->sector_size);
 
         return 0;
 }