2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright (C) 2001-2003 Red Hat, Inc.
6 * Created by David Woodhouse <dwmw2@infradead.org>
8 * For licensing information, see the file 'LICENCE' in this directory.
10 * $Id: fs.c,v 1.62 2005/08/06 04:51:30 nico Exp $
14 #include <linux/config.h>
15 #include <linux/kernel.h>
16 #include <linux/sched.h>
18 #include <linux/list.h>
19 #include <linux/mtd/mtd.h>
20 #include <linux/pagemap.h>
21 #include <linux/slab.h>
22 #include <linux/vmalloc.h>
23 #include <linux/vfs.h>
24 #include <linux/crc32.h>
27 static int jffs2_flash_setup(struct jffs2_sb_info
*c
);
29 static int jffs2_do_setattr (struct inode
*inode
, struct iattr
*iattr
)
31 struct jffs2_full_dnode
*old_metadata
, *new_metadata
;
32 struct jffs2_inode_info
*f
= JFFS2_INODE_INFO(inode
);
33 struct jffs2_sb_info
*c
= JFFS2_SB_INFO(inode
->i_sb
);
34 struct jffs2_raw_inode
*ri
;
36 unsigned char *mdata
= NULL
;
39 uint32_t phys_ofs
, alloclen
;
41 D1(printk(KERN_DEBUG
"jffs2_setattr(): ino #%lu\n", inode
->i_ino
));
42 ret
= inode_change_ok(inode
, iattr
);
46 /* Special cases - we don't want more than one data node
47 for these types on the medium at any time. So setattr
48 must read the original data associated with the node
49 (i.e. the device numbers or the target name) and write
50 it out again with the appropriate data attached */
51 if (S_ISBLK(inode
->i_mode
) || S_ISCHR(inode
->i_mode
)) {
52 /* For these, we don't actually need to read the old node */
53 dev
= old_encode_dev(inode
->i_rdev
);
55 mdatalen
= sizeof(dev
);
56 D1(printk(KERN_DEBUG
"jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen
));
57 } else if (S_ISLNK(inode
->i_mode
)) {
58 mdatalen
= f
->metadata
->size
;
59 mdata
= kmalloc(f
->metadata
->size
, GFP_USER
);
62 ret
= jffs2_read_dnode(c
, f
, f
->metadata
, mdata
, 0, mdatalen
);
67 D1(printk(KERN_DEBUG
"jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen
));
70 ri
= jffs2_alloc_raw_inode();
72 if (S_ISLNK(inode
->i_mode
))
77 ret
= jffs2_reserve_space(c
, sizeof(*ri
) + mdatalen
, &phys_ofs
, &alloclen
, ALLOC_NORMAL
);
79 jffs2_free_raw_inode(ri
);
80 if (S_ISLNK(inode
->i_mode
& S_IFMT
))
85 ivalid
= iattr
->ia_valid
;
87 ri
->magic
= cpu_to_je16(JFFS2_MAGIC_BITMASK
);
88 ri
->nodetype
= cpu_to_je16(JFFS2_NODETYPE_INODE
);
89 ri
->totlen
= cpu_to_je32(sizeof(*ri
) + mdatalen
);
90 ri
->hdr_crc
= cpu_to_je32(crc32(0, ri
, sizeof(struct jffs2_unknown_node
)-4));
92 ri
->ino
= cpu_to_je32(inode
->i_ino
);
93 ri
->version
= cpu_to_je32(++f
->highest_version
);
95 ri
->uid
= cpu_to_je16((ivalid
& ATTR_UID
)?iattr
->ia_uid
:inode
->i_uid
);
96 ri
->gid
= cpu_to_je16((ivalid
& ATTR_GID
)?iattr
->ia_gid
:inode
->i_gid
);
98 if (ivalid
& ATTR_MODE
)
99 if (iattr
->ia_mode
& S_ISGID
&&
100 !in_group_p(je16_to_cpu(ri
->gid
)) && !capable(CAP_FSETID
))
101 ri
->mode
= cpu_to_jemode(iattr
->ia_mode
& ~S_ISGID
);
103 ri
->mode
= cpu_to_jemode(iattr
->ia_mode
);
105 ri
->mode
= cpu_to_jemode(inode
->i_mode
);
108 ri
->isize
= cpu_to_je32((ivalid
& ATTR_SIZE
)?iattr
->ia_size
:inode
->i_size
);
109 ri
->atime
= cpu_to_je32(I_SEC((ivalid
& ATTR_ATIME
)?iattr
->ia_atime
:inode
->i_atime
));
110 ri
->mtime
= cpu_to_je32(I_SEC((ivalid
& ATTR_MTIME
)?iattr
->ia_mtime
:inode
->i_mtime
));
111 ri
->ctime
= cpu_to_je32(I_SEC((ivalid
& ATTR_CTIME
)?iattr
->ia_ctime
:inode
->i_ctime
));
113 ri
->offset
= cpu_to_je32(0);
114 ri
->csize
= ri
->dsize
= cpu_to_je32(mdatalen
);
115 ri
->compr
= JFFS2_COMPR_NONE
;
116 if (ivalid
& ATTR_SIZE
&& inode
->i_size
< iattr
->ia_size
) {
117 /* It's an extension. Make it a hole node */
118 ri
->compr
= JFFS2_COMPR_ZERO
;
119 ri
->dsize
= cpu_to_je32(iattr
->ia_size
- inode
->i_size
);
120 ri
->offset
= cpu_to_je32(inode
->i_size
);
122 ri
->node_crc
= cpu_to_je32(crc32(0, ri
, sizeof(*ri
)-8));
124 ri
->data_crc
= cpu_to_je32(crc32(0, mdata
, mdatalen
));
126 ri
->data_crc
= cpu_to_je32(0);
128 new_metadata
= jffs2_write_dnode(c
, f
, ri
, mdata
, mdatalen
, phys_ofs
, ALLOC_NORMAL
);
129 if (S_ISLNK(inode
->i_mode
))
132 if (IS_ERR(new_metadata
)) {
133 jffs2_complete_reservation(c
);
134 jffs2_free_raw_inode(ri
);
136 return PTR_ERR(new_metadata
);
138 /* It worked. Update the inode */
139 inode
->i_atime
= ITIME(je32_to_cpu(ri
->atime
));
140 inode
->i_ctime
= ITIME(je32_to_cpu(ri
->ctime
));
141 inode
->i_mtime
= ITIME(je32_to_cpu(ri
->mtime
));
142 inode
->i_mode
= jemode_to_cpu(ri
->mode
);
143 inode
->i_uid
= je16_to_cpu(ri
->uid
);
144 inode
->i_gid
= je16_to_cpu(ri
->gid
);
147 old_metadata
= f
->metadata
;
149 if (ivalid
& ATTR_SIZE
&& inode
->i_size
> iattr
->ia_size
)
150 jffs2_truncate_fragtree (c
, &f
->fragtree
, iattr
->ia_size
);
152 if (ivalid
& ATTR_SIZE
&& inode
->i_size
< iattr
->ia_size
) {
153 jffs2_add_full_dnode_to_inode(c
, f
, new_metadata
);
154 inode
->i_size
= iattr
->ia_size
;
157 f
->metadata
= new_metadata
;
160 jffs2_mark_node_obsolete(c
, old_metadata
->raw
);
161 jffs2_free_full_dnode(old_metadata
);
163 jffs2_free_raw_inode(ri
);
166 jffs2_complete_reservation(c
);
168 /* We have to do the vmtruncate() without f->sem held, since
169 some pages may be locked and waiting for it in readpage().
170 We are protected from a simultaneous write() extending i_size
171 back past iattr->ia_size, because do_truncate() holds the
172 generic inode semaphore. */
173 if (ivalid
& ATTR_SIZE
&& inode
->i_size
> iattr
->ia_size
)
174 vmtruncate(inode
, iattr
->ia_size
);
179 int jffs2_setattr(struct dentry
*dentry
, struct iattr
*iattr
)
181 return jffs2_do_setattr(dentry
->d_inode
, iattr
);
184 int jffs2_statfs(struct super_block
*sb
, struct kstatfs
*buf
)
186 struct jffs2_sb_info
*c
= JFFS2_SB_INFO(sb
);
189 buf
->f_type
= JFFS2_SUPER_MAGIC
;
190 buf
->f_bsize
= 1 << PAGE_SHIFT
;
191 buf
->f_blocks
= c
->flash_size
>> PAGE_SHIFT
;
194 buf
->f_namelen
= JFFS2_MAX_NAME_LEN
;
196 spin_lock(&c
->erase_completion_lock
);
197 avail
= c
->dirty_size
+ c
->free_size
;
198 if (avail
> c
->sector_size
* c
->resv_blocks_write
)
199 avail
-= c
->sector_size
* c
->resv_blocks_write
;
202 spin_unlock(&c
->erase_completion_lock
);
204 buf
->f_bavail
= buf
->f_bfree
= avail
>> PAGE_SHIFT
;
210 void jffs2_clear_inode (struct inode
*inode
)
212 /* We can forget about this inode for now - drop all
213 * the nodelists associated with it, etc.
215 struct jffs2_sb_info
*c
= JFFS2_SB_INFO(inode
->i_sb
);
216 struct jffs2_inode_info
*f
= JFFS2_INODE_INFO(inode
);
218 D1(printk(KERN_DEBUG
"jffs2_clear_inode(): ino #%lu mode %o\n", inode
->i_ino
, inode
->i_mode
));
220 jffs2_do_clear_inode(c
, f
);
223 void jffs2_read_inode (struct inode
*inode
)
225 struct jffs2_inode_info
*f
;
226 struct jffs2_sb_info
*c
;
227 struct jffs2_raw_inode latest_node
;
230 D1(printk(KERN_DEBUG
"jffs2_read_inode(): inode->i_ino == %lu\n", inode
->i_ino
));
232 f
= JFFS2_INODE_INFO(inode
);
233 c
= JFFS2_SB_INFO(inode
->i_sb
);
235 jffs2_init_inode_info(f
);
237 ret
= jffs2_do_read_inode(c
, f
, inode
->i_ino
, &latest_node
);
240 make_bad_inode(inode
);
244 inode
->i_mode
= jemode_to_cpu(latest_node
.mode
);
245 inode
->i_uid
= je16_to_cpu(latest_node
.uid
);
246 inode
->i_gid
= je16_to_cpu(latest_node
.gid
);
247 inode
->i_size
= je32_to_cpu(latest_node
.isize
);
248 inode
->i_atime
= ITIME(je32_to_cpu(latest_node
.atime
));
249 inode
->i_mtime
= ITIME(je32_to_cpu(latest_node
.mtime
));
250 inode
->i_ctime
= ITIME(je32_to_cpu(latest_node
.ctime
));
252 inode
->i_nlink
= f
->inocache
->nlink
;
254 inode
->i_blksize
= PAGE_SIZE
;
255 inode
->i_blocks
= (inode
->i_size
+ 511) >> 9;
257 switch (inode
->i_mode
& S_IFMT
) {
261 inode
->i_op
= &jffs2_symlink_inode_operations
;
266 struct jffs2_full_dirent
*fd
;
268 for (fd
=f
->dents
; fd
; fd
= fd
->next
) {
269 if (fd
->type
== DT_DIR
&& fd
->ino
)
274 /* Root dir gets i_nlink 3 for some reason */
275 if (inode
->i_ino
== 1)
278 inode
->i_op
= &jffs2_dir_inode_operations
;
279 inode
->i_fop
= &jffs2_dir_operations
;
283 inode
->i_op
= &jffs2_file_inode_operations
;
284 inode
->i_fop
= &jffs2_file_operations
;
285 inode
->i_mapping
->a_ops
= &jffs2_file_address_operations
;
286 inode
->i_mapping
->nrpages
= 0;
291 /* Read the device numbers from the media */
292 D1(printk(KERN_DEBUG
"Reading device numbers from flash\n"));
293 if (jffs2_read_dnode(c
, f
, f
->metadata
, (char *)&rdev
, 0, sizeof(rdev
)) < 0) {
295 printk(KERN_NOTICE
"Read device numbers for inode %lu failed\n", (unsigned long)inode
->i_ino
);
297 jffs2_do_clear_inode(c
, f
);
298 make_bad_inode(inode
);
304 inode
->i_op
= &jffs2_file_inode_operations
;
305 init_special_inode(inode
, inode
->i_mode
,
306 old_decode_dev((je16_to_cpu(rdev
))));
310 printk(KERN_WARNING
"jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode
->i_mode
, (unsigned long)inode
->i_ino
);
315 D1(printk(KERN_DEBUG
"jffs2_read_inode() returning\n"));
318 void jffs2_dirty_inode(struct inode
*inode
)
322 if (!(inode
->i_state
& I_DIRTY_DATASYNC
)) {
323 D2(printk(KERN_DEBUG
"jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode
->i_ino
));
327 D1(printk(KERN_DEBUG
"jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode
->i_ino
));
329 iattr
.ia_valid
= ATTR_MODE
|ATTR_UID
|ATTR_GID
|ATTR_ATIME
|ATTR_MTIME
|ATTR_CTIME
;
330 iattr
.ia_mode
= inode
->i_mode
;
331 iattr
.ia_uid
= inode
->i_uid
;
332 iattr
.ia_gid
= inode
->i_gid
;
333 iattr
.ia_atime
= inode
->i_atime
;
334 iattr
.ia_mtime
= inode
->i_mtime
;
335 iattr
.ia_ctime
= inode
->i_ctime
;
337 jffs2_do_setattr(inode
, &iattr
);
340 int jffs2_remount_fs (struct super_block
*sb
, int *flags
, char *data
)
342 struct jffs2_sb_info
*c
= JFFS2_SB_INFO(sb
);
344 if (c
->flags
& JFFS2_SB_FLAG_RO
&& !(sb
->s_flags
& MS_RDONLY
))
347 /* We stop if it was running, then restart if it needs to.
348 This also catches the case where it was stopped and this
349 is just a remount to restart it.
350 Flush the writebuffer, if neccecary, else we loose it */
351 if (!(sb
->s_flags
& MS_RDONLY
)) {
352 jffs2_stop_garbage_collect_thread(c
);
354 jffs2_flush_wbuf_pad(c
);
358 if (!(*flags
& MS_RDONLY
))
359 jffs2_start_garbage_collect_thread(c
);
361 *flags
|= MS_NOATIME
;
366 void jffs2_write_super (struct super_block
*sb
)
368 struct jffs2_sb_info
*c
= JFFS2_SB_INFO(sb
);
371 if (sb
->s_flags
& MS_RDONLY
)
374 D1(printk(KERN_DEBUG
"jffs2_write_super()\n"));
375 jffs2_garbage_collect_trigger(c
);
376 jffs2_erase_pending_blocks(c
, 0);
377 jffs2_flush_wbuf_gc(c
, 0);
381 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
382 fill in the raw_inode while you're at it. */
383 struct inode
*jffs2_new_inode (struct inode
*dir_i
, int mode
, struct jffs2_raw_inode
*ri
)
386 struct super_block
*sb
= dir_i
->i_sb
;
387 struct jffs2_sb_info
*c
;
388 struct jffs2_inode_info
*f
;
391 D1(printk(KERN_DEBUG
"jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i
->i_ino
, mode
));
393 c
= JFFS2_SB_INFO(sb
);
395 inode
= new_inode(sb
);
398 return ERR_PTR(-ENOMEM
);
400 f
= JFFS2_INODE_INFO(inode
);
401 jffs2_init_inode_info(f
);
403 memset(ri
, 0, sizeof(*ri
));
404 /* Set OS-specific defaults for new inodes */
405 ri
->uid
= cpu_to_je16(current
->fsuid
);
407 if (dir_i
->i_mode
& S_ISGID
) {
408 ri
->gid
= cpu_to_je16(dir_i
->i_gid
);
412 ri
->gid
= cpu_to_je16(current
->fsgid
);
414 ri
->mode
= cpu_to_jemode(mode
);
415 ret
= jffs2_do_new_inode (c
, f
, mode
, ri
);
417 make_bad_inode(inode
);
422 inode
->i_ino
= je32_to_cpu(ri
->ino
);
423 inode
->i_mode
= jemode_to_cpu(ri
->mode
);
424 inode
->i_gid
= je16_to_cpu(ri
->gid
);
425 inode
->i_uid
= je16_to_cpu(ri
->uid
);
426 inode
->i_atime
= inode
->i_ctime
= inode
->i_mtime
= CURRENT_TIME_SEC
;
427 ri
->atime
= ri
->mtime
= ri
->ctime
= cpu_to_je32(I_SEC(inode
->i_mtime
));
429 inode
->i_blksize
= PAGE_SIZE
;
433 insert_inode_hash(inode
);
439 int jffs2_do_fill_super(struct super_block
*sb
, void *data
, int silent
)
441 struct jffs2_sb_info
*c
;
442 struct inode
*root_i
;
446 c
= JFFS2_SB_INFO(sb
);
448 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
449 if (c
->mtd
->type
== MTD_NANDFLASH
) {
450 printk(KERN_ERR
"jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
453 if (c
->mtd
->type
== MTD_DATAFLASH
) {
454 printk(KERN_ERR
"jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
459 c
->flash_size
= c
->mtd
->size
;
462 * Check, if we have to concatenate physical blocks to larger virtual blocks
463 * to reduce the memorysize for c->blocks. (kmalloc allows max. 128K allocation)
465 c
->sector_size
= c
->mtd
->erasesize
;
466 blocks
= c
->flash_size
/ c
->sector_size
;
467 if (!(c
->mtd
->flags
& MTD_NO_VIRTBLOCKS
)) {
468 while ((blocks
* sizeof (struct jffs2_eraseblock
)) > (128 * 1024)) {
470 c
->sector_size
<<= 1;
475 * Size alignment check
477 if ((c
->sector_size
* blocks
) != c
->flash_size
) {
478 c
->flash_size
= c
->sector_size
* blocks
;
479 printk(KERN_INFO
"jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
480 c
->flash_size
/ 1024);
483 if (c
->sector_size
!= c
->mtd
->erasesize
)
484 printk(KERN_INFO
"jffs2: Erase block size too small (%dKiB). Using virtual blocks size (%dKiB) instead\n",
485 c
->mtd
->erasesize
/ 1024, c
->sector_size
/ 1024);
487 if (c
->flash_size
< 5*c
->sector_size
) {
488 printk(KERN_ERR
"jffs2: Too few erase blocks (%d)\n", c
->flash_size
/ c
->sector_size
);
492 c
->cleanmarker_size
= sizeof(struct jffs2_unknown_node
);
493 /* Joern -- stick alignment for weird 8-byte-page flash here */
495 /* NAND (or other bizarre) flash... do setup accordingly */
496 ret
= jffs2_flash_setup(c
);
500 c
->inocache_list
= kmalloc(INOCACHE_HASHSIZE
* sizeof(struct jffs2_inode_cache
*), GFP_KERNEL
);
501 if (!c
->inocache_list
) {
505 memset(c
->inocache_list
, 0, INOCACHE_HASHSIZE
* sizeof(struct jffs2_inode_cache
*));
507 if ((ret
= jffs2_do_mount_fs(c
)))
512 D1(printk(KERN_DEBUG
"jffs2_do_fill_super(): Getting root inode\n"));
513 root_i
= iget(sb
, 1);
514 if (is_bad_inode(root_i
)) {
515 D1(printk(KERN_WARNING
"get root inode failed\n"));
519 D1(printk(KERN_DEBUG
"jffs2_do_fill_super(): d_alloc_root()\n"));
520 sb
->s_root
= d_alloc_root(root_i
);
524 sb
->s_maxbytes
= 0xFFFFFFFF;
525 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
526 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
527 sb
->s_magic
= JFFS2_SUPER_MAGIC
;
528 if (!(sb
->s_flags
& MS_RDONLY
))
529 jffs2_start_garbage_collect_thread(c
);
534 jffs2_free_ino_caches(c
);
535 jffs2_free_raw_node_refs(c
);
536 if (c
->mtd
->flags
& MTD_NO_VIRTBLOCKS
)
541 kfree(c
->inocache_list
);
543 jffs2_flash_cleanup(c
);
548 void jffs2_gc_release_inode(struct jffs2_sb_info
*c
,
549 struct jffs2_inode_info
*f
)
551 iput(OFNI_EDONI_2SFFJ(f
));
554 struct jffs2_inode_info
*jffs2_gc_fetch_inode(struct jffs2_sb_info
*c
,
558 struct jffs2_inode_cache
*ic
;
560 /* The inode has zero nlink but its nodes weren't yet marked
561 obsolete. This has to be because we're still waiting for
562 the final (close() and) iput() to happen.
564 There's a possibility that the final iput() could have
565 happened while we were contemplating. In order to ensure
566 that we don't cause a new read_inode() (which would fail)
567 for the inode in question, we use ilookup() in this case
570 The nlink can't _become_ zero at this point because we're
571 holding the alloc_sem, and jffs2_do_unlink() would also
572 need that while decrementing nlink on any inode.
574 inode
= ilookup(OFNI_BS_2SFFJ(c
), inum
);
576 D1(printk(KERN_DEBUG
"ilookup() failed for ino #%u; inode is probably deleted.\n",
579 spin_lock(&c
->inocache_lock
);
580 ic
= jffs2_get_ino_cache(c
, inum
);
582 D1(printk(KERN_DEBUG
"Inode cache for ino #%u is gone.\n", inum
));
583 spin_unlock(&c
->inocache_lock
);
586 if (ic
->state
!= INO_STATE_CHECKEDABSENT
) {
587 /* Wait for progress. Don't just loop */
588 D1(printk(KERN_DEBUG
"Waiting for ino #%u in state %d\n",
589 ic
->ino
, ic
->state
));
590 sleep_on_spinunlock(&c
->inocache_wq
, &c
->inocache_lock
);
592 spin_unlock(&c
->inocache_lock
);
598 /* Inode has links to it still; they're not going away because
599 jffs2_do_unlink() would need the alloc_sem and we have it.
600 Just iget() it, and if read_inode() is necessary that's OK.
602 inode
= iget(OFNI_BS_2SFFJ(c
), inum
);
604 return ERR_PTR(-ENOMEM
);
606 if (is_bad_inode(inode
)) {
607 printk(KERN_NOTICE
"Eep. read_inode() failed for ino #%u. nlink %d\n",
609 /* NB. This will happen again. We need to do something appropriate here. */
611 return ERR_PTR(-EIO
);
614 return JFFS2_INODE_INFO(inode
);
617 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info
*c
,
618 struct jffs2_inode_info
*f
,
619 unsigned long offset
,
622 struct inode
*inode
= OFNI_EDONI_2SFFJ(f
);
625 pg
= read_cache_page(inode
->i_mapping
, offset
>> PAGE_CACHE_SHIFT
,
626 (void *)jffs2_do_readpage_unlock
, inode
);
630 *priv
= (unsigned long)pg
;
634 void jffs2_gc_release_page(struct jffs2_sb_info
*c
,
638 struct page
*pg
= (void *)*priv
;
641 page_cache_release(pg
);
644 static int jffs2_flash_setup(struct jffs2_sb_info
*c
) {
647 if (jffs2_cleanmarker_oob(c
)) {
648 /* NAND flash... do setup accordingly */
649 ret
= jffs2_nand_flash_setup(c
);
654 /* add setups for other bizarre flashes here... */
655 if (jffs2_nor_ecc(c
)) {
656 ret
= jffs2_nor_ecc_flash_setup(c
);
662 if (jffs2_dataflash(c
)) {
663 ret
= jffs2_dataflash_setup(c
);
668 /* and Intel "Sibley" flash */
669 if (jffs2_nor_wbuf_flash(c
)) {
670 ret
= jffs2_nor_wbuf_flash_setup(c
);
678 void jffs2_flash_cleanup(struct jffs2_sb_info
*c
) {
680 if (jffs2_cleanmarker_oob(c
)) {
681 jffs2_nand_flash_cleanup(c
);
684 /* add cleanups for other bizarre flashes here... */
685 if (jffs2_nor_ecc(c
)) {
686 jffs2_nor_ecc_flash_cleanup(c
);
690 if (jffs2_dataflash(c
)) {
691 jffs2_dataflash_cleanup(c
);
694 /* and Intel "Sibley" flash */
695 if (jffs2_nor_wbuf_flash(c
)) {
696 jffs2_nor_wbuf_flash_cleanup(c
);