[JFFS2] Debug code clean up - step 3
[linux-2.6.git] / 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.96 2005/07/22 10:32:08 dedekind Exp $
13  *
14  */
15
16 #include <linux/kernel.h>
17 #include <linux/slab.h>
18 #include <linux/mtd/mtd.h>
19 #include <linux/crc32.h>
20 #include <linux/mtd/nand.h>
21 #include <linux/jiffies.h>
22
23 #include "nodelist.h"
24
25 /* For testing write failures */
26 #undef BREAKME
27 #undef BREAKMEHEADER
28
29 #ifdef BREAKME
30 static unsigned char *brokenbuf;
31 #endif
32
33 /* max. erase failures before we mark a block bad */
34 #define MAX_ERASE_FAILURES      2
35
36 /* two seconds timeout for timed wbuf-flushing */
37 #define WBUF_FLUSH_TIMEOUT      2 * HZ
38
39 struct jffs2_inodirty {
40         uint32_t ino;
41         struct jffs2_inodirty *next;
42 };
43
44 static struct jffs2_inodirty inodirty_nomem;
45
46 static int jffs2_wbuf_pending_for_ino(struct jffs2_sb_info *c, uint32_t ino)
47 {
48         struct jffs2_inodirty *this = c->wbuf_inodes;
49
50         /* If a malloc failed, consider _everything_ dirty */
51         if (this == &inodirty_nomem)
52                 return 1;
53
54         /* If ino == 0, _any_ non-GC writes mean 'yes' */
55         if (this && !ino)
56                 return 1;
57
58         /* Look to see if the inode in question is pending in the wbuf */
59         while (this) {
60                 if (this->ino == ino)
61                         return 1;
62                 this = this->next;
63         }
64         return 0;
65 }
66
67 static void jffs2_clear_wbuf_ino_list(struct jffs2_sb_info *c)
68 {
69         struct jffs2_inodirty *this;
70
71         this = c->wbuf_inodes;
72
73         if (this != &inodirty_nomem) {
74                 while (this) {
75                         struct jffs2_inodirty *next = this->next;
76                         kfree(this);
77                         this = next;
78                 }
79         }
80         c->wbuf_inodes = NULL;
81 }
82
83 static void jffs2_wbuf_dirties_inode(struct jffs2_sb_info *c, uint32_t ino)
84 {
85         struct jffs2_inodirty *new;
86
87         /* Mark the superblock dirty so that kupdated will flush... */
88         jffs2_erase_pending_trigger(c);
89
90         if (jffs2_wbuf_pending_for_ino(c, ino))
91                 return;
92
93         new = kmalloc(sizeof(*new), GFP_KERNEL);
94         if (!new) {
95                 D1(printk(KERN_DEBUG "No memory to allocate inodirty. Fallback to all considered dirty\n"));
96                 jffs2_clear_wbuf_ino_list(c);
97                 c->wbuf_inodes = &inodirty_nomem;
98                 return;
99         }
100         new->ino = ino;
101         new->next = c->wbuf_inodes;
102         c->wbuf_inodes = new;
103         return;
104 }
105
106 static inline void jffs2_refile_wbuf_blocks(struct jffs2_sb_info *c)
107 {
108         struct list_head *this, *next;
109         static int n;
110
111         if (list_empty(&c->erasable_pending_wbuf_list))
112                 return;
113
114         list_for_each_safe(this, next, &c->erasable_pending_wbuf_list) {
115                 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
116
117                 D1(printk(KERN_DEBUG "Removing eraseblock at 0x%08x from erasable_pending_wbuf_list...\n", jeb->offset));
118                 list_del(this);
119                 if ((jiffies + (n++)) & 127) {
120                         /* Most of the time, we just erase it immediately. Otherwise we
121                            spend ages scanning it on mount, etc. */
122                         D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n"));
123                         list_add_tail(&jeb->list, &c->erase_pending_list);
124                         c->nr_erasing_blocks++;
125                         jffs2_erase_pending_trigger(c);
126                 } else {
127                         /* Sometimes, however, we leave it elsewhere so it doesn't get
128                            immediately reused, and we spread the load a bit. */
129                         D1(printk(KERN_DEBUG "...and adding to erasable_list\n"));
130                         list_add_tail(&jeb->list, &c->erasable_list);
131                 }
132         }
133 }
134
135 #define REFILE_NOTEMPTY 0
136 #define REFILE_ANYWAY   1
137
138 static void jffs2_block_refile(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int allow_empty)
139 {
140         D1(printk("About to refile bad block at %08x\n", jeb->offset));
141
142         /* 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);
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 && !jffs2_dataflash(c)) {
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 && !jffs2_dataflash(c)) {
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
608 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
609 #define PAGE_DIV(x) ( ((unsigned long)(x) / (unsigned long)(c->wbuf_pagesize)) * (unsigned long)(c->wbuf_pagesize) )
610 #define PAGE_MOD(x) ( (unsigned long)(x) % (unsigned long)(c->wbuf_pagesize) )
611 #else
612 #define PAGE_DIV(x) ( (x) & (~(c->wbuf_pagesize - 1)) )
613 #define PAGE_MOD(x) ( (x) & (c->wbuf_pagesize - 1) )
614 #endif
615
616 int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs, unsigned long count, loff_t to, size_t *retlen, uint32_t ino)
617 {
618         struct kvec outvecs[3];
619         uint32_t totlen = 0;
620         uint32_t split_ofs = 0;
621         uint32_t old_totlen;
622         int ret, splitvec = -1;
623         int invec, outvec;
624         size_t wbuf_retlen;
625         unsigned char *wbuf_ptr;
626         size_t donelen = 0;
627         uint32_t outvec_to = to;
628
629         /* If not NAND flash, don't bother */
630         if (!jffs2_is_writebuffered(c))
631                 return jffs2_flash_direct_writev(c, invecs, count, to, retlen);
632         
633         down_write(&c->wbuf_sem);
634
635         /* If wbuf_ofs is not initialized, set it to target address */
636         if (c->wbuf_ofs == 0xFFFFFFFF) {
637                 c->wbuf_ofs = PAGE_DIV(to);
638                 c->wbuf_len = PAGE_MOD(to);                     
639                 memset(c->wbuf,0xff,c->wbuf_pagesize);
640         }
641
642         /* Fixup the wbuf if we are moving to a new eraseblock.  The checks below
643            fail for ECC'd NOR because cleanmarker == 16, so a block starts at
644            xxx0010.  */
645         if (jffs2_nor_ecc(c)) {
646                 if (((c->wbuf_ofs % c->sector_size) == 0) && !c->wbuf_len) {
647                         c->wbuf_ofs = PAGE_DIV(to);
648                         c->wbuf_len = PAGE_MOD(to);
649                         memset(c->wbuf,0xff,c->wbuf_pagesize);
650                 }
651         }
652         
653         /* Sanity checks on target address. 
654            It's permitted to write at PAD(c->wbuf_len+c->wbuf_ofs), 
655            and it's permitted to write at the beginning of a new 
656            erase block. Anything else, and you die.
657            New block starts at xxx000c (0-b = block header)
658         */
659         if (SECTOR_ADDR(to) != SECTOR_ADDR(c->wbuf_ofs)) {
660                 /* It's a write to a new block */
661                 if (c->wbuf_len) {
662                         D1(printk(KERN_DEBUG "jffs2_flash_writev() to 0x%lx causes flush of wbuf at 0x%08x\n", (unsigned long)to, c->wbuf_ofs));
663                         ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
664                         if (ret) {
665                                 /* the underlying layer has to check wbuf_len to do the cleanup */
666                                 D1(printk(KERN_WARNING "jffs2_flush_wbuf() called from jffs2_flash_writev() failed %d\n", ret));
667                                 *retlen = 0;
668                                 goto exit;
669                         }
670                 }
671                 /* set pointer to new block */
672                 c->wbuf_ofs = PAGE_DIV(to);
673                 c->wbuf_len = PAGE_MOD(to);                     
674         } 
675
676         if (to != PAD(c->wbuf_ofs + c->wbuf_len)) {
677                 /* We're not writing immediately after the writebuffer. Bad. */
678                 printk(KERN_CRIT "jffs2_flash_writev(): Non-contiguous write to %08lx\n", (unsigned long)to);
679                 if (c->wbuf_len)
680                         printk(KERN_CRIT "wbuf was previously %08x-%08x\n",
681                                           c->wbuf_ofs, c->wbuf_ofs+c->wbuf_len);
682                 BUG();
683         }
684
685         /* Note outvecs[3] above. We know count is never greater than 2 */
686         if (count > 2) {
687                 printk(KERN_CRIT "jffs2_flash_writev(): count is %ld\n", count);
688                 BUG();
689         }
690
691         invec = 0;
692         outvec = 0;
693
694         /* Fill writebuffer first, if already in use */ 
695         if (c->wbuf_len) {
696                 uint32_t invec_ofs = 0;
697
698                 /* adjust alignment offset */ 
699                 if (c->wbuf_len != PAGE_MOD(to)) {
700                         c->wbuf_len = PAGE_MOD(to);
701                         /* take care of alignment to next page */
702                         if (!c->wbuf_len)
703                                 c->wbuf_len = c->wbuf_pagesize;
704                 }
705                 
706                 while(c->wbuf_len < c->wbuf_pagesize) {
707                         uint32_t thislen;
708                         
709                         if (invec == count)
710                                 goto alldone;
711
712                         thislen = c->wbuf_pagesize - c->wbuf_len;
713
714                         if (thislen >= invecs[invec].iov_len)
715                                 thislen = invecs[invec].iov_len;
716         
717                         invec_ofs = thislen;
718
719                         memcpy(c->wbuf + c->wbuf_len, invecs[invec].iov_base, thislen);
720                         c->wbuf_len += thislen;
721                         donelen += thislen;
722                         /* Get next invec, if actual did not fill the buffer */
723                         if (c->wbuf_len < c->wbuf_pagesize) 
724                                 invec++;
725                 }                       
726                 
727                 /* write buffer is full, flush buffer */
728                 ret = __jffs2_flush_wbuf(c, NOPAD);
729                 if (ret) {
730                         /* the underlying layer has to check wbuf_len to do the cleanup */
731                         D1(printk(KERN_WARNING "jffs2_flush_wbuf() called from jffs2_flash_writev() failed %d\n", ret));
732                         /* Retlen zero to make sure our caller doesn't mark the space dirty.
733                            We've already done everything that's necessary */
734                         *retlen = 0;
735                         goto exit;
736                 }
737                 outvec_to += donelen;
738                 c->wbuf_ofs = outvec_to;
739
740                 /* All invecs done ? */
741                 if (invec == count)
742                         goto alldone;
743
744                 /* Set up the first outvec, containing the remainder of the
745                    invec we partially used */
746                 if (invecs[invec].iov_len > invec_ofs) {
747                         outvecs[0].iov_base = invecs[invec].iov_base+invec_ofs;
748                         totlen = outvecs[0].iov_len = invecs[invec].iov_len-invec_ofs;
749                         if (totlen > c->wbuf_pagesize) {
750                                 splitvec = outvec;
751                                 split_ofs = outvecs[0].iov_len - PAGE_MOD(totlen);
752                         }
753                         outvec++;
754                 }
755                 invec++;
756         }
757
758         /* OK, now we've flushed the wbuf and the start of the bits
759            we have been asked to write, now to write the rest.... */
760
761         /* totlen holds the amount of data still to be written */
762         old_totlen = totlen;
763         for ( ; invec < count; invec++,outvec++ ) {
764                 outvecs[outvec].iov_base = invecs[invec].iov_base;
765                 totlen += outvecs[outvec].iov_len = invecs[invec].iov_len;
766                 if (PAGE_DIV(totlen) != PAGE_DIV(old_totlen)) {
767                         splitvec = outvec;
768                         split_ofs = outvecs[outvec].iov_len - PAGE_MOD(totlen);
769                         old_totlen = totlen;
770                 }
771         }
772
773         /* Now the outvecs array holds all the remaining data to write */
774         /* Up to splitvec,split_ofs is to be written immediately. The rest
775            goes into the (now-empty) wbuf */
776
777         if (splitvec != -1) {
778                 uint32_t remainder;
779
780                 remainder = outvecs[splitvec].iov_len - split_ofs;
781                 outvecs[splitvec].iov_len = split_ofs;
782
783                 /* We did cross a page boundary, so we write some now */
784                 if (jffs2_cleanmarker_oob(c))
785                         ret = c->mtd->writev_ecc(c->mtd, outvecs, splitvec+1, outvec_to, &wbuf_retlen, NULL, c->oobinfo); 
786                 else
787                         ret = jffs2_flash_direct_writev(c, outvecs, splitvec+1, outvec_to, &wbuf_retlen);
788                 
789                 if (ret < 0 || wbuf_retlen != PAGE_DIV(totlen)) {
790                         /* At this point we have no problem,
791                            c->wbuf is empty. However refile nextblock to avoid
792                            writing again to same address.
793                         */
794                         struct jffs2_eraseblock *jeb;
795
796                         spin_lock(&c->erase_completion_lock);
797
798                         jeb = &c->blocks[outvec_to / c->sector_size];
799                         jffs2_block_refile(c, jeb, REFILE_ANYWAY);
800
801                         *retlen = 0;
802                         spin_unlock(&c->erase_completion_lock);
803                         goto exit;
804                 }
805                 
806                 donelen += wbuf_retlen;
807                 c->wbuf_ofs = PAGE_DIV(outvec_to) + PAGE_DIV(totlen);
808
809                 if (remainder) {
810                         outvecs[splitvec].iov_base += split_ofs;
811                         outvecs[splitvec].iov_len = remainder;
812                 } else {
813                         splitvec++;
814                 }
815
816         } else {
817                 splitvec = 0;
818         }
819
820         /* Now splitvec points to the start of the bits we have to copy
821            into the wbuf */
822         wbuf_ptr = c->wbuf;
823
824         for ( ; splitvec < outvec; splitvec++) {
825                 /* Don't copy the wbuf into itself */
826                 if (outvecs[splitvec].iov_base == c->wbuf)
827                         continue;
828                 memcpy(wbuf_ptr, outvecs[splitvec].iov_base, outvecs[splitvec].iov_len);
829                 wbuf_ptr += outvecs[splitvec].iov_len;
830                 donelen += outvecs[splitvec].iov_len;
831         }
832         c->wbuf_len = wbuf_ptr - c->wbuf;
833
834         /* If there's a remainder in the wbuf and it's a non-GC write,
835            remember that the wbuf affects this ino */
836 alldone:
837         *retlen = donelen;
838
839         if (c->wbuf_len && ino)
840                 jffs2_wbuf_dirties_inode(c, ino);
841
842         ret = 0;
843         
844 exit:
845         up_write(&c->wbuf_sem);
846         return ret;
847 }
848
849 /*
850  *      This is the entry for flash write.
851  *      Check, if we work on NAND FLASH, if so build an kvec and write it via vritev
852 */
853 int jffs2_flash_write(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, const u_char *buf)
854 {
855         struct kvec vecs[1];
856
857         if (!jffs2_is_writebuffered(c))
858                 return c->mtd->write(c->mtd, ofs, len, retlen, buf);
859
860         vecs[0].iov_base = (unsigned char *) buf;
861         vecs[0].iov_len = len;
862         return jffs2_flash_writev(c, vecs, 1, ofs, retlen, 0);
863 }
864
865 /*
866         Handle readback from writebuffer and ECC failure return
867 */
868 int jffs2_flash_read(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, u_char *buf)
869 {
870         loff_t  orbf = 0, owbf = 0, lwbf = 0;
871         int     ret;
872
873         if (!jffs2_is_writebuffered(c))
874                 return c->mtd->read(c->mtd, ofs, len, retlen, buf);
875
876         /* Read flash */
877         down_read(&c->wbuf_sem);
878         if (jffs2_cleanmarker_oob(c))
879                 ret = c->mtd->read_ecc(c->mtd, ofs, len, retlen, buf, NULL, c->oobinfo);
880         else
881                 ret = c->mtd->read(c->mtd, ofs, len, retlen, buf);
882
883         if ( (ret == -EBADMSG) && (*retlen == len) ) {
884                 printk(KERN_WARNING "mtd->read(0x%zx bytes from 0x%llx) returned ECC error\n",
885                        len, ofs);
886                 /* 
887                  * We have the raw data without ECC correction in the buffer, maybe 
888                  * we are lucky and all data or parts are correct. We check the node.
889                  * If data are corrupted node check will sort it out.
890                  * We keep this block, it will fail on write or erase and the we
891                  * mark it bad. Or should we do that now? But we should give him a chance.
892                  * Maybe we had a system crash or power loss before the ecc write or  
893                  * a erase was completed.
894                  * So we return success. :)
895                  */
896                 ret = 0;
897         }       
898
899         /* if no writebuffer available or write buffer empty, return */
900         if (!c->wbuf_pagesize || !c->wbuf_len)
901                 goto exit;
902
903         /* if we read in a different block, return */
904         if (SECTOR_ADDR(ofs) != SECTOR_ADDR(c->wbuf_ofs))
905                 goto exit;
906
907         if (ofs >= c->wbuf_ofs) {
908                 owbf = (ofs - c->wbuf_ofs);     /* offset in write buffer */
909                 if (owbf > c->wbuf_len)         /* is read beyond write buffer ? */
910                         goto exit;
911                 lwbf = c->wbuf_len - owbf;      /* number of bytes to copy */
912                 if (lwbf > len) 
913                         lwbf = len;
914         } else {        
915                 orbf = (c->wbuf_ofs - ofs);     /* offset in read buffer */
916                 if (orbf > len)                 /* is write beyond write buffer ? */
917                         goto exit;
918                 lwbf = len - orbf;              /* number of bytes to copy */
919                 if (lwbf > c->wbuf_len) 
920                         lwbf = c->wbuf_len;
921         }       
922         if (lwbf > 0)
923                 memcpy(buf+orbf,c->wbuf+owbf,lwbf);
924
925 exit:
926         up_read(&c->wbuf_sem);
927         return ret;
928 }
929
930 /*
931  *      Check, if the out of band area is empty
932  */
933 int jffs2_check_oob_empty( struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int mode)
934 {
935         unsigned char *buf;
936         int     ret = 0;
937         int     i,len,page;
938         size_t  retlen;
939         int     oob_size;
940
941         /* allocate a buffer for all oob data in this sector */
942         oob_size = c->mtd->oobsize;
943         len = 4 * oob_size;
944         buf = kmalloc(len, GFP_KERNEL);
945         if (!buf) {
946                 printk(KERN_NOTICE "jffs2_check_oob_empty(): allocation of temporary data buffer for oob check failed\n");
947                 return -ENOMEM;
948         }
949         /* 
950          * if mode = 0, we scan for a total empty oob area, else we have
951          * to take care of the cleanmarker in the first page of the block
952         */
953         ret = jffs2_flash_read_oob(c, jeb->offset, len , &retlen, buf);
954         if (ret) {
955                 D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB failed %d for block at %08x\n", ret, jeb->offset));
956                 goto out;
957         }
958         
959         if (retlen < len) {
960                 D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB return short read "
961                           "(%zd bytes not %d) for block at %08x\n", retlen, len, jeb->offset));
962                 ret = -EIO;
963                 goto out;
964         }
965         
966         /* Special check for first page */
967         for(i = 0; i < oob_size ; i++) {
968                 /* Yeah, we know about the cleanmarker. */
969                 if (mode && i >= c->fsdata_pos && 
970                     i < c->fsdata_pos + c->fsdata_len)
971                         continue;
972
973                 if (buf[i] != 0xFF) {
974                         D2(printk(KERN_DEBUG "Found %02x at %x in OOB for %08x\n",
975                                   buf[i], i, jeb->offset));
976                         ret = 1; 
977                         goto out;
978                 }
979         }
980
981         /* we know, we are aligned :) */        
982         for (page = oob_size; page < len; page += sizeof(long)) {
983                 unsigned long dat = *(unsigned long *)(&buf[page]);
984                 if(dat != -1) {
985                         ret = 1; 
986                         goto out;
987                 }
988         }
989
990 out:
991         kfree(buf);     
992         
993         return ret;
994 }
995
996 /*
997 *       Scan for a valid cleanmarker and for bad blocks
998 *       For virtual blocks (concatenated physical blocks) check the cleanmarker
999 *       only in the first page of the first physical block, but scan for bad blocks in all
1000 *       physical blocks
1001 */
1002 int jffs2_check_nand_cleanmarker (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
1003 {
1004         struct jffs2_unknown_node n;
1005         unsigned char buf[2 * NAND_MAX_OOBSIZE];
1006         unsigned char *p;
1007         int ret, i, cnt, retval = 0;
1008         size_t retlen, offset;
1009         int oob_size;
1010
1011         offset = jeb->offset;
1012         oob_size = c->mtd->oobsize;
1013
1014         /* Loop through the physical blocks */
1015         for (cnt = 0; cnt < (c->sector_size / c->mtd->erasesize); cnt++) {
1016                 /* Check first if the block is bad. */
1017                 if (c->mtd->block_isbad (c->mtd, offset)) {
1018                         D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Bad block at %08x\n", jeb->offset));
1019                         return 2;
1020                 }
1021                 /*
1022                    *    We read oob data from page 0 and 1 of the block.
1023                    *    page 0 contains cleanmarker and badblock info
1024                    *    page 1 contains failure count of this block
1025                  */
1026                 ret = c->mtd->read_oob (c->mtd, offset, oob_size << 1, &retlen, buf);
1027
1028                 if (ret) {
1029                         D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Read OOB failed %d for block at %08x\n", ret, jeb->offset));
1030                         return ret;
1031                 }
1032                 if (retlen < (oob_size << 1)) {
1033                         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));
1034                         return -EIO;
1035                 }
1036
1037                 /* Check cleanmarker only on the first physical block */
1038                 if (!cnt) {
1039                         n.magic = cpu_to_je16 (JFFS2_MAGIC_BITMASK);
1040                         n.nodetype = cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER);
1041                         n.totlen = cpu_to_je32 (8);
1042                         p = (unsigned char *) &n;
1043
1044                         for (i = 0; i < c->fsdata_len; i++) {
1045                                 if (buf[c->fsdata_pos + i] != p[i]) {
1046                                         retval = 1;
1047                                 }
1048                         }
1049                         D1(if (retval == 1) {
1050                                 printk(KERN_WARNING "jffs2_check_nand_cleanmarker(): Cleanmarker node not detected in block at %08x\n", jeb->offset);
1051                                 printk(KERN_WARNING "OOB at %08x was ", offset);
1052                                 for (i=0; i < oob_size; i++) {
1053                                         printk("%02x ", buf[i]);
1054                                 }
1055                                 printk("\n");
1056                         })
1057                 }
1058                 offset += c->mtd->erasesize;
1059         }
1060         return retval;
1061 }
1062
1063 int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
1064 {
1065         struct  jffs2_unknown_node n;
1066         int     ret;
1067         size_t  retlen;
1068
1069         n.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
1070         n.nodetype = cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER);
1071         n.totlen = cpu_to_je32(8);
1072
1073         ret = jffs2_flash_write_oob(c, jeb->offset + c->fsdata_pos, c->fsdata_len, &retlen, (unsigned char *)&n);
1074         
1075         if (ret) {
1076                 D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
1077                 return ret;
1078         }
1079         if (retlen != c->fsdata_len) {
1080                 D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): Short write for block at %08x: %zd not %d\n", jeb->offset, retlen, c->fsdata_len));
1081                 return ret;
1082         }
1083         return 0;
1084 }
1085
1086 /* 
1087  * On NAND we try to mark this block bad. If the block was erased more
1088  * than MAX_ERASE_FAILURES we mark it finaly bad.
1089  * Don't care about failures. This block remains on the erase-pending
1090  * or badblock list as long as nobody manipulates the flash with
1091  * a bootloader or something like that.
1092  */
1093
1094 int jffs2_write_nand_badblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t bad_offset)
1095 {
1096         int     ret;
1097
1098         /* if the count is < max, we try to write the counter to the 2nd page oob area */
1099         if( ++jeb->bad_count < MAX_ERASE_FAILURES)
1100                 return 0;
1101
1102         if (!c->mtd->block_markbad)
1103                 return 1; // What else can we do?
1104
1105         D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Marking bad block at %08x\n", bad_offset));
1106         ret = c->mtd->block_markbad(c->mtd, bad_offset);
1107         
1108         if (ret) {
1109                 D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
1110                 return ret;
1111         }
1112         return 1;
1113 }
1114
1115 #define NAND_JFFS2_OOB16_FSDALEN        8
1116
1117 static struct nand_oobinfo jffs2_oobinfo_docecc = {
1118         .useecc = MTD_NANDECC_PLACE,
1119         .eccbytes = 6,
1120         .eccpos = {0,1,2,3,4,5}
1121 };
1122
1123
1124 static int jffs2_nand_set_oobinfo(struct jffs2_sb_info *c)
1125 {
1126         struct nand_oobinfo *oinfo = &c->mtd->oobinfo;
1127
1128         /* Do this only, if we have an oob buffer */
1129         if (!c->mtd->oobsize)
1130                 return 0;
1131         
1132         /* Cleanmarker is out-of-band, so inline size zero */
1133         c->cleanmarker_size = 0;
1134
1135         /* Should we use autoplacement ? */
1136         if (oinfo && oinfo->useecc == MTD_NANDECC_AUTOPLACE) {
1137                 D1(printk(KERN_DEBUG "JFFS2 using autoplace on NAND\n"));
1138                 /* Get the position of the free bytes */
1139                 if (!oinfo->oobfree[0][1]) {
1140                         printk (KERN_WARNING "jffs2_nand_set_oobinfo(): Eeep. Autoplacement selected and no empty space in oob\n");
1141                         return -ENOSPC;
1142                 }
1143                 c->fsdata_pos = oinfo->oobfree[0][0];
1144                 c->fsdata_len = oinfo->oobfree[0][1];
1145                 if (c->fsdata_len > 8)
1146                         c->fsdata_len = 8;
1147         } else {
1148                 /* This is just a legacy fallback and should go away soon */
1149                 switch(c->mtd->ecctype) {
1150                 case MTD_ECC_RS_DiskOnChip:
1151                         printk(KERN_WARNING "JFFS2 using DiskOnChip hardware ECC without autoplacement. Fix it!\n");
1152                         c->oobinfo = &jffs2_oobinfo_docecc;
1153                         c->fsdata_pos = 6;
1154                         c->fsdata_len = NAND_JFFS2_OOB16_FSDALEN;
1155                         c->badblock_pos = 15;
1156                         break;
1157         
1158                 default:
1159                         D1(printk(KERN_DEBUG "JFFS2 on NAND. No autoplacment info found\n"));
1160                         return -EINVAL;
1161                 }
1162         }
1163         return 0;
1164 }
1165
1166 int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
1167 {
1168         int res;
1169
1170         /* Initialise write buffer */
1171         init_rwsem(&c->wbuf_sem);
1172         c->wbuf_pagesize = c->mtd->oobblock;
1173         c->wbuf_ofs = 0xFFFFFFFF;
1174         
1175         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1176         if (!c->wbuf)
1177                 return -ENOMEM;
1178
1179         res = jffs2_nand_set_oobinfo(c);
1180
1181 #ifdef BREAKME
1182         if (!brokenbuf)
1183                 brokenbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1184         if (!brokenbuf) {
1185                 kfree(c->wbuf);
1186                 return -ENOMEM;
1187         }
1188         memset(brokenbuf, 0xdb, c->wbuf_pagesize);
1189 #endif
1190         return res;
1191 }
1192
1193 void jffs2_nand_flash_cleanup(struct jffs2_sb_info *c)
1194 {
1195         kfree(c->wbuf);
1196 }
1197
1198 int jffs2_dataflash_setup(struct jffs2_sb_info *c) {
1199         c->cleanmarker_size = 0;                /* No cleanmarkers needed */
1200         
1201         /* Initialize write buffer */
1202         init_rwsem(&c->wbuf_sem);
1203         c->wbuf_pagesize = c->sector_size;
1204         c->wbuf_ofs = 0xFFFFFFFF;
1205
1206         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1207         if (!c->wbuf)
1208                 return -ENOMEM;
1209
1210         printk(KERN_INFO "JFFS2 write-buffering enabled (%i)\n", c->wbuf_pagesize);
1211
1212         return 0;
1213 }
1214
1215 void jffs2_dataflash_cleanup(struct jffs2_sb_info *c) {
1216         kfree(c->wbuf);
1217 }
1218
1219 int jffs2_nor_ecc_flash_setup(struct jffs2_sb_info *c) {
1220         /* Cleanmarker is actually larger on the flashes */
1221         c->cleanmarker_size = 16;
1222
1223         /* Initialize write buffer */
1224         init_rwsem(&c->wbuf_sem);
1225         c->wbuf_pagesize = c->mtd->eccsize;
1226         c->wbuf_ofs = 0xFFFFFFFF;
1227
1228         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1229         if (!c->wbuf)
1230                 return -ENOMEM;
1231
1232         return 0;
1233 }
1234
1235 void jffs2_nor_ecc_flash_cleanup(struct jffs2_sb_info *c) {
1236         kfree(c->wbuf);
1237 }