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.100 2005/09/30 13:59:13 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 <linux/jiffies.h>
  22
  23 #include "nodelist.h"
  24
  25 /* For testing write failures */
  26 #undef BREAKME
  27 #undef BREAKMEHEADER
  28
  29 #ifdef BREAKME
  30 static unsigned char *brokenbuf;
  31 #endif
  32
  33 #define PAGE_DIV(x) ( ((unsigned long)(x) / (unsigned long)(c->wbuf_pagesize)) * (unsigned long)(c->wbuf_pagesize) )
  34 #define PAGE_MOD(x) ( (unsigned long)(x) % (unsigned long)(c->wbuf_pagesize) )
  35
  36 /* max. erase failures before we mark a block bad */
  37 #define MAX_ERASE_FAILURES      2
  38
  39 struct jffs2_inodirty {
  40         uint32_t ino;
  41         struct jffs2_inodirty *next;
  42 };
  43
  44 static struct jffs2_inodirty inodirty_nomem;
  45
  46 static int jffs2_wbuf_pending_for_ino(struct jffs2_sb_info *c, uint32_t ino)
  47 {
  48         struct jffs2_inodirty *this = c->wbuf_inodes;
  49
  50         /* If a malloc failed, consider _everything_ dirty */
  51         if (this == &inodirty_nomem)
  52                 return 1;
  53
  54         /* If ino == 0, _any_ non-GC writes mean 'yes' */
  55         if (this && !ino)
  56                 return 1;
  57
  58         /* Look to see if the inode in question is pending in the wbuf */
  59         while (this) {
  60                 if (this->ino == ino)
  61                         return 1;
  62                 this = this->next;
  63         }
  64         return 0;
  65 }
  66
  67 static void jffs2_clear_wbuf_ino_list(struct jffs2_sb_info *c)
  68 {
  69         struct jffs2_inodirty *this;
  70
  71         this = c->wbuf_inodes;
  72
  73         if (this != &inodirty_nomem) {
  74                 while (this) {
  75                         struct jffs2_inodirty *next = this->next;
  76                         kfree(this);
  77                         this = next;
  78                 }
  79         }
  80         c->wbuf_inodes = NULL;
  81 }
  82
  83 static void jffs2_wbuf_dirties_inode(struct jffs2_sb_info *c, uint32_t ino)
  84 {
  85         struct jffs2_inodirty *new;
  86
  87         /* Mark the superblock dirty so that kupdated will flush... */
  88         jffs2_erase_pending_trigger(c);
  89
  90         if (jffs2_wbuf_pending_for_ino(c, ino))
  91                 return;
  92
  93         new = kmalloc(sizeof(*new), GFP_KERNEL);
  94         if (!new) {
  95                 D1(printk(KERN_DEBUG "No memory to allocate inodirty. Fallback to all considered dirty\n"));
  96                 jffs2_clear_wbuf_ino_list(c);
  97                 c->wbuf_inodes = &inodirty_nomem;
  98                 return;
  99         }
 100         new->ino = ino;
 101         new->next = c->wbuf_inodes;
 102         c->wbuf_inodes = new;
 103         return;
 104 }
 105
 106 static inline void jffs2_refile_wbuf_blocks(struct jffs2_sb_info *c)
 107 {
 108         struct list_head *this, *next;
 109         static int n;
 110
 111         if (list_empty(&c->erasable_pending_wbuf_list))
 112                 return;
 113
 114         list_for_each_safe(this, next, &c->erasable_pending_wbuf_list) {
 115                 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
 116
 117                 D1(printk(KERN_DEBUG "Removing eraseblock at 0x%08x from erasable_pending_wbuf_list...\n", jeb->offset));
 118                 list_del(this);
 119                 if ((jiffies + (n++)) & 127) {
 120                         /* Most of the time, we just erase it immediately. Otherwise we
 121                            spend ages scanning it on mount, etc. */
 122                         D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n"));
 123                         list_add_tail(&jeb->list, &c->erase_pending_list);
 124                         c->nr_erasing_blocks++;
 125                         jffs2_erase_pending_trigger(c);
 126                 } else {
 127                         /* Sometimes, however, we leave it elsewhere so it doesn't get
 128                            immediately reused, and we spread the load a bit. */
 129                         D1(printk(KERN_DEBUG "...and adding to erasable_list\n"));
 130                         list_add_tail(&jeb->list, &c->erasable_list);
 131                 }
 132         }
 133 }
 134
 135 #define REFILE_NOTEMPTY 0
 136 #define REFILE_ANYWAY   1
 137
 138 static void jffs2_block_refile(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int allow_empty)
 139 {
 140         D1(printk("About to refile bad block at %08x\n", jeb->offset));
 141
 142         /* File the existing block on the bad_used_list.... */
 143         if (c->nextblock == jeb)
 144                 c->nextblock = NULL;
 145         else /* Not sure this should ever happen... need more coffee */
 146                 list_del(&jeb->list);
 147         if (jeb->first_node) {
 148                 D1(printk("Refiling block at %08x to bad_used_list\n", jeb->offset));
 149                 list_add(&jeb->list, &c->bad_used_list);
 150         } else {
 151                 BUG_ON(allow_empty == REFILE_NOTEMPTY);
 152                 /* It has to have had some nodes or we couldn't be here */
 153                 D1(printk("Refiling block at %08x to erase_pending_list\n", jeb->offset));
 154                 list_add(&jeb->list, &c->erase_pending_list);
 155                 c->nr_erasing_blocks++;
 156                 jffs2_erase_pending_trigger(c);
 157         }
 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         jffs2_dbg_dump_block_lists_nolock(c);
 166         jffs2_dbg_acct_sanity_check_nolock(c,jeb);
 167         jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
 168 }
 169
 170 /* Recover from failure to write wbuf. Recover the nodes up to the
 171  * wbuf, not the one which we were starting to try to write. */
 172
 173 static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
 174 {
 175         struct jffs2_eraseblock *jeb, *new_jeb;
 176         struct jffs2_raw_node_ref **first_raw, **raw;
 177         size_t retlen;
 178         int ret;
 179         unsigned char *buf;
 180         uint32_t start, end, ofs, len;
 181
 182         spin_lock(&c->erase_completion_lock);
 183
 184         jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
 185
 186         jffs2_block_refile(c, jeb, REFILE_NOTEMPTY);
 187
 188         /* Find the first node to be recovered, by skipping over every
 189            node which ends before the wbuf starts, or which is obsolete. */
 190         first_raw = &jeb->first_node;
 191         while (*first_raw &&
 192                (ref_obsolete(*first_raw) ||
 193                 (ref_offset(*first_raw)+ref_totlen(c, jeb, *first_raw)) < c->wbuf_ofs)) {
 194                 D1(printk(KERN_DEBUG "Skipping node at 0x%08x(%d)-0x%08x which is either before 0x%08x or obsolete\n",
 195                           ref_offset(*first_raw), ref_flags(*first_raw),
 196                           (ref_offset(*first_raw) + ref_totlen(c, jeb, *first_raw)),
 197                           c->wbuf_ofs));
 198                 first_raw = &(*first_raw)->next_phys;
 199         }
 200
 201         if (!*first_raw) {
 202                 /* All nodes were obsolete. Nothing to recover. */
 203                 D1(printk(KERN_DEBUG "No non-obsolete nodes to be recovered. Just filing block bad\n"));
 204                 spin_unlock(&c->erase_completion_lock);
 205                 return;
 206         }
 207
 208         start = ref_offset(*first_raw);
 209         end = ref_offset(*first_raw) + ref_totlen(c, jeb, *first_raw);
 210
 211         /* Find the last node to be recovered */
 212         raw = first_raw;
 213         while ((*raw)) {
 214                 if (!ref_obsolete(*raw))
 215                         end = ref_offset(*raw) + ref_totlen(c, jeb, *raw);
 216
 217                 raw = &(*raw)->next_phys;
 218         }
 219         spin_unlock(&c->erase_completion_lock);
 220
 221         D1(printk(KERN_DEBUG "wbuf recover %08x-%08x\n", start, end));
 222
 223         buf = NULL;
 224         if (start < c->wbuf_ofs) {
 225                 /* First affected node was already partially written.
 226                  * Attempt to reread the old data into our buffer. */
 227
 228                 buf = kmalloc(end - start, GFP_KERNEL);
 229                 if (!buf) {
 230                         printk(KERN_CRIT "Malloc failure in wbuf recovery. Data loss ensues.\n");
 231
 232                         goto read_failed;
 233                 }
 234
 235                 /* Do the read... */
 236                 if (jffs2_cleanmarker_oob(c))
 237                         ret = c->mtd->read_ecc(c->mtd, start, c->wbuf_ofs - start, &retlen, buf, NULL, c->oobinfo);
 238                 else
 239                         ret = c->mtd->read(c->mtd, start, c->wbuf_ofs - start, &retlen, buf);
 240
 241                 if (ret == -EBADMSG && retlen == c->wbuf_ofs - start) {
 242                         /* ECC recovered */
 243                         ret = 0;
 244                 }
 245                 if (ret || retlen != c->wbuf_ofs - start) {
 246                         printk(KERN_CRIT "Old data are already lost in wbuf recovery. Data loss ensues.\n");
 247
 248                         kfree(buf);
 249                         buf = NULL;
 250                 read_failed:
 251                         first_raw = &(*first_raw)->next_phys;
 252                         /* If this was the only node to be recovered, give up */
 253                         if (!(*first_raw))
 254                                 return;
 255
 256                         /* It wasn't. Go on and try to recover nodes complete in the wbuf */
 257                         start = ref_offset(*first_raw);
 258                 } else {
 259                         /* Read succeeded. Copy the remaining data from the wbuf */
 260                         memcpy(buf + (c->wbuf_ofs - start), c->wbuf, end - c->wbuf_ofs);
 261                 }
 262         }
 263         /* OK... we're to rewrite (end-start) bytes of data from first_raw onwards.
 264            Either 'buf' contains the data, or we find it in the wbuf */
 265
 266
 267         /* ... and get an allocation of space from a shiny new block instead */
 268         ret = jffs2_reserve_space_gc(c, end-start, &ofs, &len, JFFS2_SUMMARY_NOSUM_SIZE);
 269         if (ret) {
 270                 printk(KERN_WARNING "Failed to allocate space for wbuf recovery. Data loss ensues.\n");
 271                 kfree(buf);
 272                 return;
 273         }
 274         if (end-start >= c->wbuf_pagesize) {
 275                 /* Need to do another write immediately, but it's possible
 276                    that this is just because the wbuf itself is completely
 277                    full, and there's nothing earlier read back from the
 278                    flash. Hence 'buf' isn't necessarily what we're writing
 279                    from. */
 280                 unsigned char *rewrite_buf = buf?:c->wbuf;
 281                 uint32_t towrite = (end-start) - ((end-start)%c->wbuf_pagesize);
 282
 283                 D1(printk(KERN_DEBUG "Write 0x%x bytes at 0x%08x in wbuf recover\n",
 284                           towrite, ofs));
 285
 286 #ifdef BREAKMEHEADER
 287                 static int breakme;
 288                 if (breakme++ == 20) {
 289                         printk(KERN_NOTICE "Faking write error at 0x%08x\n", ofs);
 290                         breakme = 0;
 291                         c->mtd->write_ecc(c->mtd, ofs, towrite, &retlen,
 292                                           brokenbuf, NULL, c->oobinfo);
 293                         ret = -EIO;
 294                 } else
 295 #endif
 296                 if (jffs2_cleanmarker_oob(c))
 297                         ret = c->mtd->write_ecc(c->mtd, ofs, towrite, &retlen,
 298                                                 rewrite_buf, NULL, c->oobinfo);
 299                 else
 300                         ret = c->mtd->write(c->mtd, ofs, towrite, &retlen, rewrite_buf);
 301
 302                 if (ret || retlen != towrite) {
 303                         /* Argh. We tried. Really we did. */
 304                         printk(KERN_CRIT "Recovery of wbuf failed due to a second write error\n");
 305                         kfree(buf);
 306
 307                         if (retlen) {
 308                                 struct jffs2_raw_node_ref *raw2;
 309
 310                                 raw2 = jffs2_alloc_raw_node_ref();
 311                                 if (!raw2)
 312                                         return;
 313
 314                                 raw2->flash_offset = ofs | REF_OBSOLETE;
 315                                 raw2->__totlen = ref_totlen(c, jeb, *first_raw);
 316                                 raw2->next_phys = NULL;
 317                                 raw2->next_in_ino = NULL;
 318
 319                                 jffs2_add_physical_node_ref(c, raw2);
 320                         }
 321                         return;
 322                 }
 323                 printk(KERN_NOTICE "Recovery of wbuf succeeded to %08x\n", ofs);
 324
 325                 c->wbuf_len = (end - start) - towrite;
 326                 c->wbuf_ofs = ofs + towrite;
 327                 memmove(c->wbuf, rewrite_buf + towrite, c->wbuf_len);
 328                 /* Don't muck about with c->wbuf_inodes. False positives are harmless. */
 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         jffs2_dbg_acct_sanity_check_nolock(c, jeb);
 394         jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
 395
 396         jffs2_dbg_acct_sanity_check_nolock(c, new_jeb);
 397         jffs2_dbg_acct_paranoia_check_nolock(c, 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 ) {
 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) {
 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 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)
 607 {
 608         struct kvec outvecs[3];
 609         uint32_t totlen = 0;
 610         uint32_t split_ofs = 0;
 611         uint32_t old_totlen;
 612         int ret, splitvec = -1;
 613         int invec, outvec;
 614         size_t wbuf_retlen;
 615         unsigned char *wbuf_ptr;
 616         size_t donelen = 0;
 617         uint32_t outvec_to = to;
 618
 619         /* If not NAND flash, don't bother */
 620         if (!jffs2_is_writebuffered(c))
 621                 return jffs2_flash_direct_writev(c, invecs, count, to, retlen);
 622
 623         down_write(&c->wbuf_sem);
 624
 625         /* If wbuf_ofs is not initialized, set it to target address */
 626         if (c->wbuf_ofs == 0xFFFFFFFF) {
 627                 c->wbuf_ofs = PAGE_DIV(to);
 628                 c->wbuf_len = PAGE_MOD(to);
 629                 memset(c->wbuf,0xff,c->wbuf_pagesize);
 630         }
 631
 632         /* Fixup the wbuf if we are moving to a new eraseblock.  The checks below
 633            fail for ECC'd NOR because cleanmarker == 16, so a block starts at
 634            xxx0010.  */
 635         if (jffs2_nor_ecc(c)) {
 636                 if (((c->wbuf_ofs % c->sector_size) == 0) && !c->wbuf_len) {
 637                         c->wbuf_ofs = PAGE_DIV(to);
 638                         c->wbuf_len = PAGE_MOD(to);
 639                         memset(c->wbuf,0xff,c->wbuf_pagesize);
 640                 }
 641         }
 642
 643         /* Sanity checks on target address.
 644            It's permitted to write at PAD(c->wbuf_len+c->wbuf_ofs),
 645            and it's permitted to write at the beginning of a new
 646            erase block. Anything else, and you die.
 647            New block starts at xxx000c (0-b = block header)
 648         */
 649         if (SECTOR_ADDR(to) != SECTOR_ADDR(c->wbuf_ofs)) {
 650                 /* It's a write to a new block */
 651                 if (c->wbuf_len) {
 652                         D1(printk(KERN_DEBUG "jffs2_flash_writev() to 0x%lx causes flush of wbuf at 0x%08x\n", (unsigned long)to, c->wbuf_ofs));
 653                         ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
 654                         if (ret) {
 655                                 /* the underlying layer has to check wbuf_len to do the cleanup */
 656                                 D1(printk(KERN_WARNING "jffs2_flush_wbuf() called from jffs2_flash_writev() failed %d\n", ret));
 657                                 *retlen = 0;
 658                                 goto exit;
 659                         }
 660                 }
 661                 /* set pointer to new block */
 662                 c->wbuf_ofs = PAGE_DIV(to);
 663                 c->wbuf_len = PAGE_MOD(to);
 664         }
 665
 666         if (to != PAD(c->wbuf_ofs + c->wbuf_len)) {
 667                 /* We're not writing immediately after the writebuffer. Bad. */
 668                 printk(KERN_CRIT "jffs2_flash_writev(): Non-contiguous write to %08lx\n", (unsigned long)to);
 669                 if (c->wbuf_len)
 670                         printk(KERN_CRIT "wbuf was previously %08x-%08x\n",
 671                                           c->wbuf_ofs, c->wbuf_ofs+c->wbuf_len);
 672                 BUG();
 673         }
 674
 675         /* Note outvecs[3] above. We know count is never greater than 2 */
 676         if (count > 2) {
 677                 printk(KERN_CRIT "jffs2_flash_writev(): count is %ld\n", count);
 678                 BUG();
 679         }
 680
 681         invec = 0;
 682         outvec = 0;
 683
 684         /* Fill writebuffer first, if already in use */
 685         if (c->wbuf_len) {
 686                 uint32_t invec_ofs = 0;
 687
 688                 /* adjust alignment offset */
 689                 if (c->wbuf_len != PAGE_MOD(to)) {
 690                         c->wbuf_len = PAGE_MOD(to);
 691                         /* take care of alignment to next page */
 692                         if (!c->wbuf_len)
 693                                 c->wbuf_len = c->wbuf_pagesize;
 694                 }
 695
 696                 while(c->wbuf_len < c->wbuf_pagesize) {
 697                         uint32_t thislen;
 698
 699                         if (invec == count)
 700                                 goto alldone;
 701
 702                         thislen = c->wbuf_pagesize - c->wbuf_len;
 703
 704                         if (thislen >= invecs[invec].iov_len)
 705                                 thislen = invecs[invec].iov_len;
 706
 707                         invec_ofs = thislen;
 708
 709                         memcpy(c->wbuf + c->wbuf_len, invecs[invec].iov_base, thislen);
 710                         c->wbuf_len += thislen;
 711                         donelen += thislen;
 712                         /* Get next invec, if actual did not fill the buffer */
 713                         if (c->wbuf_len < c->wbuf_pagesize)
 714                                 invec++;
 715                 }
 716
 717                 /* write buffer is full, flush buffer */
 718                 ret = __jffs2_flush_wbuf(c, NOPAD);
 719                 if (ret) {
 720                         /* the underlying layer has to check wbuf_len to do the cleanup */
 721                         D1(printk(KERN_WARNING "jffs2_flush_wbuf() called from jffs2_flash_writev() failed %d\n", ret));
 722                         /* Retlen zero to make sure our caller doesn't mark the space dirty.
 723                            We've already done everything that's necessary */
 724                         *retlen = 0;
 725                         goto exit;
 726                 }
 727                 outvec_to += donelen;
 728                 c->wbuf_ofs = outvec_to;
 729
 730                 /* All invecs done ? */
 731                 if (invec == count)
 732                         goto alldone;
 733
 734                 /* Set up the first outvec, containing the remainder of the
 735                    invec we partially used */
 736                 if (invecs[invec].iov_len > invec_ofs) {
 737                         outvecs[0].iov_base = invecs[invec].iov_base+invec_ofs;
 738                         totlen = outvecs[0].iov_len = invecs[invec].iov_len-invec_ofs;
 739                         if (totlen > c->wbuf_pagesize) {
 740                                 splitvec = outvec;
 741                                 split_ofs = outvecs[0].iov_len - PAGE_MOD(totlen);
 742                         }
 743                         outvec++;
 744                 }
 745                 invec++;
 746         }
 747
 748         /* OK, now we've flushed the wbuf and the start of the bits
 749            we have been asked to write, now to write the rest.... */
 750
 751         /* totlen holds the amount of data still to be written */
 752         old_totlen = totlen;
 753         for ( ; invec < count; invec++,outvec++ ) {
 754                 outvecs[outvec].iov_base = invecs[invec].iov_base;
 755                 totlen += outvecs[outvec].iov_len = invecs[invec].iov_len;
 756                 if (PAGE_DIV(totlen) != PAGE_DIV(old_totlen)) {
 757                         splitvec = outvec;
 758                         split_ofs = outvecs[outvec].iov_len - PAGE_MOD(totlen);
 759                         old_totlen = totlen;
 760                 }
 761         }
 762
 763         /* Now the outvecs array holds all the remaining data to write */
 764         /* Up to splitvec,split_ofs is to be written immediately. The rest
 765            goes into the (now-empty) wbuf */
 766
 767         if (splitvec != -1) {
 768                 uint32_t remainder;
 769
 770                 remainder = outvecs[splitvec].iov_len - split_ofs;
 771                 outvecs[splitvec].iov_len = split_ofs;
 772
 773                 /* We did cross a page boundary, so we write some now */
 774                 if (jffs2_cleanmarker_oob(c))
 775                         ret = c->mtd->writev_ecc(c->mtd, outvecs, splitvec+1, outvec_to, &wbuf_retlen, NULL, c->oobinfo);
 776                 else
 777                         ret = jffs2_flash_direct_writev(c, outvecs, splitvec+1, outvec_to, &wbuf_retlen);
 778
 779                 if (ret < 0 || wbuf_retlen != PAGE_DIV(totlen)) {
 780                         /* At this point we have no problem,
 781                            c->wbuf is empty. However refile nextblock to avoid
 782                            writing again to same address.
 783                         */
 784                         struct jffs2_eraseblock *jeb;
 785
 786                         spin_lock(&c->erase_completion_lock);
 787
 788                         jeb = &c->blocks[outvec_to / c->sector_size];
 789                         jffs2_block_refile(c, jeb, REFILE_ANYWAY);
 790
 791                         *retlen = 0;
 792                         spin_unlock(&c->erase_completion_lock);
 793                         goto exit;
 794                 }
 795
 796                 donelen += wbuf_retlen;
 797                 c->wbuf_ofs = PAGE_DIV(outvec_to) + PAGE_DIV(totlen);
 798
 799                 if (remainder) {
 800                         outvecs[splitvec].iov_base += split_ofs;
 801                         outvecs[splitvec].iov_len = remainder;
 802                 } else {
 803                         splitvec++;
 804                 }
 805
 806         } else {
 807                 splitvec = 0;
 808         }
 809
 810         /* Now splitvec points to the start of the bits we have to copy
 811            into the wbuf */
 812         wbuf_ptr = c->wbuf;
 813
 814         for ( ; splitvec < outvec; splitvec++) {
 815                 /* Don't copy the wbuf into itself */
 816                 if (outvecs[splitvec].iov_base == c->wbuf)
 817                         continue;
 818                 memcpy(wbuf_ptr, outvecs[splitvec].iov_base, outvecs[splitvec].iov_len);
 819                 wbuf_ptr += outvecs[splitvec].iov_len;
 820                 donelen += outvecs[splitvec].iov_len;
 821         }
 822         c->wbuf_len = wbuf_ptr - c->wbuf;
 823
 824         /* If there's a remainder in the wbuf and it's a non-GC write,
 825            remember that the wbuf affects this ino */
 826 alldone:
 827         *retlen = donelen;
 828
 829         if (jffs2_sum_active()) {
 830                 int res = jffs2_sum_add_kvec(c, invecs, count, (uint32_t) to);
 831                 if (res)
 832                         return res;
 833         }
 834
 835         if (c->wbuf_len && ino)
 836                 jffs2_wbuf_dirties_inode(c, ino);
 837
 838         ret = 0;
 839
 840 exit:
 841         up_write(&c->wbuf_sem);
 842         return ret;
 843 }
 844
 845 /*
 846  *      This is the entry for flash write.
 847  *      Check, if we work on NAND FLASH, if so build an kvec and write it via vritev
 848 */
 849 int jffs2_flash_write(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, const u_char *buf)
 850 {
 851         struct kvec vecs[1];
 852
 853         if (!jffs2_is_writebuffered(c))
 854                 return jffs2_flash_direct_write(c, ofs, len, retlen, buf);
 855
 856         vecs[0].iov_base = (unsigned char *) buf;
 857         vecs[0].iov_len = len;
 858         return jffs2_flash_writev(c, vecs, 1, ofs, retlen, 0);
 859 }
 860
 861 /*
 862         Handle readback from writebuffer and ECC failure return
 863 */
 864 int jffs2_flash_read(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, u_char *buf)
 865 {
 866         loff_t  orbf = 0, owbf = 0, lwbf = 0;
 867         int     ret;
 868
 869         if (!jffs2_is_writebuffered(c))
 870                 return c->mtd->read(c->mtd, ofs, len, retlen, buf);
 871
 872         /* Read flash */
 873         down_read(&c->wbuf_sem);
 874         if (jffs2_cleanmarker_oob(c))
 875                 ret = c->mtd->read_ecc(c->mtd, ofs, len, retlen, buf, NULL, c->oobinfo);
 876         else
 877                 ret = c->mtd->read(c->mtd, ofs, len, retlen, buf);
 878
 879         if ( (ret == -EBADMSG) && (*retlen == len) ) {
 880                 printk(KERN_WARNING "mtd->read(0x%zx bytes from 0x%llx) returned ECC error\n",
 881                        len, ofs);
 882                 /*
 883                  * We have the raw data without ECC correction in the buffer, maybe
 884                  * we are lucky and all data or parts are correct. We check the node.
 885                  * If data are corrupted node check will sort it out.
 886                  * We keep this block, it will fail on write or erase and the we
 887                  * mark it bad. Or should we do that now? But we should give him a chance.
 888                  * Maybe we had a system crash or power loss before the ecc write or
 889                  * a erase was completed.
 890                  * So we return success. :)
 891                  */
 892                 ret = 0;
 893         }
 894
 895         /* if no writebuffer available or write buffer empty, return */
 896         if (!c->wbuf_pagesize || !c->wbuf_len)
 897                 goto exit;
 898
 899         /* if we read in a different block, return */
 900         if (SECTOR_ADDR(ofs) != SECTOR_ADDR(c->wbuf_ofs))
 901                 goto exit;
 902
 903         if (ofs >= c->wbuf_ofs) {
 904                 owbf = (ofs - c->wbuf_ofs);     /* offset in write buffer */
 905                 if (owbf > c->wbuf_len)         /* is read beyond write buffer ? */
 906                         goto exit;
 907                 lwbf = c->wbuf_len - owbf;      /* number of bytes to copy */
 908                 if (lwbf > len)
 909                         lwbf = len;
 910         } else {
 911                 orbf = (c->wbuf_ofs - ofs);     /* offset in read buffer */
 912                 if (orbf > len)                 /* is write beyond write buffer ? */
 913                         goto exit;
 914                 lwbf = len - orbf;              /* number of bytes to copy */
 915                 if (lwbf > c->wbuf_len)
 916                         lwbf = c->wbuf_len;
 917         }
 918         if (lwbf > 0)
 919                 memcpy(buf+orbf,c->wbuf+owbf,lwbf);
 920
 921 exit:
 922         up_read(&c->wbuf_sem);
 923         return ret;
 924 }
 925
 926 /*
 927  *      Check, if the out of band area is empty
 928  */
 929 int jffs2_check_oob_empty( struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int mode)
 930 {
 931         unsigned char *buf;
 932         int     ret = 0;
 933         int     i,len,page;
 934         size_t  retlen;
 935         int     oob_size;
 936
 937         /* allocate a buffer for all oob data in this sector */
 938         oob_size = c->mtd->oobsize;
 939         len = 4 * oob_size;
 940         buf = kmalloc(len, GFP_KERNEL);
 941         if (!buf) {
 942                 printk(KERN_NOTICE "jffs2_check_oob_empty(): allocation of temporary data buffer for oob check failed\n");
 943                 return -ENOMEM;
 944         }
 945         /*
 946          * if mode = 0, we scan for a total empty oob area, else we have
 947          * to take care of the cleanmarker in the first page of the block
 948         */
 949         ret = jffs2_flash_read_oob(c, jeb->offset, len , &retlen, buf);
 950         if (ret) {
 951                 D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB failed %d for block at %08x\n", ret, jeb->offset));
 952                 goto out;
 953         }
 954
 955         if (retlen < len) {
 956                 D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB return short read "
 957                           "(%zd bytes not %d) for block at %08x\n", retlen, len, jeb->offset));
 958                 ret = -EIO;
 959                 goto out;
 960         }
 961
 962         /* Special check for first page */
 963         for(i = 0; i < oob_size ; i++) {
 964                 /* Yeah, we know about the cleanmarker. */
 965                 if (mode && i >= c->fsdata_pos &&
 966                     i < c->fsdata_pos + c->fsdata_len)
 967                         continue;
 968
 969                 if (buf[i] != 0xFF) {
 970                         D2(printk(KERN_DEBUG "Found %02x at %x in OOB for %08x\n",
 971                                   buf[i], i, jeb->offset));
 972                         ret = 1;
 973                         goto out;
 974                 }
 975         }
 976
 977         /* we know, we are aligned :) */
 978         for (page = oob_size; page < len; page += sizeof(long)) {
 979                 unsigned long dat = *(unsigned long *)(&buf[page]);
 980                 if(dat != -1) {
 981                         ret = 1;
 982                         goto out;
 983                 }
 984         }
 985
 986 out:
 987         kfree(buf);
 988
 989         return ret;
 990 }
 991
 992 /*
 993 *       Scan for a valid cleanmarker and for bad blocks
 994 *       For virtual blocks (concatenated physical blocks) check the cleanmarker
 995 *       only in the first page of the first physical block, but scan for bad blocks in all
 996 *       physical blocks
 997 */
 998 int jffs2_check_nand_cleanmarker (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
 999 {
1000         struct jffs2_unknown_node n;
1001         unsigned char buf[2 * NAND_MAX_OOBSIZE];
1002         unsigned char *p;
1003         int ret, i, cnt, retval = 0;
1004         size_t retlen, offset;
1005         int oob_size;
1006
1007         offset = jeb->offset;
1008         oob_size = c->mtd->oobsize;
1009
1010         /* Loop through the physical blocks */
1011         for (cnt = 0; cnt < (c->sector_size / c->mtd->erasesize); cnt++) {
1012                 /* Check first if the block is bad. */
1013                 if (c->mtd->block_isbad (c->mtd, offset)) {
1014                         D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Bad block at %08x\n", jeb->offset));
1015                         return 2;
1016                 }
1017                 /*
1018                    *    We read oob data from page 0 and 1 of the block.
1019                    *    page 0 contains cleanmarker and badblock info
1020                    *    page 1 contains failure count of this block
1021                  */
1022                 ret = c->mtd->read_oob (c->mtd, offset, oob_size << 1, &retlen, buf);
1023
1024                 if (ret) {
1025                         D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Read OOB failed %d for block at %08x\n", ret, jeb->offset));
1026                         return ret;
1027                 }
1028                 if (retlen < (oob_size << 1)) {
1029                         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));
1030                         return -EIO;
1031                 }
1032
1033                 /* Check cleanmarker only on the first physical block */
1034                 if (!cnt) {
1035                         n.magic = cpu_to_je16 (JFFS2_MAGIC_BITMASK);
1036                         n.nodetype = cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER);
1037                         n.totlen = cpu_to_je32 (8);
1038                         p = (unsigned char *) &n;
1039
1040                         for (i = 0; i < c->fsdata_len; i++) {
1041                                 if (buf[c->fsdata_pos + i] != p[i]) {
1042                                         retval = 1;
1043                                 }
1044                         }
1045                         D1(if (retval == 1) {
1046                                 printk(KERN_WARNING "jffs2_check_nand_cleanmarker(): Cleanmarker node not detected in block at %08x\n", jeb->offset);
1047                                 printk(KERN_WARNING "OOB at %08x was ", offset);
1048                                 for (i=0; i < oob_size; i++) {
1049                                         printk("%02x ", buf[i]);
1050                                 }
1051                                 printk("\n");
1052                         })
1053                 }
1054                 offset += c->mtd->erasesize;
1055         }
1056         return retval;
1057 }
1058
1059 int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
1060 {
1061         struct  jffs2_unknown_node n;
1062         int     ret;
1063         size_t  retlen;
1064
1065         n.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
1066         n.nodetype = cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER);
1067         n.totlen = cpu_to_je32(8);
1068
1069         ret = jffs2_flash_write_oob(c, jeb->offset + c->fsdata_pos, c->fsdata_len, &retlen, (unsigned char *)&n);
1070
1071         if (ret) {
1072                 D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
1073                 return ret;
1074         }
1075         if (retlen != c->fsdata_len) {
1076                 D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): Short write for block at %08x: %zd not %d\n", jeb->offset, retlen, c->fsdata_len));
1077                 return ret;
1078         }
1079         return 0;
1080 }
1081
1082 /*
1083  * On NAND we try to mark this block bad. If the block was erased more
1084  * than MAX_ERASE_FAILURES we mark it finaly bad.
1085  * Don't care about failures. This block remains on the erase-pending
1086  * or badblock list as long as nobody manipulates the flash with
1087  * a bootloader or something like that.
1088  */
1089
1090 int jffs2_write_nand_badblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t bad_offset)
1091 {
1092         int     ret;
1093
1094         /* if the count is < max, we try to write the counter to the 2nd page oob area */
1095         if( ++jeb->bad_count < MAX_ERASE_FAILURES)
1096                 return 0;
1097
1098         if (!c->mtd->block_markbad)
1099                 return 1; // What else can we do?
1100
1101         D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Marking bad block at %08x\n", bad_offset));
1102         ret = c->mtd->block_markbad(c->mtd, bad_offset);
1103
1104         if (ret) {
1105                 D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
1106                 return ret;
1107         }
1108         return 1;
1109 }
1110
1111 #define NAND_JFFS2_OOB16_FSDALEN        8
1112
1113 static struct nand_oobinfo jffs2_oobinfo_docecc = {
1114         .useecc = MTD_NANDECC_PLACE,
1115         .eccbytes = 6,
1116         .eccpos = {0,1,2,3,4,5}
1117 };
1118
1119
1120 static int jffs2_nand_set_oobinfo(struct jffs2_sb_info *c)
1121 {
1122         struct nand_oobinfo *oinfo = &c->mtd->oobinfo;
1123
1124         /* Do this only, if we have an oob buffer */
1125         if (!c->mtd->oobsize)
1126                 return 0;
1127
1128         /* Cleanmarker is out-of-band, so inline size zero */
1129         c->cleanmarker_size = 0;
1130
1131         /* Should we use autoplacement ? */
1132         if (oinfo && oinfo->useecc == MTD_NANDECC_AUTOPLACE) {
1133                 D1(printk(KERN_DEBUG "JFFS2 using autoplace on NAND\n"));
1134                 /* Get the position of the free bytes */
1135                 if (!oinfo->oobfree[0][1]) {
1136                         printk (KERN_WARNING "jffs2_nand_set_oobinfo(): Eeep. Autoplacement selected and no empty space in oob\n");
1137                         return -ENOSPC;
1138                 }
1139                 c->fsdata_pos = oinfo->oobfree[0][0];
1140                 c->fsdata_len = oinfo->oobfree[0][1];
1141                 if (c->fsdata_len > 8)
1142                         c->fsdata_len = 8;
1143         } else {
1144                 /* This is just a legacy fallback and should go away soon */
1145                 switch(c->mtd->ecctype) {
1146                 case MTD_ECC_RS_DiskOnChip:
1147                         printk(KERN_WARNING "JFFS2 using DiskOnChip hardware ECC without autoplacement. Fix it!\n");
1148                         c->oobinfo = &jffs2_oobinfo_docecc;
1149                         c->fsdata_pos = 6;
1150                         c->fsdata_len = NAND_JFFS2_OOB16_FSDALEN;
1151                         c->badblock_pos = 15;
1152                         break;
1153
1154                 default:
1155                         D1(printk(KERN_DEBUG "JFFS2 on NAND. No autoplacment info found\n"));
1156                         return -EINVAL;
1157                 }
1158         }
1159         return 0;
1160 }
1161
1162 int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
1163 {
1164         int res;
1165
1166         /* Initialise write buffer */
1167         init_rwsem(&c->wbuf_sem);
1168         c->wbuf_pagesize = c->mtd->oobblock;
1169         c->wbuf_ofs = 0xFFFFFFFF;
1170
1171         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1172         if (!c->wbuf)
1173                 return -ENOMEM;
1174
1175         res = jffs2_nand_set_oobinfo(c);
1176
1177 #ifdef BREAKME
1178         if (!brokenbuf)
1179                 brokenbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1180         if (!brokenbuf) {
1181                 kfree(c->wbuf);
1182                 return -ENOMEM;
1183         }
1184         memset(brokenbuf, 0xdb, c->wbuf_pagesize);
1185 #endif
1186         return res;
1187 }
1188
1189 void jffs2_nand_flash_cleanup(struct jffs2_sb_info *c)
1190 {
1191         kfree(c->wbuf);
1192 }
1193
1194 int jffs2_dataflash_setup(struct jffs2_sb_info *c) {
1195         c->cleanmarker_size = 0;                /* No cleanmarkers needed */
1196
1197         /* Initialize write buffer */
1198         init_rwsem(&c->wbuf_sem);
1199
1200
1201         c->wbuf_pagesize =  c->mtd->erasesize;
1202
1203         /* Find a suitable c->sector_size
1204          * - Not too much sectors
1205          * - Sectors have to be at least 4 K + some bytes
1206          * - All known dataflashes have erase sizes of 528 or 1056
1207          * - we take at least 8 eraseblocks and want to have at least 8K size
1208          * - The concatenation should be a power of 2
1209         */
1210
1211         c->sector_size = 8 * c->mtd->erasesize;
1212
1213         while (c->sector_size < 8192) {
1214                 c->sector_size *= 2;
1215         }
1216
1217         /* It may be necessary to adjust the flash size */
1218         c->flash_size = c->mtd->size;
1219
1220         if ((c->flash_size % c->sector_size) != 0) {
1221                 c->flash_size = (c->flash_size / c->sector_size) * c->sector_size;
1222                 printk(KERN_WARNING "JFFS2 flash size adjusted to %dKiB\n", c->flash_size);
1223         };
1224
1225         c->wbuf_ofs = 0xFFFFFFFF;
1226         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1227         if (!c->wbuf)
1228                 return -ENOMEM;
1229
1230         printk(KERN_INFO "JFFS2 write-buffering enabled buffer (%d) erasesize (%d)\n", c->wbuf_pagesize, c->sector_size);
1231
1232         return 0;
1233 }
1234
1235 void jffs2_dataflash_cleanup(struct jffs2_sb_info *c) {
1236         kfree(c->wbuf);
1237 }
1238
1239 int jffs2_nor_ecc_flash_setup(struct jffs2_sb_info *c) {
1240         /* Cleanmarker is actually larger on the flashes */
1241         c->cleanmarker_size = 16;
1242
1243         /* Initialize write buffer */
1244         init_rwsem(&c->wbuf_sem);
1245         c->wbuf_pagesize = c->mtd->eccsize;
1246         c->wbuf_ofs = 0xFFFFFFFF;
1247
1248         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1249         if (!c->wbuf)
1250                 return -ENOMEM;
1251
1252         return 0;
1253 }
1254
1255 void jffs2_nor_ecc_flash_cleanup(struct jffs2_sb_info *c) {
1256         kfree(c->wbuf);
1257 }
1258
1259 int jffs2_nor_wbuf_flash_setup(struct jffs2_sb_info *c) {
1260         /* Cleanmarker currently occupies a whole programming region */
1261         c->cleanmarker_size = MTD_PROGREGION_SIZE(c->mtd);
1262
1263         /* Initialize write buffer */
1264         init_rwsem(&c->wbuf_sem);
1265         c->wbuf_pagesize = MTD_PROGREGION_SIZE(c->mtd);
1266         c->wbuf_ofs = 0xFFFFFFFF;
1267
1268         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1269         if (!c->wbuf)
1270                 return -ENOMEM;
1271
1272         return 0;
1273 }
1274
1275 void jffs2_nor_wbuf_flash_cleanup(struct jffs2_sb_info *c) {
1276         kfree(c->wbuf);
1277 }