fs/jffs2/wbuf.c

   1 /*
   2  * JFFS2 -- Journalling Flash File System, Version 2.
   3  *
   4  * Copyright (C) 2001-2003 Red Hat, Inc.
   5  * Copyright (C) 2004 Thomas Gleixner <tglx@linutronix.de>
   6  *
   7  * Created by David Woodhouse <dwmw2@infradead.org>
   8  * Modified debugged and enhanced by Thomas Gleixner <tglx@linutronix.de>
   9  *
  10  * For licensing information, see the file 'LICENCE' in this directory.
  11  *
  12  * $Id: wbuf.c,v 1.92 2005/04/05 12:51:54 dedekind Exp $
  13  *
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/slab.h>
  18 #include <linux/mtd/mtd.h>
  19 #include <linux/crc32.h>
  20 #include <linux/mtd/nand.h>
  21 #include "nodelist.h"
  22
  23 /* For testing write failures */
  24 #undef BREAKME
  25 #undef BREAKMEHEADER
  26
  27 #ifdef BREAKME
  28 static unsigned char *brokenbuf;
  29 #endif
  30
  31 /* max. erase failures before we mark a block bad */
  32 #define MAX_ERASE_FAILURES      2
  33
  34 /* two seconds timeout for timed wbuf-flushing */
  35 #define WBUF_FLUSH_TIMEOUT      2 * HZ
  36
  37 struct jffs2_inodirty {
  38         uint32_t ino;
  39         struct jffs2_inodirty *next;
  40 };
  41
  42 static struct jffs2_inodirty inodirty_nomem;
  43
  44 static int jffs2_wbuf_pending_for_ino(struct jffs2_sb_info *c, uint32_t ino)
  45 {
  46         struct jffs2_inodirty *this = c->wbuf_inodes;
  47
  48         /* If a malloc failed, consider _everything_ dirty */
  49         if (this == &inodirty_nomem)
  50                 return 1;
  51
  52         /* If ino == 0, _any_ non-GC writes mean 'yes' */
  53         if (this && !ino)
  54                 return 1;
  55
  56         /* Look to see if the inode in question is pending in the wbuf */
  57         while (this) {
  58                 if (this->ino == ino)
  59                         return 1;
  60                 this = this->next;
  61         }
  62         return 0;
  63 }
  64
  65 static void jffs2_clear_wbuf_ino_list(struct jffs2_sb_info *c)
  66 {
  67         struct jffs2_inodirty *this;
  68
  69         this = c->wbuf_inodes;
  70
  71         if (this != &inodirty_nomem) {
  72                 while (this) {
  73                         struct jffs2_inodirty *next = this->next;
  74                         kfree(this);
  75                         this = next;
  76                 }
  77         }
  78         c->wbuf_inodes = NULL;
  79 }
  80
  81 static void jffs2_wbuf_dirties_inode(struct jffs2_sb_info *c, uint32_t ino)
  82 {
  83         struct jffs2_inodirty *new;
  84
  85         /* Mark the superblock dirty so that kupdated will flush... */
  86         jffs2_erase_pending_trigger(c);
  87
  88         if (jffs2_wbuf_pending_for_ino(c, ino))
  89                 return;
  90
  91         new = kmalloc(sizeof(*new), GFP_KERNEL);
  92         if (!new) {
  93                 D1(printk(KERN_DEBUG "No memory to allocate inodirty. Fallback to all considered dirty\n"));
  94                 jffs2_clear_wbuf_ino_list(c);
  95                 c->wbuf_inodes = &inodirty_nomem;
  96                 return;
  97         }
  98         new->ino = ino;
  99         new->next = c->wbuf_inodes;
 100         c->wbuf_inodes = new;
 101         return;
 102 }
 103
 104 static inline void jffs2_refile_wbuf_blocks(struct jffs2_sb_info *c)
 105 {
 106         struct list_head *this, *next;
 107         static int n;
 108
 109         if (list_empty(&c->erasable_pending_wbuf_list))
 110                 return;
 111
 112         list_for_each_safe(this, next, &c->erasable_pending_wbuf_list) {
 113                 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
 114
 115                 D1(printk(KERN_DEBUG "Removing eraseblock at 0x%08x from erasable_pending_wbuf_list...\n", jeb->offset));
 116                 list_del(this);
 117                 if ((jiffies + (n++)) & 127) {
 118                         /* Most of the time, we just erase it immediately. Otherwise we
 119                            spend ages scanning it on mount, etc. */
 120                         D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n"));
 121                         list_add_tail(&jeb->list, &c->erase_pending_list);
 122                         c->nr_erasing_blocks++;
 123                         jffs2_erase_pending_trigger(c);
 124                 } else {
 125                         /* Sometimes, however, we leave it elsewhere so it doesn't get
 126                            immediately reused, and we spread the load a bit. */
 127                         D1(printk(KERN_DEBUG "...and adding to erasable_list\n"));
 128                         list_add_tail(&jeb->list, &c->erasable_list);
 129                 }
 130         }
 131 }
 132
 133 #define REFILE_NOTEMPTY 0
 134 #define REFILE_ANYWAY   1
 135
 136 static void jffs2_block_refile(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int allow_empty)
 137 {
 138         D1(printk("About to refile bad block at %08x\n", jeb->offset));
 139
 140         D2(jffs2_dump_block_lists(c));
 141         /* File the existing block on the bad_used_list.... */
 142         if (c->nextblock == jeb)
 143                 c->nextblock = NULL;
 144         else /* Not sure this should ever happen... need more coffee */
 145                 list_del(&jeb->list);
 146         if (jeb->first_node) {
 147                 D1(printk("Refiling block at %08x to bad_used_list\n", jeb->offset));
 148                 list_add(&jeb->list, &c->bad_used_list);
 149         } else {
 150                 BUG_ON(allow_empty == REFILE_NOTEMPTY);
 151                 /* It has to have had some nodes or we couldn't be here */
 152                 D1(printk("Refiling block at %08x to erase_pending_list\n", jeb->offset));
 153                 list_add(&jeb->list, &c->erase_pending_list);
 154                 c->nr_erasing_blocks++;
 155                 jffs2_erase_pending_trigger(c);
 156         }
 157         D2(jffs2_dump_block_lists(c));
 158
 159         /* Adjust its size counts accordingly */
 160         c->wasted_size += jeb->free_size;
 161         c->free_size -= jeb->free_size;
 162         jeb->wasted_size += jeb->free_size;
 163         jeb->free_size = 0;
 164
 165         ACCT_SANITY_CHECK(c,jeb);
 166         D1(ACCT_PARANOIA_CHECK(jeb));
 167 }
 168
 169 /* Recover from failure to write wbuf. Recover the nodes up to the
 170  * wbuf, not the one which we were starting to try to write. */
 171
 172 static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
 173 {
 174         struct jffs2_eraseblock *jeb, *new_jeb;
 175         struct jffs2_raw_node_ref **first_raw, **raw;
 176         size_t retlen;
 177         int ret;
 178         unsigned char *buf;
 179         uint32_t start, end, ofs, len;
 180
 181         spin_lock(&c->erase_completion_lock);
 182
 183         jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
 184
 185         jffs2_block_refile(c, jeb, REFILE_NOTEMPTY);
 186
 187         /* Find the first node to be recovered, by skipping over every
 188            node which ends before the wbuf starts, or which is obsolete. */
 189         first_raw = &jeb->first_node;
 190         while (*first_raw &&
 191                (ref_obsolete(*first_raw) ||
 192                 (ref_offset(*first_raw)+ref_totlen(c, jeb, *first_raw)) < c->wbuf_ofs)) {
 193                 D1(printk(KERN_DEBUG "Skipping node at 0x%08x(%d)-0x%08x which is either before 0x%08x or obsolete\n",
 194                           ref_offset(*first_raw), ref_flags(*first_raw),
 195                           (ref_offset(*first_raw) + ref_totlen(c, jeb, *first_raw)),
 196                           c->wbuf_ofs));
 197                 first_raw = &(*first_raw)->next_phys;
 198         }
 199
 200         if (!*first_raw) {
 201                 /* All nodes were obsolete. Nothing to recover. */
 202                 D1(printk(KERN_DEBUG "No non-obsolete nodes to be recovered. Just filing block bad\n"));
 203                 spin_unlock(&c->erase_completion_lock);
 204                 return;
 205         }
 206
 207         start = ref_offset(*first_raw);
 208         end = ref_offset(*first_raw) + ref_totlen(c, jeb, *first_raw);
 209
 210         /* Find the last node to be recovered */
 211         raw = first_raw;
 212         while ((*raw)) {
 213                 if (!ref_obsolete(*raw))
 214                         end = ref_offset(*raw) + ref_totlen(c, jeb, *raw);
 215
 216                 raw = &(*raw)->next_phys;
 217         }
 218         spin_unlock(&c->erase_completion_lock);
 219
 220         D1(printk(KERN_DEBUG "wbuf recover %08x-%08x\n", start, end));
 221
 222         buf = NULL;
 223         if (start < c->wbuf_ofs) {
 224                 /* First affected node was already partially written.
 225                  * Attempt to reread the old data into our buffer. */
 226
 227                 buf = kmalloc(end - start, GFP_KERNEL);
 228                 if (!buf) {
 229                         printk(KERN_CRIT "Malloc failure in wbuf recovery. Data loss ensues.\n");
 230
 231                         goto read_failed;
 232                 }
 233
 234                 /* Do the read... */
 235                 if (jffs2_cleanmarker_oob(c))
 236                         ret = c->mtd->read_ecc(c->mtd, start, c->wbuf_ofs - start, &retlen, buf, NULL, c->oobinfo);
 237                 else
 238                         ret = c->mtd->read(c->mtd, start, c->wbuf_ofs - start, &retlen, buf);
 239
 240                 if (ret == -EBADMSG && retlen == c->wbuf_ofs - start) {
 241                         /* ECC recovered */
 242                         ret = 0;
 243                 }
 244                 if (ret || retlen != c->wbuf_ofs - start) {
 245                         printk(KERN_CRIT "Old data are already lost in wbuf recovery. Data loss ensues.\n");
 246
 247                         kfree(buf);
 248                         buf = NULL;
 249                 read_failed:
 250                         first_raw = &(*first_raw)->next_phys;
 251                         /* If this was the only node to be recovered, give up */
 252                         if (!(*first_raw))
 253                                 return;
 254
 255                         /* It wasn't. Go on and try to recover nodes complete in the wbuf */
 256                         start = ref_offset(*first_raw);
 257                 } else {
 258                         /* Read succeeded. Copy the remaining data from the wbuf */
 259                         memcpy(buf + (c->wbuf_ofs - start), c->wbuf, end - c->wbuf_ofs);
 260                 }
 261         }
 262         /* OK... we're to rewrite (end-start) bytes of data from first_raw onwards.
 263            Either 'buf' contains the data, or we find it in the wbuf */
 264
 265
 266         /* ... and get an allocation of space from a shiny new block instead */
 267         ret = jffs2_reserve_space_gc(c, end-start, &ofs, &len);
 268         if (ret) {
 269                 printk(KERN_WARNING "Failed to allocate space for wbuf recovery. Data loss ensues.\n");
 270                 kfree(buf);
 271                 return;
 272         }
 273         if (end-start >= c->wbuf_pagesize) {
 274                 /* Need to do another write immediately, but it's possible
 275                    that this is just because the wbuf itself is completely
 276                    full, and there's nothing earlier read back from the
 277                    flash. Hence 'buf' isn't necessarily what we're writing
 278                    from. */
 279                 unsigned char *rewrite_buf = buf?:c->wbuf;
 280                 uint32_t towrite = (end-start) - ((end-start)%c->wbuf_pagesize);
 281
 282                 D1(printk(KERN_DEBUG "Write 0x%x bytes at 0x%08x in wbuf recover\n",
 283                           towrite, ofs));
 284
 285 #ifdef BREAKMEHEADER
 286                 static int breakme;
 287                 if (breakme++ == 20) {
 288                         printk(KERN_NOTICE "Faking write error at 0x%08x\n", ofs);
 289                         breakme = 0;
 290                         c->mtd->write_ecc(c->mtd, ofs, towrite, &retlen,
 291                                           brokenbuf, NULL, c->oobinfo);
 292                         ret = -EIO;
 293                 } else
 294 #endif
 295                 if (jffs2_cleanmarker_oob(c))
 296                         ret = c->mtd->write_ecc(c->mtd, ofs, towrite, &retlen,
 297                                                 rewrite_buf, NULL, c->oobinfo);
 298                 else
 299                         ret = c->mtd->write(c->mtd, ofs, towrite, &retlen, rewrite_buf);
 300
 301                 if (ret || retlen != towrite) {
 302                         /* Argh. We tried. Really we did. */
 303                         printk(KERN_CRIT "Recovery of wbuf failed due to a second write error\n");
 304                         kfree(buf);
 305
 306                         if (retlen) {
 307                                 struct jffs2_raw_node_ref *raw2;
 308
 309                                 raw2 = jffs2_alloc_raw_node_ref();
 310                                 if (!raw2)
 311                                         return;
 312
 313                                 raw2->flash_offset = ofs | REF_OBSOLETE;
 314                                 raw2->__totlen = ref_totlen(c, jeb, *first_raw);
 315                                 raw2->next_phys = NULL;
 316                                 raw2->next_in_ino = NULL;
 317
 318                                 jffs2_add_physical_node_ref(c, raw2);
 319                         }
 320                         return;
 321                 }
 322                 printk(KERN_NOTICE "Recovery of wbuf succeeded to %08x\n", ofs);
 323
 324                 c->wbuf_len = (end - start) - towrite;
 325                 c->wbuf_ofs = ofs + towrite;
 326                 memmove(c->wbuf, rewrite_buf + towrite, c->wbuf_len);
 327                 /* Don't muck about with c->wbuf_inodes. False positives are harmless. */
 328                 if (buf)
 329                         kfree(buf);
 330         } else {
 331                 /* OK, now we're left with the dregs in whichever buffer we're using */
 332                 if (buf) {
 333                         memcpy(c->wbuf, buf, end-start);
 334                         kfree(buf);
 335                 } else {
 336                         memmove(c->wbuf, c->wbuf + (start - c->wbuf_ofs), end - start);
 337                 }
 338                 c->wbuf_ofs = ofs;
 339                 c->wbuf_len = end - start;
 340         }
 341
 342         /* Now sort out the jffs2_raw_node_refs, moving them from the old to the next block */
 343         new_jeb = &c->blocks[ofs / c->sector_size];
 344
 345         spin_lock(&c->erase_completion_lock);
 346         if (new_jeb->first_node) {
 347                 /* Odd, but possible with ST flash later maybe */
 348                 new_jeb->last_node->next_phys = *first_raw;
 349         } else {
 350                 new_jeb->first_node = *first_raw;
 351         }
 352
 353         raw = first_raw;
 354         while (*raw) {
 355                 uint32_t rawlen = ref_totlen(c, jeb, *raw);
 356
 357                 D1(printk(KERN_DEBUG "Refiling block of %08x at %08x(%d) to %08x\n",
 358                           rawlen, ref_offset(*raw), ref_flags(*raw), ofs));
 359
 360                 if (ref_obsolete(*raw)) {
 361                         /* Shouldn't really happen much */
 362                         new_jeb->dirty_size += rawlen;
 363                         new_jeb->free_size -= rawlen;
 364                         c->dirty_size += rawlen;
 365                 } else {
 366                         new_jeb->used_size += rawlen;
 367                         new_jeb->free_size -= rawlen;
 368                         jeb->dirty_size += rawlen;
 369                         jeb->used_size  -= rawlen;
 370                         c->dirty_size += rawlen;
 371                 }
 372                 c->free_size -= rawlen;
 373                 (*raw)->flash_offset = ofs | ref_flags(*raw);
 374                 ofs += rawlen;
 375                 new_jeb->last_node = *raw;
 376
 377                 raw = &(*raw)->next_phys;
 378         }
 379
 380         /* Fix up the original jeb now it's on the bad_list */
 381         *first_raw = NULL;
 382         if (first_raw == &jeb->first_node) {
 383                 jeb->last_node = NULL;
 384                 D1(printk(KERN_DEBUG "Failing block at %08x is now empty. Moving to erase_pending_list\n", jeb->offset));
 385                 list_del(&jeb->list);
 386                 list_add(&jeb->list, &c->erase_pending_list);
 387                 c->nr_erasing_blocks++;
 388                 jffs2_erase_pending_trigger(c);
 389         }
 390         else
 391                 jeb->last_node = container_of(first_raw, struct jffs2_raw_node_ref, next_phys);
 392
 393         ACCT_SANITY_CHECK(c,jeb);
 394         D1(ACCT_PARANOIA_CHECK(jeb));
 395
 396         ACCT_SANITY_CHECK(c,new_jeb);
 397         D1(ACCT_PARANOIA_CHECK(new_jeb));
 398
 399         spin_unlock(&c->erase_completion_lock);
 400
 401         D1(printk(KERN_DEBUG "wbuf recovery completed OK\n"));
 402 }
 403
 404 /* Meaning of pad argument:
 405    0: Do not pad. Probably pointless - we only ever use this when we can't pad anyway.
 406    1: Pad, do not adjust nextblock free_size
 407    2: Pad, adjust nextblock free_size
 408 */
 409 #define NOPAD           0
 410 #define PAD_NOACCOUNT   1
 411 #define PAD_ACCOUNTING  2
 412
 413 static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
 414 {
 415         int ret;
 416         size_t retlen;
 417
 418         /* Nothing to do if not write-buffering the flash. In particular, we shouldn't
 419            del_timer() the timer we never initialised. */
 420         if (!jffs2_is_writebuffered(c))
 421                 return 0;
 422
 423         if (!down_trylock(&c->alloc_sem)) {
 424                 up(&c->alloc_sem);
 425                 printk(KERN_CRIT "jffs2_flush_wbuf() called with alloc_sem not locked!\n");
 426                 BUG();
 427         }
 428
 429         if (!c->wbuf_len)       /* already checked c->wbuf above */
 430                 return 0;
 431
 432         /* claim remaining space on the page
 433            this happens, if we have a change to a new block,
 434            or if fsync forces us to flush the writebuffer.
 435            if we have a switch to next page, we will not have
 436            enough remaining space for this.
 437         */
 438         if (pad && !jffs2_dataflash(c)) {
 439                 c->wbuf_len = PAD(c->wbuf_len);
 440
 441                 /* Pad with JFFS2_DIRTY_BITMASK initially.  this helps out ECC'd NOR
 442                    with 8 byte page size */
 443                 memset(c->wbuf + c->wbuf_len, 0, c->wbuf_pagesize - c->wbuf_len);
 444
 445                 if ( c->wbuf_len + sizeof(struct jffs2_unknown_node) < c->wbuf_pagesize) {
 446                         struct jffs2_unknown_node *padnode = (void *)(c->wbuf + c->wbuf_len);
 447                         padnode->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
 448                         padnode->nodetype = cpu_to_je16(JFFS2_NODETYPE_PADDING);
 449                         padnode->totlen = cpu_to_je32(c->wbuf_pagesize - c->wbuf_len);
 450                         padnode->hdr_crc = cpu_to_je32(crc32(0, padnode, sizeof(*padnode)-4));
 451                 }
 452         }
 453         /* else jffs2_flash_writev has actually filled in the rest of the
 454            buffer for us, and will deal with the node refs etc. later. */
 455
 456 #ifdef BREAKME
 457         static int breakme;
 458         if (breakme++ == 20) {
 459                 printk(KERN_NOTICE "Faking write error at 0x%08x\n", c->wbuf_ofs);
 460                 breakme = 0;
 461                 c->mtd->write_ecc(c->mtd, c->wbuf_ofs, c->wbuf_pagesize,
 462                                         &retlen, brokenbuf, NULL, c->oobinfo);
 463                 ret = -EIO;
 464         } else
 465 #endif
 466
 467         if (jffs2_cleanmarker_oob(c))
 468                 ret = c->mtd->write_ecc(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf, NULL, c->oobinfo);
 469         else
 470                 ret = c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf);
 471
 472         if (ret || retlen != c->wbuf_pagesize) {
 473                 if (ret)
 474                         printk(KERN_WARNING "jffs2_flush_wbuf(): Write failed with %d\n",ret);
 475                 else {
 476                         printk(KERN_WARNING "jffs2_flush_wbuf(): Write was short: %zd instead of %d\n",
 477                                 retlen, c->wbuf_pagesize);
 478                         ret = -EIO;
 479                 }
 480
 481                 jffs2_wbuf_recover(c);
 482
 483                 return ret;
 484         }
 485
 486         spin_lock(&c->erase_completion_lock);
 487
 488         /* Adjust free size of the block if we padded. */
 489         if (pad && !jffs2_dataflash(c)) {
 490                 struct jffs2_eraseblock *jeb;
 491
 492                 jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
 493
 494                 D1(printk(KERN_DEBUG "jffs2_flush_wbuf() adjusting free_size of %sblock at %08x\n",
 495                           (jeb==c->nextblock)?"next":"", jeb->offset));
 496
 497                 /* wbuf_pagesize - wbuf_len is the amount of space that's to be
 498                    padded. If there is less free space in the block than that,
 499                    something screwed up */
 500                 if (jeb->free_size < (c->wbuf_pagesize - c->wbuf_len)) {
 501                         printk(KERN_CRIT "jffs2_flush_wbuf(): Accounting error. wbuf at 0x%08x has 0x%03x bytes, 0x%03x left.\n",
 502                                c->wbuf_ofs, c->wbuf_len, c->wbuf_pagesize-c->wbuf_len);
 503                         printk(KERN_CRIT "jffs2_flush_wbuf(): But free_size for block at 0x%08x is only 0x%08x\n",
 504                                jeb->offset, jeb->free_size);
 505                         BUG();
 506                 }
 507                 jeb->free_size -= (c->wbuf_pagesize - c->wbuf_len);
 508                 c->free_size -= (c->wbuf_pagesize - c->wbuf_len);
 509                 jeb->wasted_size += (c->wbuf_pagesize - c->wbuf_len);
 510                 c->wasted_size += (c->wbuf_pagesize - c->wbuf_len);
 511         }
 512
 513         /* Stick any now-obsoleted blocks on the erase_pending_list */
 514         jffs2_refile_wbuf_blocks(c);
 515         jffs2_clear_wbuf_ino_list(c);
 516         spin_unlock(&c->erase_completion_lock);
 517
 518         memset(c->wbuf,0xff,c->wbuf_pagesize);
 519         /* adjust write buffer offset, else we get a non contiguous write bug */
 520         c->wbuf_ofs += c->wbuf_pagesize;
 521         c->wbuf_len = 0;
 522         return 0;
 523 }
 524
 525 /* Trigger garbage collection to flush the write-buffer.
 526    If ino arg is zero, do it if _any_ real (i.e. not GC) writes are
 527    outstanding. If ino arg non-zero, do it only if a write for the
 528    given inode is outstanding. */
 529 int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino)
 530 {
 531         uint32_t old_wbuf_ofs;
 532         uint32_t old_wbuf_len;
 533         int ret = 0;
 534
 535         D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() called for ino #%u...\n", ino));
 536
 537         if (!c->wbuf)
 538                 return 0;
 539
 540         down(&c->alloc_sem);
 541         if (!jffs2_wbuf_pending_for_ino(c, ino)) {
 542                 D1(printk(KERN_DEBUG "Ino #%d not pending in wbuf. Returning\n", ino));
 543                 up(&c->alloc_sem);
 544                 return 0;
 545         }
 546
 547         old_wbuf_ofs = c->wbuf_ofs;
 548         old_wbuf_len = c->wbuf_len;
 549
 550         if (c->unchecked_size) {
 551                 /* GC won't make any progress for a while */
 552                 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() padding. Not finished checking\n"));
 553                 down_write(&c->wbuf_sem);
 554                 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
 555                 /* retry flushing wbuf in case jffs2_wbuf_recover
 556                    left some data in the wbuf */
 557                 if (ret)
 558                         ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
 559                 up_write(&c->wbuf_sem);
 560         } else while (old_wbuf_len &&
 561                       old_wbuf_ofs == c->wbuf_ofs) {
 562
 563                 up(&c->alloc_sem);
 564
 565                 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() calls gc pass\n"));
 566
 567                 ret = jffs2_garbage_collect_pass(c);
 568                 if (ret) {
 569                         /* GC failed. Flush it with padding instead */
 570                         down(&c->alloc_sem);
 571                         down_write(&c->wbuf_sem);
 572                         ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
 573                         /* retry flushing wbuf in case jffs2_wbuf_recover
 574                            left some data in the wbuf */
 575                         if (ret)
 576                                 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
 577                         up_write(&c->wbuf_sem);
 578                         break;
 579                 }
 580                 down(&c->alloc_sem);
 581         }
 582
 583         D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() ends...\n"));
 584
 585         up(&c->alloc_sem);
 586         return ret;
 587 }
 588
 589 /* Pad write-buffer to end and write it, wasting space. */
 590 int jffs2_flush_wbuf_pad(struct jffs2_sb_info *c)
 591 {
 592         int ret;
 593
 594         if (!c->wbuf)
 595                 return 0;
 596
 597         down_write(&c->wbuf_sem);
 598         ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
 599         /* retry - maybe wbuf recover left some data in wbuf. */
 600         if (ret)
 601                 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
 602         up_write(&c->wbuf_sem);
 603
 604         return ret;
 605 }
 606
 607 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
 608 #define PAGE_DIV(x) ( ((unsigned long)(x) / (unsigned long)(c->wbuf_pagesize)) * (unsigned long)(c->wbuf_pagesize) )
 609 #define PAGE_MOD(x) ( (unsigned long)(x) % (unsigned long)(c->wbuf_pagesize) )
 610 #else
 611 #define PAGE_DIV(x) ( (x) & (~(c->wbuf_pagesize - 1)) )
 612 #define PAGE_MOD(x) ( (x) & (c->wbuf_pagesize - 1) )
 613 #endif
 614
 615 int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs, unsigned long count, loff_t to, size_t *retlen, uint32_t ino)
 616 {
 617         struct kvec outvecs[3];
 618         uint32_t totlen = 0;
 619         uint32_t split_ofs = 0;
 620         uint32_t old_totlen;
 621         int ret, splitvec = -1;
 622         int invec, outvec;
 623         size_t wbuf_retlen;
 624         unsigned char *wbuf_ptr;
 625         size_t donelen = 0;
 626         uint32_t outvec_to = to;
 627
 628         /* If not NAND flash, don't bother */
 629         if (!jffs2_is_writebuffered(c))
 630                 return jffs2_flash_direct_writev(c, invecs, count, to, retlen);
 631
 632         down_write(&c->wbuf_sem);
 633
 634         /* If wbuf_ofs is not initialized, set it to target address */
 635         if (c->wbuf_ofs == 0xFFFFFFFF) {
 636                 c->wbuf_ofs = PAGE_DIV(to);
 637                 c->wbuf_len = PAGE_MOD(to);
 638                 memset(c->wbuf,0xff,c->wbuf_pagesize);
 639         }
 640
 641         /* Fixup the wbuf if we are moving to a new eraseblock.  The checks below
 642            fail for ECC'd NOR because cleanmarker == 16, so a block starts at
 643            xxx0010.  */
 644         if (jffs2_nor_ecc(c)) {
 645                 if (((c->wbuf_ofs % c->sector_size) == 0) && !c->wbuf_len) {
 646                         c->wbuf_ofs = PAGE_DIV(to);
 647                         c->wbuf_len = PAGE_MOD(to);
 648                         memset(c->wbuf,0xff,c->wbuf_pagesize);
 649                 }
 650         }
 651
 652         /* Sanity checks on target address.
 653            It's permitted to write at PAD(c->wbuf_len+c->wbuf_ofs),
 654            and it's permitted to write at the beginning of a new
 655            erase block. Anything else, and you die.
 656            New block starts at xxx000c (0-b = block header)
 657         */
 658         if (SECTOR_ADDR(to) != SECTOR_ADDR(c->wbuf_ofs)) {
 659                 /* It's a write to a new block */
 660                 if (c->wbuf_len) {
 661                         D1(printk(KERN_DEBUG "jffs2_flash_writev() to 0x%lx causes flush of wbuf at 0x%08x\n", (unsigned long)to, c->wbuf_ofs));
 662                         ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
 663                         if (ret) {
 664                                 /* the underlying layer has to check wbuf_len to do the cleanup */
 665                                 D1(printk(KERN_WARNING "jffs2_flush_wbuf() called from jffs2_flash_writev() failed %d\n", ret));
 666                                 *retlen = 0;
 667                                 goto exit;
 668                         }
 669                 }
 670                 /* set pointer to new block */
 671                 c->wbuf_ofs = PAGE_DIV(to);
 672                 c->wbuf_len = PAGE_MOD(to);
 673         }
 674
 675         if (to != PAD(c->wbuf_ofs + c->wbuf_len)) {
 676                 /* We're not writing immediately after the writebuffer. Bad. */
 677                 printk(KERN_CRIT "jffs2_flash_writev(): Non-contiguous write to %08lx\n", (unsigned long)to);
 678                 if (c->wbuf_len)
 679                         printk(KERN_CRIT "wbuf was previously %08x-%08x\n",
 680                                           c->wbuf_ofs, c->wbuf_ofs+c->wbuf_len);
 681                 BUG();
 682         }
 683
 684         /* Note outvecs[3] above. We know count is never greater than 2 */
 685         if (count > 2) {
 686                 printk(KERN_CRIT "jffs2_flash_writev(): count is %ld\n", count);
 687                 BUG();
 688         }
 689
 690         invec = 0;
 691         outvec = 0;
 692
 693         /* Fill writebuffer first, if already in use */
 694         if (c->wbuf_len) {
 695                 uint32_t invec_ofs = 0;
 696
 697                 /* adjust alignment offset */
 698                 if (c->wbuf_len != PAGE_MOD(to)) {
 699                         c->wbuf_len = PAGE_MOD(to);
 700                         /* take care of alignment to next page */
 701                         if (!c->wbuf_len)
 702                                 c->wbuf_len = c->wbuf_pagesize;
 703                 }
 704
 705                 while(c->wbuf_len < c->wbuf_pagesize) {
 706                         uint32_t thislen;
 707
 708                         if (invec == count)
 709                                 goto alldone;
 710
 711                         thislen = c->wbuf_pagesize - c->wbuf_len;
 712
 713                         if (thislen >= invecs[invec].iov_len)
 714                                 thislen = invecs[invec].iov_len;
 715
 716                         invec_ofs = thislen;
 717
 718                         memcpy(c->wbuf + c->wbuf_len, invecs[invec].iov_base, thislen);
 719                         c->wbuf_len += thislen;
 720                         donelen += thislen;
 721                         /* Get next invec, if actual did not fill the buffer */
 722                         if (c->wbuf_len < c->wbuf_pagesize)
 723                                 invec++;
 724                 }
 725
 726                 /* write buffer is full, flush buffer */
 727                 ret = __jffs2_flush_wbuf(c, NOPAD);
 728                 if (ret) {
 729                         /* the underlying layer has to check wbuf_len to do the cleanup */
 730                         D1(printk(KERN_WARNING "jffs2_flush_wbuf() called from jffs2_flash_writev() failed %d\n", ret));
 731                         /* Retlen zero to make sure our caller doesn't mark the space dirty.
 732                            We've already done everything that's necessary */
 733                         *retlen = 0;
 734                         goto exit;
 735                 }
 736                 outvec_to += donelen;
 737                 c->wbuf_ofs = outvec_to;
 738
 739                 /* All invecs done ? */
 740                 if (invec == count)
 741                         goto alldone;
 742
 743                 /* Set up the first outvec, containing the remainder of the
 744                    invec we partially used */
 745                 if (invecs[invec].iov_len > invec_ofs) {
 746                         outvecs[0].iov_base = invecs[invec].iov_base+invec_ofs;
 747                         totlen = outvecs[0].iov_len = invecs[invec].iov_len-invec_ofs;
 748                         if (totlen > c->wbuf_pagesize) {
 749                                 splitvec = outvec;
 750                                 split_ofs = outvecs[0].iov_len - PAGE_MOD(totlen);
 751                         }
 752                         outvec++;
 753                 }
 754                 invec++;
 755         }
 756
 757         /* OK, now we've flushed the wbuf and the start of the bits
 758            we have been asked to write, now to write the rest.... */
 759
 760         /* totlen holds the amount of data still to be written */
 761         old_totlen = totlen;
 762         for ( ; invec < count; invec++,outvec++ ) {
 763                 outvecs[outvec].iov_base = invecs[invec].iov_base;
 764                 totlen += outvecs[outvec].iov_len = invecs[invec].iov_len;
 765                 if (PAGE_DIV(totlen) != PAGE_DIV(old_totlen)) {
 766                         splitvec = outvec;
 767                         split_ofs = outvecs[outvec].iov_len - PAGE_MOD(totlen);
 768                         old_totlen = totlen;
 769                 }
 770         }
 771
 772         /* Now the outvecs array holds all the remaining data to write */
 773         /* Up to splitvec,split_ofs is to be written immediately. The rest
 774            goes into the (now-empty) wbuf */
 775
 776         if (splitvec != -1) {
 777                 uint32_t remainder;
 778
 779                 remainder = outvecs[splitvec].iov_len - split_ofs;
 780                 outvecs[splitvec].iov_len = split_ofs;
 781
 782                 /* We did cross a page boundary, so we write some now */
 783                 if (jffs2_cleanmarker_oob(c))
 784                         ret = c->mtd->writev_ecc(c->mtd, outvecs, splitvec+1, outvec_to, &wbuf_retlen, NULL, c->oobinfo);
 785                 else
 786                         ret = jffs2_flash_direct_writev(c, outvecs, splitvec+1, outvec_to, &wbuf_retlen);
 787
 788                 if (ret < 0 || wbuf_retlen != PAGE_DIV(totlen)) {
 789                         /* At this point we have no problem,
 790                            c->wbuf is empty. However refile nextblock to avoid
 791                            writing again to same address.
 792                         */
 793                         struct jffs2_eraseblock *jeb;
 794
 795                         spin_lock(&c->erase_completion_lock);
 796
 797                         jeb = &c->blocks[outvec_to / c->sector_size];
 798                         jffs2_block_refile(c, jeb, REFILE_ANYWAY);
 799
 800                         *retlen = 0;
 801                         spin_unlock(&c->erase_completion_lock);
 802                         goto exit;
 803                 }
 804
 805                 donelen += wbuf_retlen;
 806                 c->wbuf_ofs = PAGE_DIV(outvec_to) + PAGE_DIV(totlen);
 807
 808                 if (remainder) {
 809                         outvecs[splitvec].iov_base += split_ofs;
 810                         outvecs[splitvec].iov_len = remainder;
 811                 } else {
 812                         splitvec++;
 813                 }
 814
 815         } else {
 816                 splitvec = 0;
 817         }
 818
 819         /* Now splitvec points to the start of the bits we have to copy
 820            into the wbuf */
 821         wbuf_ptr = c->wbuf;
 822
 823         for ( ; splitvec < outvec; splitvec++) {
 824                 /* Don't copy the wbuf into itself */
 825                 if (outvecs[splitvec].iov_base == c->wbuf)
 826                         continue;
 827                 memcpy(wbuf_ptr, outvecs[splitvec].iov_base, outvecs[splitvec].iov_len);
 828                 wbuf_ptr += outvecs[splitvec].iov_len;
 829                 donelen += outvecs[splitvec].iov_len;
 830         }
 831         c->wbuf_len = wbuf_ptr - c->wbuf;
 832
 833         /* If there's a remainder in the wbuf and it's a non-GC write,
 834            remember that the wbuf affects this ino */
 835 alldone:
 836         *retlen = donelen;
 837
 838         if (c->wbuf_len && ino)
 839                 jffs2_wbuf_dirties_inode(c, ino);
 840
 841         ret = 0;
 842
 843 exit:
 844         up_write(&c->wbuf_sem);
 845         return ret;
 846 }
 847
 848 /*
 849  *      This is the entry for flash write.
 850  *      Check, if we work on NAND FLASH, if so build an kvec and write it via vritev
 851 */
 852 int jffs2_flash_write(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, const u_char *buf)
 853 {
 854         struct kvec vecs[1];
 855
 856         if (!jffs2_is_writebuffered(c))
 857                 return c->mtd->write(c->mtd, ofs, len, retlen, buf);
 858
 859         vecs[0].iov_base = (unsigned char *) buf;
 860         vecs[0].iov_len = len;
 861         return jffs2_flash_writev(c, vecs, 1, ofs, retlen, 0);
 862 }
 863
 864 /*
 865         Handle readback from writebuffer and ECC failure return
 866 */
 867 int jffs2_flash_read(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, u_char *buf)
 868 {
 869         loff_t  orbf = 0, owbf = 0, lwbf = 0;
 870         int     ret;
 871
 872         if (!jffs2_is_writebuffered(c))
 873                 return c->mtd->read(c->mtd, ofs, len, retlen, buf);
 874
 875         /* Read flash */
 876         down_read(&c->wbuf_sem);
 877         if (jffs2_cleanmarker_oob(c))
 878                 ret = c->mtd->read_ecc(c->mtd, ofs, len, retlen, buf, NULL, c->oobinfo);
 879         else
 880                 ret = c->mtd->read(c->mtd, ofs, len, retlen, buf);
 881
 882         if ( (ret == -EBADMSG) && (*retlen == len) ) {
 883                 printk(KERN_WARNING "mtd->read(0x%zx bytes from 0x%llx) returned ECC error\n",
 884                        len, ofs);
 885                 /*
 886                  * We have the raw data without ECC correction in the buffer, maybe
 887                  * we are lucky and all data or parts are correct. We check the node.
 888                  * If data are corrupted node check will sort it out.
 889                  * We keep this block, it will fail on write or erase and the we
 890                  * mark it bad. Or should we do that now? But we should give him a chance.
 891                  * Maybe we had a system crash or power loss before the ecc write or
 892                  * a erase was completed.
 893                  * So we return success. :)
 894                  */
 895                 ret = 0;
 896         }
 897
 898         /* if no writebuffer available or write buffer empty, return */
 899         if (!c->wbuf_pagesize || !c->wbuf_len)
 900                 goto exit;
 901
 902         /* if we read in a different block, return */
 903         if (SECTOR_ADDR(ofs) != SECTOR_ADDR(c->wbuf_ofs))
 904                 goto exit;
 905
 906         if (ofs >= c->wbuf_ofs) {
 907                 owbf = (ofs - c->wbuf_ofs);     /* offset in write buffer */
 908                 if (owbf > c->wbuf_len)         /* is read beyond write buffer ? */
 909                         goto exit;
 910                 lwbf = c->wbuf_len - owbf;      /* number of bytes to copy */
 911                 if (lwbf > len)
 912                         lwbf = len;
 913         } else {
 914                 orbf = (c->wbuf_ofs - ofs);     /* offset in read buffer */
 915                 if (orbf > len)                 /* is write beyond write buffer ? */
 916                         goto exit;
 917                 lwbf = len - orbf;              /* number of bytes to copy */
 918                 if (lwbf > c->wbuf_len)
 919                         lwbf = c->wbuf_len;
 920         }
 921         if (lwbf > 0)
 922                 memcpy(buf+orbf,c->wbuf+owbf,lwbf);
 923
 924 exit:
 925         up_read(&c->wbuf_sem);
 926         return ret;
 927 }
 928
 929 /*
 930  *      Check, if the out of band area is empty
 931  */
 932 int jffs2_check_oob_empty( struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int mode)
 933 {
 934         unsigned char *buf;
 935         int     ret = 0;
 936         int     i,len,page;
 937         size_t  retlen;
 938         int     oob_size;
 939
 940         /* allocate a buffer for all oob data in this sector */
 941         oob_size = c->mtd->oobsize;
 942         len = 4 * oob_size;
 943         buf = kmalloc(len, GFP_KERNEL);
 944         if (!buf) {
 945                 printk(KERN_NOTICE "jffs2_check_oob_empty(): allocation of temporary data buffer for oob check failed\n");
 946                 return -ENOMEM;
 947         }
 948         /*
 949          * if mode = 0, we scan for a total empty oob area, else we have
 950          * to take care of the cleanmarker in the first page of the block
 951         */
 952         ret = jffs2_flash_read_oob(c, jeb->offset, len , &retlen, buf);
 953         if (ret) {
 954                 D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB failed %d for block at %08x\n", ret, jeb->offset));
 955                 goto out;
 956         }
 957
 958         if (retlen < len) {
 959                 D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB return short read "
 960                           "(%zd bytes not %d) for block at %08x\n", retlen, len, jeb->offset));
 961                 ret = -EIO;
 962                 goto out;
 963         }
 964
 965         /* Special check for first page */
 966         for(i = 0; i < oob_size ; i++) {
 967                 /* Yeah, we know about the cleanmarker. */
 968                 if (mode && i >= c->fsdata_pos &&
 969                     i < c->fsdata_pos + c->fsdata_len)
 970                         continue;
 971
 972                 if (buf[i] != 0xFF) {
 973                         D2(printk(KERN_DEBUG "Found %02x at %x in OOB for %08x\n",
 974                                   buf[page+i], page+i, jeb->offset));
 975                         ret = 1;
 976                         goto out;
 977                 }
 978         }
 979
 980         /* we know, we are aligned :) */
 981         for (page = oob_size; page < len; page += sizeof(long)) {
 982                 unsigned long dat = *(unsigned long *)(&buf[page]);
 983                 if(dat != -1) {
 984                         ret = 1;
 985                         goto out;
 986                 }
 987         }
 988
 989 out:
 990         kfree(buf);
 991
 992         return ret;
 993 }
 994
 995 /*
 996 *       Scan for a valid cleanmarker and for bad blocks
 997 *       For virtual blocks (concatenated physical blocks) check the cleanmarker
 998 *       only in the first page of the first physical block, but scan for bad blocks in all
 999 *       physical blocks
1000 */
1001 int jffs2_check_nand_cleanmarker (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
1002 {
1003         struct jffs2_unknown_node n;
1004         unsigned char buf[2 * NAND_MAX_OOBSIZE];
1005         unsigned char *p;
1006         int ret, i, cnt, retval = 0;
1007         size_t retlen, offset;
1008         int oob_size;
1009
1010         offset = jeb->offset;
1011         oob_size = c->mtd->oobsize;
1012
1013         /* Loop through the physical blocks */
1014         for (cnt = 0; cnt < (c->sector_size / c->mtd->erasesize); cnt++) {
1015                 /* Check first if the block is bad. */
1016                 if (c->mtd->block_isbad (c->mtd, offset)) {
1017                         D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Bad block at %08x\n", jeb->offset));
1018                         return 2;
1019                 }
1020                 /*
1021                    *    We read oob data from page 0 and 1 of the block.
1022                    *    page 0 contains cleanmarker and badblock info
1023                    *    page 1 contains failure count of this block
1024                  */
1025                 ret = c->mtd->read_oob (c->mtd, offset, oob_size << 1, &retlen, buf);
1026
1027                 if (ret) {
1028                         D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Read OOB failed %d for block at %08x\n", ret, jeb->offset));
1029                         return ret;
1030                 }
1031                 if (retlen < (oob_size << 1)) {
1032                         D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Read OOB return short read (%zd bytes not %d) for block at %08x\n", retlen, oob_size << 1, jeb->offset));
1033                         return -EIO;
1034                 }
1035
1036                 /* Check cleanmarker only on the first physical block */
1037                 if (!cnt) {
1038                         n.magic = cpu_to_je16 (JFFS2_MAGIC_BITMASK);
1039                         n.nodetype = cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER);
1040                         n.totlen = cpu_to_je32 (8);
1041                         p = (unsigned char *) &n;
1042
1043                         for (i = 0; i < c->fsdata_len; i++) {
1044                                 if (buf[c->fsdata_pos + i] != p[i]) {
1045                                         retval = 1;
1046                                 }
1047                         }
1048                         D1(if (retval == 1) {
1049                                 printk(KERN_WARNING "jffs2_check_nand_cleanmarker(): Cleanmarker node not detected in block at %08x\n", jeb->offset);
1050                                 printk(KERN_WARNING "OOB at %08x was ", offset);
1051                                 for (i=0; i < oob_size; i++) {
1052                                         printk("%02x ", buf[i]);
1053                                 }
1054                                 printk("\n");
1055                         })
1056                 }
1057                 offset += c->mtd->erasesize;
1058         }
1059         return retval;
1060 }
1061
1062 int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
1063 {
1064         struct  jffs2_unknown_node n;
1065         int     ret;
1066         size_t  retlen;
1067
1068         n.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
1069         n.nodetype = cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER);
1070         n.totlen = cpu_to_je32(8);
1071
1072         ret = jffs2_flash_write_oob(c, jeb->offset + c->fsdata_pos, c->fsdata_len, &retlen, (unsigned char *)&n);
1073
1074         if (ret) {
1075                 D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
1076                 return ret;
1077         }
1078         if (retlen != c->fsdata_len) {
1079                 D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): Short write for block at %08x: %zd not %d\n", jeb->offset, retlen, c->fsdata_len));
1080                 return ret;
1081         }
1082         return 0;
1083 }
1084
1085 /*
1086  * On NAND we try to mark this block bad. If the block was erased more
1087  * than MAX_ERASE_FAILURES we mark it finaly bad.
1088  * Don't care about failures. This block remains on the erase-pending
1089  * or badblock list as long as nobody manipulates the flash with
1090  * a bootloader or something like that.
1091  */
1092
1093 int jffs2_write_nand_badblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t bad_offset)
1094 {
1095         int     ret;
1096
1097         /* if the count is < max, we try to write the counter to the 2nd page oob area */
1098         if( ++jeb->bad_count < MAX_ERASE_FAILURES)
1099                 return 0;
1100
1101         if (!c->mtd->block_markbad)
1102                 return 1; // What else can we do?
1103
1104         D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Marking bad block at %08x\n", bad_offset));
1105         ret = c->mtd->block_markbad(c->mtd, bad_offset);
1106
1107         if (ret) {
1108                 D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
1109                 return ret;
1110         }
1111         return 1;
1112 }
1113
1114 #define NAND_JFFS2_OOB16_FSDALEN        8
1115
1116 static struct nand_oobinfo jffs2_oobinfo_docecc = {
1117         .useecc = MTD_NANDECC_PLACE,
1118         .eccbytes = 6,
1119         .eccpos = {0,1,2,3,4,5}
1120 };
1121
1122
1123 static int jffs2_nand_set_oobinfo(struct jffs2_sb_info *c)
1124 {
1125         struct nand_oobinfo *oinfo = &c->mtd->oobinfo;
1126
1127         /* Do this only, if we have an oob buffer */
1128         if (!c->mtd->oobsize)
1129                 return 0;
1130
1131         /* Cleanmarker is out-of-band, so inline size zero */
1132         c->cleanmarker_size = 0;
1133
1134         /* Should we use autoplacement ? */
1135         if (oinfo && oinfo->useecc == MTD_NANDECC_AUTOPLACE) {
1136                 D1(printk(KERN_DEBUG "JFFS2 using autoplace on NAND\n"));
1137                 /* Get the position of the free bytes */
1138                 if (!oinfo->oobfree[0][1]) {
1139                         printk (KERN_WARNING "jffs2_nand_set_oobinfo(): Eeep. Autoplacement selected and no empty space in oob\n");
1140                         return -ENOSPC;
1141                 }
1142                 c->fsdata_pos = oinfo->oobfree[0][0];
1143                 c->fsdata_len = oinfo->oobfree[0][1];
1144                 if (c->fsdata_len > 8)
1145                         c->fsdata_len = 8;
1146         } else {
1147                 /* This is just a legacy fallback and should go away soon */
1148                 switch(c->mtd->ecctype) {
1149                 case MTD_ECC_RS_DiskOnChip:
1150                         printk(KERN_WARNING "JFFS2 using DiskOnChip hardware ECC without autoplacement. Fix it!\n");
1151                         c->oobinfo = &jffs2_oobinfo_docecc;
1152                         c->fsdata_pos = 6;
1153                         c->fsdata_len = NAND_JFFS2_OOB16_FSDALEN;
1154                         c->badblock_pos = 15;
1155                         break;
1156
1157                 default:
1158                         D1(printk(KERN_DEBUG "JFFS2 on NAND. No autoplacment info found\n"));
1159                         return -EINVAL;
1160                 }
1161         }
1162         return 0;
1163 }
1164
1165 int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
1166 {
1167         int res;
1168
1169         /* Initialise write buffer */
1170         init_rwsem(&c->wbuf_sem);
1171         c->wbuf_pagesize = c->mtd->oobblock;
1172         c->wbuf_ofs = 0xFFFFFFFF;
1173
1174         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1175         if (!c->wbuf)
1176                 return -ENOMEM;
1177
1178         res = jffs2_nand_set_oobinfo(c);
1179
1180 #ifdef BREAKME
1181         if (!brokenbuf)
1182                 brokenbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1183         if (!brokenbuf) {
1184                 kfree(c->wbuf);
1185                 return -ENOMEM;
1186         }
1187         memset(brokenbuf, 0xdb, c->wbuf_pagesize);
1188 #endif
1189         return res;
1190 }
1191
1192 void jffs2_nand_flash_cleanup(struct jffs2_sb_info *c)
1193 {
1194         kfree(c->wbuf);
1195 }
1196
1197 int jffs2_dataflash_setup(struct jffs2_sb_info *c) {
1198         c->cleanmarker_size = 0;                /* No cleanmarkers needed */
1199
1200         /* Initialize write buffer */
1201         init_rwsem(&c->wbuf_sem);
1202         c->wbuf_pagesize = c->sector_size;
1203         c->wbuf_ofs = 0xFFFFFFFF;
1204
1205         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1206         if (!c->wbuf)
1207                 return -ENOMEM;
1208
1209         printk(KERN_INFO "JFFS2 write-buffering enabled (%i)\n", c->wbuf_pagesize);
1210
1211         return 0;
1212 }
1213
1214 void jffs2_dataflash_cleanup(struct jffs2_sb_info *c) {
1215         kfree(c->wbuf);
1216 }
1217
1218 int jffs2_nor_ecc_flash_setup(struct jffs2_sb_info *c) {
1219         /* Cleanmarker is actually larger on the flashes */
1220         c->cleanmarker_size = 16;
1221
1222         /* Initialize write buffer */
1223         init_rwsem(&c->wbuf_sem);
1224         c->wbuf_pagesize = c->mtd->eccsize;
1225         c->wbuf_ofs = 0xFFFFFFFF;
1226
1227         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1228         if (!c->wbuf)
1229                 return -ENOMEM;
1230
1231         return 0;
1232 }
1233
1234 void jffs2_nor_ecc_flash_cleanup(struct jffs2_sb_info *c) {
1235         kfree(c->wbuf);
1236 }