git.oblomov.eu Git - linux-2.6/blob - fs/jffs2/wbuf.c

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