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