fs/jffs2/wbuf.c

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