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                 if (buf)
 330                         kfree(buf);
 331         } else {
 332                 /* OK, now we're left with the dregs in whichever buffer we're using */
 333                 if (buf) {
 334                         memcpy(c->wbuf, buf, end-start);
 335                         kfree(buf);
 336                 } else {
 337                         memmove(c->wbuf, c->wbuf + (start - c->wbuf_ofs), end - start);
 338                 }
 339                 c->wbuf_ofs = ofs;
 340                 c->wbuf_len = end - start;
 341         }
 342
 343         /* Now sort out the jffs2_raw_node_refs, moving them from the old to the next block */
 344         new_jeb = &c->blocks[ofs / c->sector_size];
 345
 346         spin_lock(&c->erase_completion_lock);
 347         if (new_jeb->first_node) {
 348                 /* Odd, but possible with ST flash later maybe */
 349                 new_jeb->last_node->next_phys = *first_raw;
 350         } else {
 351                 new_jeb->first_node = *first_raw;
 352         }
 353
 354         raw = first_raw;
 355         while (*raw) {
 356                 uint32_t rawlen = ref_totlen(c, jeb, *raw);
 357
 358                 D1(printk(KERN_DEBUG "Refiling block of %08x at %08x(%d) to %08x\n",
 359                           rawlen, ref_offset(*raw), ref_flags(*raw), ofs));
 360
 361                 if (ref_obsolete(*raw)) {
 362                         /* Shouldn't really happen much */
 363                         new_jeb->dirty_size += rawlen;
 364                         new_jeb->free_size -= rawlen;
 365                         c->dirty_size += rawlen;
 366                 } else {
 367                         new_jeb->used_size += rawlen;
 368                         new_jeb->free_size -= rawlen;
 369                         jeb->dirty_size += rawlen;
 370                         jeb->used_size  -= rawlen;
 371                         c->dirty_size += rawlen;
 372                 }
 373                 c->free_size -= rawlen;
 374                 (*raw)->flash_offset = ofs | ref_flags(*raw);
 375                 ofs += rawlen;
 376                 new_jeb->last_node = *raw;
 377
 378                 raw = &(*raw)->next_phys;
 379         }
 380
 381         /* Fix up the original jeb now it's on the bad_list */
 382         *first_raw = NULL;
 383         if (first_raw == &jeb->first_node) {
 384                 jeb->last_node = NULL;
 385                 D1(printk(KERN_DEBUG "Failing block at %08x is now empty. Moving to erase_pending_list\n", jeb->offset));
 386                 list_del(&jeb->list);
 387                 list_add(&jeb->list, &c->erase_pending_list);
 388                 c->nr_erasing_blocks++;
 389                 jffs2_erase_pending_trigger(c);
 390         }
 391         else
 392                 jeb->last_node = container_of(first_raw, struct jffs2_raw_node_ref, next_phys);
 393
 394         jffs2_dbg_acct_sanity_check_nolock(c, jeb);
 395         jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
 396
 397         jffs2_dbg_acct_sanity_check_nolock(c, new_jeb);
 398         jffs2_dbg_acct_paranoia_check_nolock(c, new_jeb);
 399
 400         spin_unlock(&c->erase_completion_lock);
 401
 402         D1(printk(KERN_DEBUG "wbuf recovery completed OK\n"));
 403 }
 404
 405 /* Meaning of pad argument:
 406    0: Do not pad. Probably pointless - we only ever use this when we can't pad anyway.
 407    1: Pad, do not adjust nextblock free_size
 408    2: Pad, adjust nextblock free_size
 409 */
 410 #define NOPAD           0
 411 #define PAD_NOACCOUNT   1
 412 #define PAD_ACCOUNTING  2
 413
 414 static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
 415 {
 416         int ret;
 417         size_t retlen;
 418
 419         /* Nothing to do if not write-buffering the flash. In particular, we shouldn't
 420            del_timer() the timer we never initialised. */
 421         if (!jffs2_is_writebuffered(c))
 422                 return 0;
 423
 424         if (!down_trylock(&c->alloc_sem)) {
 425                 up(&c->alloc_sem);
 426                 printk(KERN_CRIT "jffs2_flush_wbuf() called with alloc_sem not locked!\n");
 427                 BUG();
 428         }
 429
 430         if (!c->wbuf_len)       /* already checked c->wbuf above */
 431                 return 0;
 432
 433         /* claim remaining space on the page
 434            this happens, if we have a change to a new block,
 435            or if fsync forces us to flush the writebuffer.
 436            if we have a switch to next page, we will not have
 437            enough remaining space for this.
 438         */
 439         if (pad ) {
 440                 c->wbuf_len = PAD(c->wbuf_len);
 441
 442                 /* Pad with JFFS2_DIRTY_BITMASK initially.  this helps out ECC'd NOR
 443                    with 8 byte page size */
 444                 memset(c->wbuf + c->wbuf_len, 0, c->wbuf_pagesize - c->wbuf_len);
 445
 446                 if ( c->wbuf_len + sizeof(struct jffs2_unknown_node) < c->wbuf_pagesize) {
 447                         struct jffs2_unknown_node *padnode = (void *)(c->wbuf + c->wbuf_len);
 448                         padnode->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
 449                         padnode->nodetype = cpu_to_je16(JFFS2_NODETYPE_PADDING);
 450                         padnode->totlen = cpu_to_je32(c->wbuf_pagesize - c->wbuf_len);
 451                         padnode->hdr_crc = cpu_to_je32(crc32(0, padnode, sizeof(*padnode)-4));
 452                 }
 453         }
 454         /* else jffs2_flash_writev has actually filled in the rest of the
 455            buffer for us, and will deal with the node refs etc. later. */
 456
 457 #ifdef BREAKME
 458         static int breakme;
 459         if (breakme++ == 20) {
 460                 printk(KERN_NOTICE "Faking write error at 0x%08x\n", c->wbuf_ofs);
 461                 breakme = 0;
 462                 c->mtd->write_ecc(c->mtd, c->wbuf_ofs, c->wbuf_pagesize,
 463                                         &retlen, brokenbuf, NULL, c->oobinfo);
 464                 ret = -EIO;
 465         } else
 466 #endif
 467
 468         if (jffs2_cleanmarker_oob(c))
 469                 ret = c->mtd->write_ecc(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf, NULL, c->oobinfo);
 470         else
 471                 ret = c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf);
 472
 473         if (ret || retlen != c->wbuf_pagesize) {
 474                 if (ret)
 475                         printk(KERN_WARNING "jffs2_flush_wbuf(): Write failed with %d\n",ret);
 476                 else {
 477                         printk(KERN_WARNING "jffs2_flush_wbuf(): Write was short: %zd instead of %d\n",
 478                                 retlen, c->wbuf_pagesize);
 479                         ret = -EIO;
 480                 }
 481
 482                 jffs2_wbuf_recover(c);
 483
 484                 return ret;
 485         }
 486
 487         spin_lock(&c->erase_completion_lock);
 488
 489         /* Adjust free size of the block if we padded. */
 490         if (pad) {
 491                 struct jffs2_eraseblock *jeb;
 492
 493                 jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
 494
 495                 D1(printk(KERN_DEBUG "jffs2_flush_wbuf() adjusting free_size of %sblock at %08x\n",
 496                           (jeb==c->nextblock)?"next":"", jeb->offset));
 497
 498                 /* wbuf_pagesize - wbuf_len is the amount of space that's to be
 499                    padded. If there is less free space in the block than that,
 500                    something screwed up */
 501                 if (jeb->free_size < (c->wbuf_pagesize - c->wbuf_len)) {
 502                         printk(KERN_CRIT "jffs2_flush_wbuf(): Accounting error. wbuf at 0x%08x has 0x%03x bytes, 0x%03x left.\n",
 503                                c->wbuf_ofs, c->wbuf_len, c->wbuf_pagesize-c->wbuf_len);
 504                         printk(KERN_CRIT "jffs2_flush_wbuf(): But free_size for block at 0x%08x is only 0x%08x\n",
 505                                jeb->offset, jeb->free_size);
 506                         BUG();
 507                 }
 508                 jeb->free_size -= (c->wbuf_pagesize - c->wbuf_len);
 509                 c->free_size -= (c->wbuf_pagesize - c->wbuf_len);
 510                 jeb->wasted_size += (c->wbuf_pagesize - c->wbuf_len);
 511                 c->wasted_size += (c->wbuf_pagesize - c->wbuf_len);
 512         }
 513
 514         /* Stick any now-obsoleted blocks on the erase_pending_list */
 515         jffs2_refile_wbuf_blocks(c);
 516         jffs2_clear_wbuf_ino_list(c);
 517         spin_unlock(&c->erase_completion_lock);
 518
 519         memset(c->wbuf,0xff,c->wbuf_pagesize);
 520         /* adjust write buffer offset, else we get a non contiguous write bug */
 521         c->wbuf_ofs += c->wbuf_pagesize;
 522         c->wbuf_len = 0;
 523         return 0;
 524 }
 525
 526 /* Trigger garbage collection to flush the write-buffer.
 527    If ino arg is zero, do it if _any_ real (i.e. not GC) writes are
 528    outstanding. If ino arg non-zero, do it only if a write for the
 529    given inode is outstanding. */
 530 int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino)
 531 {
 532         uint32_t old_wbuf_ofs;
 533         uint32_t old_wbuf_len;
 534         int ret = 0;
 535
 536         D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() called for ino #%u...\n", ino));
 537
 538         if (!c->wbuf)
 539                 return 0;
 540
 541         down(&c->alloc_sem);
 542         if (!jffs2_wbuf_pending_for_ino(c, ino)) {
 543                 D1(printk(KERN_DEBUG "Ino #%d not pending in wbuf. Returning\n", ino));
 544                 up(&c->alloc_sem);
 545                 return 0;
 546         }
 547
 548         old_wbuf_ofs = c->wbuf_ofs;
 549         old_wbuf_len = c->wbuf_len;
 550
 551         if (c->unchecked_size) {
 552                 /* GC won't make any progress for a while */
 553                 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() padding. Not finished checking\n"));
 554                 down_write(&c->wbuf_sem);
 555                 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
 556                 /* retry flushing wbuf in case jffs2_wbuf_recover
 557                    left some data in the wbuf */
 558                 if (ret)
 559                         ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
 560                 up_write(&c->wbuf_sem);
 561         } else while (old_wbuf_len &&
 562                       old_wbuf_ofs == c->wbuf_ofs) {
 563
 564                 up(&c->alloc_sem);
 565
 566                 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() calls gc pass\n"));
 567
 568                 ret = jffs2_garbage_collect_pass(c);
 569                 if (ret) {
 570                         /* GC failed. Flush it with padding instead */
 571                         down(&c->alloc_sem);
 572                         down_write(&c->wbuf_sem);
 573                         ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
 574                         /* retry flushing wbuf in case jffs2_wbuf_recover
 575                            left some data in the wbuf */
 576                         if (ret)
 577                                 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
 578                         up_write(&c->wbuf_sem);
 579                         break;
 580                 }
 581                 down(&c->alloc_sem);
 582         }
 583
 584         D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() ends...\n"));
 585
 586         up(&c->alloc_sem);
 587         return ret;
 588 }
 589
 590 /* Pad write-buffer to end and write it, wasting space. */
 591 int jffs2_flush_wbuf_pad(struct jffs2_sb_info *c)
 592 {
 593         int ret;
 594
 595         if (!c->wbuf)
 596                 return 0;
 597
 598         down_write(&c->wbuf_sem);
 599         ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
 600         /* retry - maybe wbuf recover left some data in wbuf. */
 601         if (ret)
 602                 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
 603         up_write(&c->wbuf_sem);
 604
 605         return ret;
 606 }
 607 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)
 608 {
 609         struct kvec outvecs[3];
 610         uint32_t totlen = 0;
 611         uint32_t split_ofs = 0;
 612         uint32_t old_totlen;
 613         int ret, splitvec = -1;
 614         int invec, outvec;
 615         size_t wbuf_retlen;
 616         unsigned char *wbuf_ptr;
 617         size_t donelen = 0;
 618         uint32_t outvec_to = to;
 619
 620         /* If not NAND flash, don't bother */
 621         if (!jffs2_is_writebuffered(c))
 622                 return jffs2_flash_direct_writev(c, invecs, count, to, retlen);
 623
 624         down_write(&c->wbuf_sem);
 625
 626         /* If wbuf_ofs is not initialized, set it to target address */
 627         if (c->wbuf_ofs == 0xFFFFFFFF) {
 628                 c->wbuf_ofs = PAGE_DIV(to);
 629                 c->wbuf_len = PAGE_MOD(to);
 630                 memset(c->wbuf,0xff,c->wbuf_pagesize);
 631         }
 632
 633         /* Fixup the wbuf if we are moving to a new eraseblock.  The checks below
 634            fail for ECC'd NOR because cleanmarker == 16, so a block starts at
 635            xxx0010.  */
 636         if (jffs2_nor_ecc(c)) {
 637                 if (((c->wbuf_ofs % c->sector_size) == 0) && !c->wbuf_len) {
 638                         c->wbuf_ofs = PAGE_DIV(to);
 639                         c->wbuf_len = PAGE_MOD(to);
 640                         memset(c->wbuf,0xff,c->wbuf_pagesize);
 641                 }
 642         }
 643
 644         /* Sanity checks on target address.
 645            It's permitted to write at PAD(c->wbuf_len+c->wbuf_ofs),
 646            and it's permitted to write at the beginning of a new
 647            erase block. Anything else, and you die.
 648            New block starts at xxx000c (0-b = block header)
 649         */
 650         if (SECTOR_ADDR(to) != SECTOR_ADDR(c->wbuf_ofs)) {
 651                 /* It's a write to a new block */
 652                 if (c->wbuf_len) {
 653                         D1(printk(KERN_DEBUG "jffs2_flash_writev() to 0x%lx causes flush of wbuf at 0x%08x\n", (unsigned long)to, c->wbuf_ofs));
 654                         ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
 655                         if (ret) {
 656                                 /* the underlying layer has to check wbuf_len to do the cleanup */
 657                                 D1(printk(KERN_WARNING "jffs2_flush_wbuf() called from jffs2_flash_writev() failed %d\n", ret));
 658                                 *retlen = 0;
 659                                 goto exit;
 660                         }
 661                 }
 662                 /* set pointer to new block */
 663                 c->wbuf_ofs = PAGE_DIV(to);
 664                 c->wbuf_len = PAGE_MOD(to);
 665         }
 666
 667         if (to != PAD(c->wbuf_ofs + c->wbuf_len)) {
 668                 /* We're not writing immediately after the writebuffer. Bad. */
 669                 printk(KERN_CRIT "jffs2_flash_writev(): Non-contiguous write to %08lx\n", (unsigned long)to);
 670                 if (c->wbuf_len)
 671                         printk(KERN_CRIT "wbuf was previously %08x-%08x\n",
 672                                           c->wbuf_ofs, c->wbuf_ofs+c->wbuf_len);
 673                 BUG();
 674         }
 675
 676         /* Note outvecs[3] above. We know count is never greater than 2 */
 677         if (count > 2) {
 678                 printk(KERN_CRIT "jffs2_flash_writev(): count is %ld\n", count);
 679                 BUG();
 680         }
 681
 682         invec = 0;
 683         outvec = 0;
 684
 685         /* Fill writebuffer first, if already in use */
 686         if (c->wbuf_len) {
 687                 uint32_t invec_ofs = 0;
 688
 689                 /* adjust alignment offset */
 690                 if (c->wbuf_len != PAGE_MOD(to)) {
 691                         c->wbuf_len = PAGE_MOD(to);
 692                         /* take care of alignment to next page */
 693                         if (!c->wbuf_len)
 694                                 c->wbuf_len = c->wbuf_pagesize;
 695                 }
 696
 697                 while(c->wbuf_len < c->wbuf_pagesize) {
 698                         uint32_t thislen;
 699
 700                         if (invec == count)
 701                                 goto alldone;
 702
 703                         thislen = c->wbuf_pagesize - c->wbuf_len;
 704
 705                         if (thislen >= invecs[invec].iov_len)
 706                                 thislen = invecs[invec].iov_len;
 707
 708                         invec_ofs = thislen;
 709
 710                         memcpy(c->wbuf + c->wbuf_len, invecs[invec].iov_base, thislen);
 711                         c->wbuf_len += thislen;
 712                         donelen += thislen;
 713                         /* Get next invec, if actual did not fill the buffer */
 714                         if (c->wbuf_len < c->wbuf_pagesize)
 715                                 invec++;
 716                 }
 717
 718                 /* write buffer is full, flush buffer */
 719                 ret = __jffs2_flush_wbuf(c, NOPAD);
 720                 if (ret) {
 721                         /* the underlying layer has to check wbuf_len to do the cleanup */
 722                         D1(printk(KERN_WARNING "jffs2_flush_wbuf() called from jffs2_flash_writev() failed %d\n", ret));
 723                         /* Retlen zero to make sure our caller doesn't mark the space dirty.
 724                            We've already done everything that's necessary */
 725                         *retlen = 0;
 726                         goto exit;
 727                 }
 728                 outvec_to += donelen;
 729                 c->wbuf_ofs = outvec_to;
 730
 731                 /* All invecs done ? */
 732                 if (invec == count)
 733                         goto alldone;
 734
 735                 /* Set up the first outvec, containing the remainder of the
 736                    invec we partially used */
 737                 if (invecs[invec].iov_len > invec_ofs) {
 738                         outvecs[0].iov_base = invecs[invec].iov_base+invec_ofs;
 739                         totlen = outvecs[0].iov_len = invecs[invec].iov_len-invec_ofs;
 740                         if (totlen > c->wbuf_pagesize) {
 741                                 splitvec = outvec;
 742                                 split_ofs = outvecs[0].iov_len - PAGE_MOD(totlen);
 743                         }
 744                         outvec++;
 745                 }
 746                 invec++;
 747         }
 748
 749         /* OK, now we've flushed the wbuf and the start of the bits
 750            we have been asked to write, now to write the rest.... */
 751
 752         /* totlen holds the amount of data still to be written */
 753         old_totlen = totlen;
 754         for ( ; invec < count; invec++,outvec++ ) {
 755                 outvecs[outvec].iov_base = invecs[invec].iov_base;
 756                 totlen += outvecs[outvec].iov_len = invecs[invec].iov_len;
 757                 if (PAGE_DIV(totlen) != PAGE_DIV(old_totlen)) {
 758                         splitvec = outvec;
 759                         split_ofs = outvecs[outvec].iov_len - PAGE_MOD(totlen);
 760                         old_totlen = totlen;
 761                 }
 762         }
 763
 764         /* Now the outvecs array holds all the remaining data to write */
 765         /* Up to splitvec,split_ofs is to be written immediately. The rest
 766            goes into the (now-empty) wbuf */
 767
 768         if (splitvec != -1) {
 769                 uint32_t remainder;
 770
 771                 remainder = outvecs[splitvec].iov_len - split_ofs;
 772                 outvecs[splitvec].iov_len = split_ofs;
 773
 774                 /* We did cross a page boundary, so we write some now */
 775                 if (jffs2_cleanmarker_oob(c))
 776                         ret = c->mtd->writev_ecc(c->mtd, outvecs, splitvec+1, outvec_to, &wbuf_retlen, NULL, c->oobinfo);
 777                 else
 778                         ret = jffs2_flash_direct_writev(c, outvecs, splitvec+1, outvec_to, &wbuf_retlen);
 779
 780                 if (ret < 0 || wbuf_retlen != PAGE_DIV(totlen)) {
 781                         /* At this point we have no problem,
 782                            c->wbuf is empty. However refile nextblock to avoid
 783                            writing again to same address.
 784                         */
 785                         struct jffs2_eraseblock *jeb;
 786
 787                         spin_lock(&c->erase_completion_lock);
 788
 789                         jeb = &c->blocks[outvec_to / c->sector_size];
 790                         jffs2_block_refile(c, jeb, REFILE_ANYWAY);
 791
 792                         *retlen = 0;
 793                         spin_unlock(&c->erase_completion_lock);
 794                         goto exit;
 795                 }
 796
 797                 donelen += wbuf_retlen;
 798                 c->wbuf_ofs = PAGE_DIV(outvec_to) + PAGE_DIV(totlen);
 799
 800                 if (remainder) {
 801                         outvecs[splitvec].iov_base += split_ofs;
 802                         outvecs[splitvec].iov_len = remainder;
 803                 } else {
 804                         splitvec++;
 805                 }
 806
 807         } else {
 808                 splitvec = 0;
 809         }
 810
 811         /* Now splitvec points to the start of the bits we have to copy
 812            into the wbuf */
 813         wbuf_ptr = c->wbuf;
 814
 815         for ( ; splitvec < outvec; splitvec++) {
 816                 /* Don't copy the wbuf into itself */
 817                 if (outvecs[splitvec].iov_base == c->wbuf)
 818                         continue;
 819                 memcpy(wbuf_ptr, outvecs[splitvec].iov_base, outvecs[splitvec].iov_len);
 820                 wbuf_ptr += outvecs[splitvec].iov_len;
 821                 donelen += outvecs[splitvec].iov_len;
 822         }
 823         c->wbuf_len = wbuf_ptr - c->wbuf;
 824
 825         /* If there's a remainder in the wbuf and it's a non-GC write,
 826            remember that the wbuf affects this ino */
 827 alldone:
 828         *retlen = donelen;
 829
 830         if (jffs2_sum_active()) {
 831                 int res = jffs2_sum_add_kvec(c, invecs, count, (uint32_t) to);
 832                 if (res)
 833                         return res;
 834         }
 835
 836         if (c->wbuf_len && ino)
 837                 jffs2_wbuf_dirties_inode(c, ino);
 838
 839         ret = 0;
 840
 841 exit:
 842         up_write(&c->wbuf_sem);
 843         return ret;
 844 }
 845
 846 /*
 847  *      This is the entry for flash write.
 848  *      Check, if we work on NAND FLASH, if so build an kvec and write it via vritev
 849 */
 850 int jffs2_flash_write(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, const u_char *buf)
 851 {
 852         struct kvec vecs[1];
 853
 854         if (!jffs2_is_writebuffered(c))
 855                 return jffs2_flash_direct_write(c, ofs, len, retlen, buf);
 856
 857         vecs[0].iov_base = (unsigned char *) buf;
 858         vecs[0].iov_len = len;
 859         return jffs2_flash_writev(c, vecs, 1, ofs, retlen, 0);
 860 }
 861
 862 /*
 863         Handle readback from writebuffer and ECC failure return
 864 */
 865 int jffs2_flash_read(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, u_char *buf)
 866 {
 867         loff_t  orbf = 0, owbf = 0, lwbf = 0;
 868         int     ret;
 869
 870         if (!jffs2_is_writebuffered(c))
 871                 return c->mtd->read(c->mtd, ofs, len, retlen, buf);
 872
 873         /* Read flash */
 874         down_read(&c->wbuf_sem);
 875         if (jffs2_cleanmarker_oob(c))
 876                 ret = c->mtd->read_ecc(c->mtd, ofs, len, retlen, buf, NULL, c->oobinfo);
 877         else
 878                 ret = c->mtd->read(c->mtd, ofs, len, retlen, buf);
 879
 880         if ( (ret == -EBADMSG) && (*retlen == len) ) {
 881                 printk(KERN_WARNING "mtd->read(0x%zx bytes from 0x%llx) returned ECC error\n",
 882                        len, ofs);
 883                 /*
 884                  * We have the raw data without ECC correction in the buffer, maybe
 885                  * we are lucky and all data or parts are correct. We check the node.
 886                  * If data are corrupted node check will sort it out.
 887                  * We keep this block, it will fail on write or erase and the we
 888                  * mark it bad. Or should we do that now? But we should give him a chance.
 889                  * Maybe we had a system crash or power loss before the ecc write or
 890                  * a erase was completed.
 891                  * So we return success. :)
 892                  */
 893                 ret = 0;
 894         }
 895
 896         /* if no writebuffer available or write buffer empty, return */
 897         if (!c->wbuf_pagesize || !c->wbuf_len)
 898                 goto exit;
 899
 900         /* if we read in a different block, return */
 901         if (SECTOR_ADDR(ofs) != SECTOR_ADDR(c->wbuf_ofs))
 902                 goto exit;
 903
 904         if (ofs >= c->wbuf_ofs) {
 905                 owbf = (ofs - c->wbuf_ofs);     /* offset in write buffer */
 906                 if (owbf > c->wbuf_len)         /* is read beyond write buffer ? */
 907                         goto exit;
 908                 lwbf = c->wbuf_len - owbf;      /* number of bytes to copy */
 909                 if (lwbf > len)
 910                         lwbf = len;
 911         } else {
 912                 orbf = (c->wbuf_ofs - ofs);     /* offset in read buffer */
 913                 if (orbf > len)                 /* is write beyond write buffer ? */
 914                         goto exit;
 915                 lwbf = len - orbf;              /* number of bytes to copy */
 916                 if (lwbf > c->wbuf_len)
 917                         lwbf = c->wbuf_len;
 918         }
 919         if (lwbf > 0)
 920                 memcpy(buf+orbf,c->wbuf+owbf,lwbf);
 921
 922 exit:
 923         up_read(&c->wbuf_sem);
 924         return ret;
 925 }
 926
 927 /*
 928  *      Check, if the out of band area is empty
 929  */
 930 int jffs2_check_oob_empty( struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int mode)
 931 {
 932         unsigned char *buf;
 933         int     ret = 0;
 934         int     i,len,page;
 935         size_t  retlen;
 936         int     oob_size;
 937
 938         /* allocate a buffer for all oob data in this sector */
 939         oob_size = c->mtd->oobsize;
 940         len = 4 * oob_size;
 941         buf = kmalloc(len, GFP_KERNEL);
 942         if (!buf) {
 943                 printk(KERN_NOTICE "jffs2_check_oob_empty(): allocation of temporary data buffer for oob check failed\n");
 944                 return -ENOMEM;
 945         }
 946         /*
 947          * if mode = 0, we scan for a total empty oob area, else we have
 948          * to take care of the cleanmarker in the first page of the block
 949         */
 950         ret = jffs2_flash_read_oob(c, jeb->offset, len , &retlen, buf);
 951         if (ret) {
 952                 D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB failed %d for block at %08x\n", ret, jeb->offset));
 953                 goto out;
 954         }
 955
 956         if (retlen < len) {
 957                 D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB return short read "
 958                           "(%zd bytes not %d) for block at %08x\n", retlen, len, jeb->offset));
 959                 ret = -EIO;
 960                 goto out;
 961         }
 962
 963         /* Special check for first page */
 964         for(i = 0; i < oob_size ; i++) {
 965                 /* Yeah, we know about the cleanmarker. */
 966                 if (mode && i >= c->fsdata_pos &&
 967                     i < c->fsdata_pos + c->fsdata_len)
 968                         continue;
 969
 970                 if (buf[i] != 0xFF) {
 971                         D2(printk(KERN_DEBUG "Found %02x at %x in OOB for %08x\n",
 972                                   buf[i], i, jeb->offset));
 973                         ret = 1;
 974                         goto out;
 975                 }
 976         }
 977
 978         /* we know, we are aligned :) */
 979         for (page = oob_size; page < len; page += sizeof(long)) {
 980                 unsigned long dat = *(unsigned long *)(&buf[page]);
 981                 if(dat != -1) {
 982                         ret = 1;
 983                         goto out;
 984                 }
 985         }
 986
 987 out:
 988         kfree(buf);
 989
 990         return ret;
 991 }
 992
 993 /*
 994 *       Scan for a valid cleanmarker and for bad blocks
 995 *       For virtual blocks (concatenated physical blocks) check the cleanmarker
 996 *       only in the first page of the first physical block, but scan for bad blocks in all
 997 *       physical blocks
 998 */
 999 int jffs2_check_nand_cleanmarker (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
1000 {
1001         struct jffs2_unknown_node n;
1002         unsigned char buf[2 * NAND_MAX_OOBSIZE];
1003         unsigned char *p;
1004         int ret, i, cnt, retval = 0;
1005         size_t retlen, offset;
1006         int oob_size;
1007
1008         offset = jeb->offset;
1009         oob_size = c->mtd->oobsize;
1010
1011         /* Loop through the physical blocks */
1012         for (cnt = 0; cnt < (c->sector_size / c->mtd->erasesize); cnt++) {
1013                 /* Check first if the block is bad. */
1014                 if (c->mtd->block_isbad (c->mtd, offset)) {
1015                         D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Bad block at %08x\n", jeb->offset));
1016                         return 2;
1017                 }
1018                 /*
1019                    *    We read oob data from page 0 and 1 of the block.
1020                    *    page 0 contains cleanmarker and badblock info
1021                    *    page 1 contains failure count of this block
1022                  */
1023                 ret = c->mtd->read_oob (c->mtd, offset, oob_size << 1, &retlen, buf);
1024
1025                 if (ret) {
1026                         D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Read OOB failed %d for block at %08x\n", ret, jeb->offset));
1027                         return ret;
1028                 }
1029                 if (retlen < (oob_size << 1)) {
1030                         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));
1031                         return -EIO;
1032                 }
1033
1034                 /* Check cleanmarker only on the first physical block */
1035                 if (!cnt) {
1036                         n.magic = cpu_to_je16 (JFFS2_MAGIC_BITMASK);
1037                         n.nodetype = cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER);
1038                         n.totlen = cpu_to_je32 (8);
1039                         p = (unsigned char *) &n;
1040
1041                         for (i = 0; i < c->fsdata_len; i++) {
1042                                 if (buf[c->fsdata_pos + i] != p[i]) {
1043                                         retval = 1;
1044                                 }
1045                         }
1046                         D1(if (retval == 1) {
1047                                 printk(KERN_WARNING "jffs2_check_nand_cleanmarker(): Cleanmarker node not detected in block at %08x\n", jeb->offset);
1048                                 printk(KERN_WARNING "OOB at %08x was ", offset);
1049                                 for (i=0; i < oob_size; i++) {
1050                                         printk("%02x ", buf[i]);
1051                                 }
1052                                 printk("\n");
1053                         })
1054                 }
1055                 offset += c->mtd->erasesize;
1056         }
1057         return retval;
1058 }
1059
1060 int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
1061 {
1062         struct  jffs2_unknown_node n;
1063         int     ret;
1064         size_t  retlen;
1065
1066         n.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
1067         n.nodetype = cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER);
1068         n.totlen = cpu_to_je32(8);
1069
1070         ret = jffs2_flash_write_oob(c, jeb->offset + c->fsdata_pos, c->fsdata_len, &retlen, (unsigned char *)&n);
1071
1072         if (ret) {
1073                 D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
1074                 return ret;
1075         }
1076         if (retlen != c->fsdata_len) {
1077                 D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): Short write for block at %08x: %zd not %d\n", jeb->offset, retlen, c->fsdata_len));
1078                 return ret;
1079         }
1080         return 0;
1081 }
1082
1083 /*
1084  * On NAND we try to mark this block bad. If the block was erased more
1085  * than MAX_ERASE_FAILURES we mark it finaly bad.
1086  * Don't care about failures. This block remains on the erase-pending
1087  * or badblock list as long as nobody manipulates the flash with
1088  * a bootloader or something like that.
1089  */
1090
1091 int jffs2_write_nand_badblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t bad_offset)
1092 {
1093         int     ret;
1094
1095         /* if the count is < max, we try to write the counter to the 2nd page oob area */
1096         if( ++jeb->bad_count < MAX_ERASE_FAILURES)
1097                 return 0;
1098
1099         if (!c->mtd->block_markbad)
1100                 return 1; // What else can we do?
1101
1102         D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Marking bad block at %08x\n", bad_offset));
1103         ret = c->mtd->block_markbad(c->mtd, bad_offset);
1104
1105         if (ret) {
1106                 D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
1107                 return ret;
1108         }
1109         return 1;
1110 }
1111
1112 #define NAND_JFFS2_OOB16_FSDALEN        8
1113
1114 static struct nand_oobinfo jffs2_oobinfo_docecc = {
1115         .useecc = MTD_NANDECC_PLACE,
1116         .eccbytes = 6,
1117         .eccpos = {0,1,2,3,4,5}
1118 };
1119
1120
1121 static int jffs2_nand_set_oobinfo(struct jffs2_sb_info *c)
1122 {
1123         struct nand_oobinfo *oinfo = &c->mtd->oobinfo;
1124
1125         /* Do this only, if we have an oob buffer */
1126         if (!c->mtd->oobsize)
1127                 return 0;
1128
1129         /* Cleanmarker is out-of-band, so inline size zero */
1130         c->cleanmarker_size = 0;
1131
1132         /* Should we use autoplacement ? */
1133         if (oinfo && oinfo->useecc == MTD_NANDECC_AUTOPLACE) {
1134                 D1(printk(KERN_DEBUG "JFFS2 using autoplace on NAND\n"));
1135                 /* Get the position of the free bytes */
1136                 if (!oinfo->oobfree[0][1]) {
1137                         printk (KERN_WARNING "jffs2_nand_set_oobinfo(): Eeep. Autoplacement selected and no empty space in oob\n");
1138                         return -ENOSPC;
1139                 }
1140                 c->fsdata_pos = oinfo->oobfree[0][0];
1141                 c->fsdata_len = oinfo->oobfree[0][1];
1142                 if (c->fsdata_len > 8)
1143                         c->fsdata_len = 8;
1144         } else {
1145                 /* This is just a legacy fallback and should go away soon */
1146                 switch(c->mtd->ecctype) {
1147                 case MTD_ECC_RS_DiskOnChip:
1148                         printk(KERN_WARNING "JFFS2 using DiskOnChip hardware ECC without autoplacement. Fix it!\n");
1149                         c->oobinfo = &jffs2_oobinfo_docecc;
1150                         c->fsdata_pos = 6;
1151                         c->fsdata_len = NAND_JFFS2_OOB16_FSDALEN;
1152                         c->badblock_pos = 15;
1153                         break;
1154
1155                 default:
1156                         D1(printk(KERN_DEBUG "JFFS2 on NAND. No autoplacment info found\n"));
1157                         return -EINVAL;
1158                 }
1159         }
1160         return 0;
1161 }
1162
1163 int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
1164 {
1165         int res;
1166
1167         /* Initialise write buffer */
1168         init_rwsem(&c->wbuf_sem);
1169         c->wbuf_pagesize = c->mtd->oobblock;
1170         c->wbuf_ofs = 0xFFFFFFFF;
1171
1172         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1173         if (!c->wbuf)
1174                 return -ENOMEM;
1175
1176         res = jffs2_nand_set_oobinfo(c);
1177
1178 #ifdef BREAKME
1179         if (!brokenbuf)
1180                 brokenbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1181         if (!brokenbuf) {
1182                 kfree(c->wbuf);
1183                 return -ENOMEM;
1184         }
1185         memset(brokenbuf, 0xdb, c->wbuf_pagesize);
1186 #endif
1187         return res;
1188 }
1189
1190 void jffs2_nand_flash_cleanup(struct jffs2_sb_info *c)
1191 {
1192         kfree(c->wbuf);
1193 }
1194
1195 int jffs2_dataflash_setup(struct jffs2_sb_info *c) {
1196         c->cleanmarker_size = 0;                /* No cleanmarkers needed */
1197
1198         /* Initialize write buffer */
1199         init_rwsem(&c->wbuf_sem);
1200
1201
1202         c->wbuf_pagesize =  c->mtd->erasesize;
1203
1204         /* Find a suitable c->sector_size
1205          * - Not too much sectors
1206          * - Sectors have to be at least 4 K + some bytes
1207          * - All known dataflashes have erase sizes of 528 or 1056
1208          * - we take at least 8 eraseblocks and want to have at least 8K size
1209          * - The concatenation should be a power of 2
1210         */
1211
1212         c->sector_size = 8 * c->mtd->erasesize;
1213
1214         while (c->sector_size < 8192) {
1215                 c->sector_size *= 2;
1216         }
1217
1218         /* It may be necessary to adjust the flash size */
1219         c->flash_size = c->mtd->size;
1220
1221         if ((c->flash_size % c->sector_size) != 0) {
1222                 c->flash_size = (c->flash_size / c->sector_size) * c->sector_size;
1223                 printk(KERN_WARNING "JFFS2 flash size adjusted to %dKiB\n", c->flash_size);
1224         };
1225
1226         c->wbuf_ofs = 0xFFFFFFFF;
1227         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1228         if (!c->wbuf)
1229                 return -ENOMEM;
1230
1231         printk(KERN_INFO "JFFS2 write-buffering enabled buffer (%d) erasesize (%d)\n", c->wbuf_pagesize, c->sector_size);
1232
1233         return 0;
1234 }
1235
1236 void jffs2_dataflash_cleanup(struct jffs2_sb_info *c) {
1237         kfree(c->wbuf);
1238 }
1239
1240 int jffs2_nor_ecc_flash_setup(struct jffs2_sb_info *c) {
1241         /* Cleanmarker is actually larger on the flashes */
1242         c->cleanmarker_size = 16;
1243
1244         /* Initialize write buffer */
1245         init_rwsem(&c->wbuf_sem);
1246         c->wbuf_pagesize = c->mtd->eccsize;
1247         c->wbuf_ofs = 0xFFFFFFFF;
1248
1249         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1250         if (!c->wbuf)
1251                 return -ENOMEM;
1252
1253         return 0;
1254 }
1255
1256 void jffs2_nor_ecc_flash_cleanup(struct jffs2_sb_info *c) {
1257         kfree(c->wbuf);
1258 }
1259
1260 int jffs2_nor_wbuf_flash_setup(struct jffs2_sb_info *c) {
1261         /* Cleanmarker currently occupies a whole programming region */
1262         c->cleanmarker_size = MTD_PROGREGION_SIZE(c->mtd);
1263
1264         /* Initialize write buffer */
1265         init_rwsem(&c->wbuf_sem);
1266         c->wbuf_pagesize = MTD_PROGREGION_SIZE(c->mtd);
1267         c->wbuf_ofs = 0xFFFFFFFF;
1268
1269         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1270         if (!c->wbuf)
1271                 return -ENOMEM;
1272
1273         return 0;
1274 }
1275
1276 void jffs2_nor_wbuf_flash_cleanup(struct jffs2_sb_info *c) {
1277         kfree(c->wbuf);
1278 }