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