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