Coding Style cleanup, update CHANGELOG
authorWolfgang Denk <wd@denx.de>
Thu, 14 Aug 2008 12:41:06 +0000 (14:41 +0200)
committerWolfgang Denk <wd@denx.de>
Thu, 14 Aug 2008 12:41:06 +0000 (14:41 +0200)
Signed-off-by: Wolfgang Denk <wd@denx.de>
47 files changed:
CHANGELOG
common/cmd_nand.c
common/cmd_yaffs2.c
drivers/mtd/nand/fsl_elbc_nand.c
drivers/mtd/nand/nand_util.c
drivers/mtd/onenand/onenand_base.c
fs/yaffs2/Makefile
fs/yaffs2/README-linux
fs/yaffs2/devextras.h
fs/yaffs2/yaffs_checkptrw.c
fs/yaffs2/yaffs_checkptrw.h
fs/yaffs2/yaffs_ecc.c
fs/yaffs2/yaffs_ecc.h
fs/yaffs2/yaffs_flashif.h
fs/yaffs2/yaffs_guts.c
fs/yaffs2/yaffs_guts.h
fs/yaffs2/yaffs_malloc.h
fs/yaffs2/yaffs_mtdif.c
fs/yaffs2/yaffs_mtdif.h
fs/yaffs2/yaffs_mtdif2.c
fs/yaffs2/yaffs_mtdif2.h
fs/yaffs2/yaffs_nand.c
fs/yaffs2/yaffs_nand.h
fs/yaffs2/yaffs_nandemul2k.h
fs/yaffs2/yaffs_packedtags1.h
fs/yaffs2/yaffs_packedtags2.c
fs/yaffs2/yaffs_packedtags2.h
fs/yaffs2/yaffs_qsort.c
fs/yaffs2/yaffs_qsort.h
fs/yaffs2/yaffs_ramdisk.h
fs/yaffs2/yaffs_tagscompat.h
fs/yaffs2/yaffs_tagsvalidity.h
fs/yaffs2/yaffscfg.c
fs/yaffs2/yaffscfg.h
fs/yaffs2/yaffsfs.c
fs/yaffs2/yaffsfs.h
fs/yaffs2/yaffsinterface.h
fs/yaffs2/ydirectenv.h
fs/yaffs2/yportenv.h
include/configs/MPC8313ERDB.h
include/linux/mtd/inftl-user.h
include/linux/mtd/mtd-abi.h
include/linux/mtd/mtd.h
include/linux/mtd/nftl-user.h
include/linux/mtd/nftl.h
include/nand.h
nand_spl/nand_boot.c

index aa1bdc31f8d63bd307823b436a504be3788a112d..d3383101b4fe9c17ddfd647515fdd97facf5096f 100644 (file)
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,3 +1,577 @@
+commit 68cf19aae48f2969ec70669604d0d776f02c8bc4
+Author: Scott Wood <scottwood@freescale.com>
+Date:  Wed Aug 13 18:24:05 2008 -0500
+
+    socrates: Update NAND driver to new API.
+
+    Also, fix some minor formatting issues, and simplify the handling of
+    "state" for writes.
+
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit ba22d10f39eaeedd035e8265616e31ff88e314d5
+Author: Scott Wood <scottwood@freescale.com>
+Date:  Wed Aug 13 18:03:40 2008 -0500
+
+    quad100hd: Update NAND driver to new API.
+
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit f64cb652a8a84c5c34d0afcbd7ffef886aa1d838
+Author: Scott Wood <scottwood@freescale.com>
+Date:  Wed Aug 13 17:53:48 2008 -0500
+
+    m5373evb: Update NAND driver to new API.
+
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit 1a23a197c8722b805f40895544bbdb1a648c1c82
+Author: Scott Wood <scottwood@freescale.com>
+Date:  Wed Aug 13 17:04:30 2008 -0500
+
+    s3c24x0: Update NAND driver to new API.
+
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit aa5f75f20db8a7103fad9c34d6f1193e10d1890f
+Author: Scott Wood <scottwood@freescale.com>
+Date:  Wed Aug 13 15:56:00 2008 -0500
+
+    at91: Update board NAND drivers to current API.
+
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit d438d50848e9425286e5fb0493e0affb5a0b1e1b
+Author: Kyungmin Park <kmpark@infradead.org>
+Date:  Wed Aug 13 09:11:02 2008 +0900
+
+    Fix OneNAND build break
+
+    Since page size field is changed from oobblock to writesize. But OneNAND is not updated.
+    - fix bufferram management at erase operation
+    This patch includes the NAND/OneNAND state filed too.
+
+    Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit 9483df6408c25f16060432de3868901e352e23bc
+Author: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+Date:  Wed Aug 13 01:40:43 2008 +0200
+
+    drivers/mtd/nand_legacy: Move conditional compilation to Makefile
+
+    Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+
+commit cc4a0ceeac5462106172d0cc9d9d542233aa3ab2
+Author: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+Date:  Wed Aug 13 01:40:43 2008 +0200
+
+    drivers/mtd/nand: Move conditional compilation to Makefile
+
+    rename CFG_NAND_LEGACY to CONFIG_NAND_LEGACY
+
+    Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+
+commit 4fb09b81920e5dfdfc4576883186733f0bd6059c
+Author: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+Date:  Wed Aug 13 01:40:42 2008 +0200
+
+    drivers/mtd/onenand: Move conditional compilation to Makefile
+
+    Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+
+commit 00b1883a4cac59d97cd297b1a3a398db85982865
+Author: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+Date:  Wed Aug 13 01:40:42 2008 +0200
+
+    drivers/mtd: Move conditional compilation to Makefile
+
+    rename CFG_FLASH_CFI_DRIVER to CONFIG_FLASH_CFI_DRIVER
+
+    Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+
+commit 7ba44a5521cdb7fa1c72864025cde1e21a6f6921
+Author: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+Date:  Wed Aug 13 01:40:41 2008 +0200
+
+    drivers/qe: Move conditional compilation to Makefile
+
+    Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+
+commit ab6878c7bc68a7b5e5b731655bdc13221bbfc493
+Author: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+Date:  Wed Aug 13 01:40:40 2008 +0200
+
+    drivers/pci: Move conditional compilation to Makefile
+
+    Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+
+commit 55d6d2d39fe3fe87802e399aa17539368b495d2e
+Author: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+Date:  Wed Aug 13 01:40:40 2008 +0200
+
+    drivers/misc: Move conditional compilation to Makefile
+
+    Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+
+commit 65e41ea0548b86e3d7892defac8e4dc1ea70aed1
+Author: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+Date:  Wed Aug 13 01:40:40 2008 +0200
+
+    drivers/input: Move conditional compilation to Makefile
+
+    Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+
+commit 88f57e093114a44aa9a858d52b099bcc52034a8c
+Author: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+Date:  Wed Aug 13 01:40:39 2008 +0200
+
+    drivers/dma: Move conditional compilation to Makefile
+
+    Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+
+commit 1a02806c4b1b4a09ad4e95d3aac3783889e5f8d7
+Author: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+Date:  Wed Aug 13 01:40:39 2008 +0200
+
+    drivers/block: Move conditional compilation to Makefile
+
+    Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+
+commit 1a6ffbfaf4353bec379ed1fcfc54b6f1a30af09a
+Author: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+Date:  Wed Aug 13 01:40:39 2008 +0200
+
+    serial: move CFG_NS9750_UART to CONFIG_NS9750_UART
+
+    move also conditional compilation to Makefile
+
+    Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+
+commit 6c58a030f86829fa4f0d4337cf4b794c41a1823e
+Author: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+Date:  Wed Aug 13 01:40:38 2008 +0200
+
+    serial: move CFG_SCIF_CONSOLE to CONFIG_SCIF_CONSOLE
+
+    move also conditional compilation to Makefile
+
+    Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+
+commit d6e9ee92e890f67594ab150689510df361133ead
+Author: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+Date:  Wed Aug 13 01:40:38 2008 +0200
+
+    common: Move conditional compilation to Makefile
+
+    Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+
+commit f5acb9fd9bba1160de3ef349c7d33fe510eda286
+Author: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+Date:  Wed Aug 13 01:40:09 2008 +0200
+
+    mx31: move freescale's mx31 boards to vendor board dir
+
+    Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+
+commit 8ed2f5f950e2581214d20b011a8f27a6396d65d2
+Author: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+Date:  Sat Jul 5 23:11:11 2008 +0200
+
+    at91: move arch-at91sam9 to arch-at91
+
+    Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+
+commit 195ccfc5991d48764b2519941e3507f693851d5d
+Author: Fathi BOUDRA <fabo@debian.org>
+Date:  Wed Aug 6 10:06:20 2008 +0200
+
+    OneNAND: Fill in MTD function pointers for OneNAND.
+
+    onenand_print_device_info():
+     - Now returns a string to be placed in mtd->name,
+       rather than calling printf.
+     - Remove verbose parameter as it becomes useless.
+
+    Signed-off-by: Fathi Boudra <fabo@debian.org>
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit aa646643b6bc250cb3a4966bf728876e0c10d329
+Author: Guennadi Liakhovetski <lg@denx.de>
+Date:  Wed Aug 6 21:42:07 2008 +0200
+
+    nand_spl: Support page-aligned read in nand_load, use chipselect
+
+    Supporting page-aligned reads doesn't incure any sinificant overhead, just
+    a small change in the algorithm. Also replace in_8 with readb, since there
+    is no in_8 on ARM.
+
+    Signed-off-by: Guennadi Liakhovetski <lg@denx.de>
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit 4f32d7760a58fe73981b6edc0b0751565d2daa4c
+Author: Scott Wood <scottwood@freescale.com>
+Date:  Tue Aug 5 11:15:59 2008 -0500
+
+    NAND boot: Update large page support for current API.
+
+    Also, remove the ctrl variable in favor of passing the constants
+    directly, and remove redundant (u8) casts.
+
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit e4c09508545d1c45617ba45391c03c03cbc360b9
+Author: Scott Wood <scottwood@freescale.com>
+Date:  Mon Jun 30 14:13:28 2008 -0500
+
+    NAND boot: MPC8313ERDB support
+
+    Note that with older board revisions, NAND boot may only work after a
+    power-on reset, and not after a warm reset.  I don't have a newer board
+    to test on; if you have a board with a 33MHz crystal, please let me know
+    if it works after a warm reset.
+
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit acdab5c33f1ea6f5e08f06f08bc64af23ff40d71
+Author: Scott Wood <scottwood@freescale.com>
+Date:  Thu Jun 26 14:06:52 2008 -0500
+
+    mpc8313erdb: Enable NAND in config.
+
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit c3db8c649c6ab3da2f1411c4c6d61aecea054aa4
+Author: Guennadi Liakhovetski <lg@denx.de>
+Date:  Thu Jul 31 12:38:26 2008 +0200
+
+    NAND: Do not write or read a whole block if it is larger than the environment
+
+    Environment can be smaller than NAND block size, do not need to read a whole
+    block and minimum for writing is one page. Also remove an unused variable.
+
+    Signed-off-by: Guennadi Liakhovetski <lg@denx.de>
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit eafcabd15f00c142156235c519fcc55b10993241
+Author: Marcel Ziswiler <marcel@ziswiler.com>
+Date:  Sun Jun 22 16:30:06 2008 +0200
+
+    NAND: chip->state does not always get set.
+
+    Fixes an issue with chip->state not always being set causing troubles.
+
+    Signed-off-by: Marcel Ziswiler <marcel@ziswiler.com>
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit 13f0fd94e3cae6f8a0d9fba5d367e311edc8ebde
+Author: Ilya Yanok <yanok@emcraft.com>
+Date:  Mon Jun 30 15:34:40 2008 +0200
+
+    NAND: Scan bad blocks lazily.
+
+    Rather than scanning on boot, scan upon the first attempt to check the
+    badness of a block.  This speeds up boot when not using NAND, and reduces
+    the likelihood of needing to reflash via JTAG if NAND becomes
+    nonfunctional.
+
+    Signed-off-by: Ilya Yanok <yanok@emcraft.com>
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit dfbf617ff055e4216f78d358b0867c548916d14b
+Author: Scott Wood <scottwood@freescale.com>
+Date:  Thu Jun 12 13:20:16 2008 -0500
+
+    NAND read/write fix
+
+    Implement block-skipping read/write, based on a patch from
+    Morten Ebbell Hestens <morten.hestnes@tandberg.com>.
+
+    Signed-off-by: Morten Ebbell Hestnes <morten.hestnes@tandberg.com>
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit 984e03cdf1431bb593aeaa1b74c445d616f955d3
+Author: Scott Wood <scottwood@freescale.com>
+Date:  Thu Jun 12 13:13:23 2008 -0500
+
+    NAND: Always skip blocks on read/write/boot.
+
+    Use of the non-skipping versions was almost always (if not always)
+    an error, and no valid use case has been identified.
+
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit e1c3dbada349992875934575c97b328ab2cb33ca
+Author: Anton Vorontsov <avorontsov@ru.mvista.com>
+Date:  Thu Jun 12 11:10:21 2008 -0500
+
+    nand: fsl_upm: convert to updated MTD NAND infrastructure
+
+    Signed-off-by: Anton Vorontsov <avorontsov@ru.mvista.com>
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit 300253306acc72b1b2e9faf0987f86551151d7cf
+Author: Scott Wood <scottwood@freescale.com>
+Date:  Thu May 22 15:02:46 2008 -0500
+
+    fsl_elbc_nand: Hard-code the FBAR/FPAR split.
+
+    The hardware has separate registers for block and page-within-block,
+    but the division between the two has no apparent relation to the
+    actual erase block size of the NAND chip.
+
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit 9c814b0a716aae884bec977b9a032dfa59cfb79a
+Author: Anton Vorontsov <avorontsov@ru.mvista.com>
+Date:  Fri Mar 28 22:10:54 2008 +0300
+
+    fsl_elbc_nand: workaround for hangs during nand write
+
+    Using current driver elbc sometimes hangs during nand write. Reading back
+    last byte helps though (thanks to Scott Wood for the idea).
+
+    Signed-off-by: Anton Vorontsov <avorontsov@ru.mvista.com>
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit 9fd020d6b4b36b9fb67cd834bc1ae7fdba15ee9e
+Author: Scott Wood <scottwood@freescale.com>
+Date:  Fri Mar 21 16:12:51 2008 -0500
+
+    Freescale eLBC FCM NAND driver
+
+    This is a driver for the Flash Control Machine of the enhanched Local Bus
+    Controller found on some Freescale chips (such as the mpc8313 and the
+    mpc8379).
+
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit 41ef8c716e93fdf50efe9c1ba733ca6675daaca6
+Author: Scott Wood <scottwood@freescale.com>
+Date:  Tue Mar 18 15:29:14 2008 -0500
+
+    Don't panic if a controller driver does ecc its own way.
+
+    Some hardware, such as the enhanced local bus controller used on some
+    mpc83xx chips, does ecc transparently when reading and writing data, rather
+    than providing a generic calculate/correct mechanism that can be exported to
+    the nand subsystem.
+
+    The subsystem should not BUG() when calculate, correct, or hwctl are
+    missing, if the methods that call them have been overridden.
+
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit e52b34d40a8a646e3d11638ea8797e96398dba13
+Author: Stefan Roese <sr@denx.de>
+Date:  Thu Jan 10 18:47:33 2008 +0100
+
+    NAND: Make NAND driver less verbose per default
+
+    This patch turns off printing of bad blocks per default upon bootup.
+    This can always be shown via the "nand bad" command later.
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit fe56a2772e5c59577df906163d0d4b29b056140e
+Author: Sergey Kubushyn <ksi@koi8.net>
+Date:  Wed Jan 9 15:36:20 2008 +0100
+
+    NAND: Davinci driver updates
+
+    Here comes a trivial patch to cpu/arm926ejs/davinci/nand.c. Unfortunately I
+    don't have hardware handy so I can not test it at the moment but changes are
+    rather trivial so it should work. It would be nice if somebody with a
+    hardware checked it anyways.
+
+    Signed-off-by: Sergey Kubushyn <ksi@koi8.net>
+
+commit deac913effd8d80535c9ff4687b6fcdff540c554
+Author: Stefan Roese <sr@denx.de>
+Date:  Sat Jan 5 16:50:32 2008 +0100
+
+    NAND: Fix compilation warning and small coding style issue
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit c568f77acdf896fc3dd6413ce53205b17ba809a3
+Author: Stefan Roese <sr@denx.de>
+Date:  Sat Jan 5 16:49:37 2008 +0100
+
+    NAND: Update nand_spl driver to match updated nand subsystem
+
+    This patch changes the NAND booting driver nand_spl/nand_boot.c to match
+    the new infrastructure from the updated NAND subsystem. This NAND
+    subsystem was recently synced again with the Linux 2.6.22 MTD/NAND
+    subsystem.
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 3df2ece0f0fbba47d27f02fff96c533732b98c14
+Author: Stefan Roese <sr@denx.de>
+Date:  Sat Jan 5 16:47:58 2008 +0100
+
+    NAND: Update 4xx NDFC driver to match updated nand subsystem
+
+    This patch changes the 4xx NAND driver ndfc.c to match the new
+    infrastructure from the updated NAND subsystem. This NAND
+    subsystem was recently synced again with the Linux 2.6.22 MTD/NAND
+    subsystem.
+
+    Tested successfully on AMCC Sequoia and Bamboo.
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 12072264528eba33737bc9674e19f0e925ffda23
+Author: Stefan Roese <sr@denx.de>
+Date:  Sat Jan 5 16:43:25 2008 +0100
+
+    NAND: Change nand_wait_ready() to not call nand_wait()
+
+    This patch changes nand_wait_ready() to not just call nand_wait(),
+    since this will send a new command to the NAND chip. We just want to
+    wait for the chip to become ready here.
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 9ad754fef5053144daed3b007adaf1c9bec654c9
+Author: William Juul <william.juul@datarespons.no>
+Date:  Fri Dec 14 16:33:45 2007 +0100
+
+    make nand dump and nand dump.oob work
+
+    Signed-off-by: William Juul <william.juul@tandberg.com>
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit 43ea36fb8fdcbc6e26f0caffe808c63633b18838
+Author: William Juul <william.juul@datarespons.no>
+Date:  Mon Nov 19 14:46:00 2007 +0100
+
+    moving files from yaffs2/direct/ to yaffs2/ and deleting all symlinks
+
+    Signed-off-by: William Juul <william.juul@tandberg.com>
+
+commit 98824ce3f95e6c4d08d439b779c0acb0048045a6
+Author: William Juul <william.juul@tandberg.com>
+Date:  Tue Jun 10 16:18:13 2008 -0500
+
+    Clean out unneeded files
+
+    Signed-off-by: William Juul <william.juul@tandberg.com>
+
+commit ec29a32b5a71b203f7d9087f1f4d786e7f13dd23
+Author: William Juul <william.juul@datarespons.no>
+Date:  Fri Nov 16 08:44:27 2007 +0100
+
+    Create symlinks from yaffs2/direct to yaffs2
+
+    Signed-off-by: William Juul <william.juul@tandberg.com>
+
+commit 90ef117b68387d66763291af0117677644166611
+Author: William Juul <william.juul@datarespons.no>
+Date:  Thu Nov 15 12:23:57 2007 +0100
+
+    Incorporate yaffs2 into U-boot
+
+    To use YAFFS2 define CONFIG_YAFFS2
+
+    Signed-off-by: William Juul <william.juul@tandberg.com>
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit 0e8cc8bd92257da2e1df88cbc985e166e472ce61
+Author: William Juul <william.juul@datarespons.no>
+Date:  Thu Nov 15 11:13:05 2007 +0100
+
+    YAFFS2 import
+
+    Direct import of yaffs as a tarball as of 20071113 from their public
+    CVS-web at http://www.aleph1.co.uk/cgi-bin/viewcvs.cgi/yaffs2/
+
+    The code can also be imported on the command line with:
+    export CVSROOT=:pserver:anonymous@cvs.aleph1.co.uk:/home/aleph1/cvs cvs logon
+    (Hit return when asked for a password)
+    cvs checkout yaffs2
+
+    Signed-off-by: William Juul <william.juul@tandberg.com>
+    Signed-off-by: Stig Olsen <stig.olsen@tandberg.com>
+
+commit 3043c045d5a9897faba7d5c7218c2f4d06cd0038
+Author: William Juul <william.juul@datarespons.no>
+Date:  Wed Nov 14 14:28:11 2007 +0100
+
+    Whitespace cleanup and marking broken code.
+
+    Changes requested by maintainer Stefan Roese after
+    posting patch to U-boot mailing list.
+
+    Signed-off-by: William Juul <william.juul@tandberg.com>
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit 5e1dae5c3db7f4026f31b6a2a81ecd9e9dee475f
+Author: William Juul <william.juul@datarespons.no>
+Date:  Fri Nov 9 13:32:30 2007 +0100
+
+    Fixing coding style issues
+
+     - Fixing leading white spaces
+     - Fixing indentation where 4 spaces are used instead of tab
+     - Removing C++ comments (//), wherever I introduced them
+
+    Signed-off-by: William Juul <william.juul@tandberg.com>
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit 4cbb651b29cb64d378a06729970e1e153bb605b1
+Author: William Juul <william.juul@datarespons.no>
+Date:  Thu Nov 8 10:39:53 2007 +0100
+
+    Remove white space at end.
+
+    Signed-off-by: William Juul <william.juul@tandberg.com>
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit cfa460adfdefcc30d104e1a9ee44994ee349bb7b
+Author: William Juul <william.juul@datarespons.no>
+Date:  Wed Oct 31 13:53:06 2007 +0100
+
+    Update MTD to that of Linux 2.6.22.1
+
+    A lot changed in the Linux MTD code, since it was last ported from
+    Linux to U-Boot. This patch takes U-Boot NAND support to the level
+    of Linux 2.6.22.1 and will enable support for very large NAND devices
+    (4KB pages) and ease the compatibility between U-Boot and Linux
+    filesystems.
+
+    This patch is tested on two custom boards with PPC and ARM
+    processors running YAFFS in U-Boot and Linux using gcc-4.1.2
+    cross compilers.
+
+    MAKEALL ppc/arm has some issues:
+     * DOC/OneNand/nand_spl is not building (I have not tried porting
+       these parts, and since I do not have any HW and I am not familiar
+       with this code/HW I think its best left to someone else.)
+
+    Except for the issues mentioned above, I have ported all drivers
+    necessary to run MAKEALL ppc/arm without errors and warnings. Many
+    drivers were trivial to port, but some were not so trivial. The
+    following drivers must be examined carefully and maybe rewritten to
+    some degree:
+     cpu/ppc4xx/ndfc.c
+     cpu/arm926ejs/davinci/nand.c
+     board/delta/nand.c
+     board/zylonite/nand.c
+
+    Signed-off-by: William Juul <william.juul@tandberg.com>
+    Signed-off-by: Stig Olsen <stig.olsen@tandberg.com>
+    Signed-off-by: Scott Wood <scottwood@freescale.com>
+
+commit cd82919e6c8a73b363a26f34b734923844e52d1c
+Author: Wolfgang Denk <wd@denx.de>
+Date:  Tue Aug 12 16:08:38 2008 +0200
+
+    Coding style cleanup, update CHANGELOG, prepare release
+
+    Signed-off-by: Wolfgang Denk <wd@denx.de>
+
 commit 17e900b8c0f38d922da47073246219dce2a847f2
 Author: Wolfgang Denk <wd@denx.de>
 Date:  Tue Aug 12 14:54:04 2008 +0200
@@ -413,6 +987,22 @@ Date:      Wed Aug 6 15:42:52 2008 -0400
     Signed-off-by: Steven A. Falco <sfalco@harris.com>
     Signed-off-by: Stefan Roese <sr@denx.de>
 
+commit 1318673045fe188c6e24c582b1e6efc00ae1c62c
+Author: Stefan Roese <sr@denx.de>
+Date:  Wed Aug 6 14:06:03 2008 +0200
+
+    Fix merge problems
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit f2302d4430e7f3f48308d6a585320fe96af8afbd
+Author: Stefan Roese <sr@denx.de>
+Date:  Wed Aug 6 14:05:38 2008 +0200
+
+    Fix merge problems
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
 commit 6689484ccd43189322aaa5a1c6cd02cdd511ad7d
 Author: Kenneth Johansson <kenneth@southpole.se>
 Date:  Tue Jul 15 12:13:38 2008 +0200
@@ -775,6 +1365,42 @@ Date:     Thu Jul 31 10:12:09 2008 +0200
 
     Signed-off-by: Wolfgang Denk <wd@denx.de>
 
+commit 9246f5ecfd353ae297a02ffd5328402acf16c9dd
+Author: Ricardo Ribalda Delgado <ricardo.ribalda@uam.es>
+Date:  Wed Jul 30 12:39:28 2008 +0200
+
+    ppc4xx: ML507: Environment in flash and MTD Support
+
+    - Relocate the location of U-Boot in the flash
+    - Save the environment in one sector of the flash memory
+    - MTD Support
+
+    Signed-off-by: Ricardo Ribalda Delgado <ricardo.ribalda@uam.es>
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit a8a16af4d59d14cc1c1187c10aaad80d6b8394b5
+Author: Ricardo Ribalda Delgado <ricardo.ribalda@uam.es>
+Date:  Tue Jul 29 17:16:10 2008 +0200
+
+    ppc4xx: ML507: Use of get_ram_size in board ml507
+
+    - Change suggested by WD
+
+    Signed-off-by: Ricardo Ribalda Delgado <ricardo.ribalda@uam.es>
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 01a004313c5ec2d128b611df4c208b1b0d3c3fb4
+Author: Ricardo Ribalda Delgado <ricardo.ribalda@uam.es>
+Date:  Mon Jul 21 20:30:07 2008 +0200
+
+    ppc4xx: ML507: U-Boot in flash and System ACE
+
+    This patch allows booting from FLASH the ML507 board by Xilinx.
+    Previously, U-Boot needed to be loaded from JTAG or a Sytem ACE CF
+
+    Signed-off-by: Ricardo Ribalda Delgado <ricardo.ribalda@uam.es>
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
 commit 09d318a8bb1444ec92e31cafcdba877eb9409e58
 Author: Kumar Gala <galak@kernel.crashing.org>
 Date:  Tue Jul 29 12:23:49 2008 -0500
@@ -1098,6 +1724,54 @@ Date:    Fri Jul 18 15:57:23 2008 +0200
 
     Signed-off-by: Stefan Roese <sr@denx.de>
 
+commit 60204d06ed9f8c2a67cc79eb67fd2b1d22bcbc8c
+Author: Stefan Roese <sr@denx.de>
+Date:  Fri Jul 18 12:24:41 2008 +0200
+
+    ppc4xx: Minor coding style cleanup of Xilinx Virtex5 ml507 support
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 086511fc96a8a9bb56e5e19a3d84c40f4dba80cc
+Author: Ricardo Ribalda Delgado <ricardo.ribalda@uam.es>
+Date:  Thu Jul 17 12:47:09 2008 +0200
+
+    ppc4xx: ML507 Board Support
+
+    The Xilinx ML507 Board is a Virtex 5 prototyping board that includes,
+       among others:
+       -Virtex 5 FX FPGA (With a ppc440x5 in it)
+       -256MB of SDRAM2
+       -32MB of Flash
+       -I2C Eeprom
+       -System ACE chip
+       -Serial ATA connectors
+       -RS232 Level Conversors
+       -Ethernet Transceiver
+
+    This patch gives support to a standard design produced by EDK for this
+    board: ppc440, uartlite, xilinx_int and flash
+
+    - Includes Changes propossed by Stefan Roese and Michal Simek
+
+    Signed-off-by: Ricardo Ribalda Delgado <ricardo.ribalda@uam.es>
+    Acked-by: Stefan Roese <sr@denx.de>
+
+commit d865fd09809a3a18669f35f970781820af40e4de
+Author: Ricardo Ribalda Delgado <ricardo.ribalda@uam.es>
+Date:  Thu Jul 17 11:44:12 2008 +0200
+
+    ppc4xx: CPU PPC440x5 on Virtex5 FX
+
+    -This patchs gives support for the embbedded ppc440
+     on the Virtex5 FPGAs
+    -interrupts.c divided in uic.c and interrupts.c
+    -xilinx_irq.c for xilinx interrupt controller
+    -Include modifications propossed by  Stefan Roese
+
+    Signed-off-by: Ricardo Ribalda Delgado <ricardo.ribalda@uam.es>
+    Acked-by: Stefan Roese <sr@denx.de>
+
 commit 340ccb260f21516be360745d5c5e3bd0657698df
 Author: Sebastian Siewior <bigeasy@linutronix.de>
 Date:  Wed Jul 16 20:04:49 2008 +0200
@@ -1116,6 +1790,14 @@ Date:    Wed Jul 16 20:04:49 2008 +0200
     Cc: Vasiliy Leonenko <vasiliy.leonenko@mail.ru>
     Signed-off-by: Sebastian Siewior <bigeasy@linutronix.de>
 
+commit 11188d55bc16dd907451c00282e00a038f73dd62
+Author: Stefan Roese <sr@denx.de>
+Date:  Thu Jul 17 10:40:51 2008 +0200
+
+    ppc4xx: Fix alphabetical order in 4xx Makefile part (redwood)
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
 commit 699f05125509249072a0b865c8d35520d97cd501
 Author: Wolfgang Denk <wd@denx.de>
 Date:  Tue Jul 15 22:22:44 2008 +0200
@@ -1927,6 +2609,271 @@ Date:   Thu Jul 10 11:38:26 2008 +0200
 
     Signed-off-by: Stefan Roese <sr@denx.de>
 
+commit 69e2c6d0d13d7c8cf1612ac090bdc4c59ba6858e
+Author: Stefan Roese <sr@denx.de>
+Date:  Fri Jul 11 13:10:56 2008 +0200
+
+    ppc4xx: Fix compile warning in 44x_spd_ddr2.c
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 6bd9138498c2e4f4f09190108b99157d1b2140b5
+Author: Stefan Roese <sr@denx.de>
+Date:  Fri Jul 11 11:40:13 2008 +0200
+
+    ppc4xx: Fix small korat merge problem
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 1d0554736a0a1dd59718acda660871ce56b69e18
+Author: Stefan Roese <sr@denx.de>
+Date:  Fri Jul 11 11:34:52 2008 +0200
+
+    ppc4xx: Some Rewood cleanups (coding style, leading white spaces)
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 3a82113ed5934d498f25080441a8261fc9454b15
+Author: Stefan Roese <sr@denx.de>
+Date:  Thu Jul 10 16:37:09 2008 +0200
+
+    ppc4xx: Add 460SX UIC defines
+
+    Only the really needed ones are added (cascading and EMAC/MAL).
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 26173fc6f60521c2a8072f652f863617fc11ba9a
+Author: Stefan Roese <sr@denx.de>
+Date:  Mon Jun 30 14:11:07 2008 +0200
+
+    ppc4xx: Continue cleanup of ppc440.h
+
+    This patch continues the ppc440.h cleanup by removing some of the unused
+    defines.
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit d9056b7913ed6a228d2f33671d916efedee541dd
+Author: Stefan Roese <sr@denx.de>
+Date:  Mon Jun 30 14:05:05 2008 +0200
+
+    ppc4xx: Cleanup Katmai & Yucca PCIe register usage
+
+    This patch cleans up the 440SPe PCIe register usage. Now only defines
+    from the include/asm-ppc/4xx_pcie.h are used.
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 5de851403b01489b493fa83137ad990b8ce60d1c
+Author: Stefan Roese <sr@denx.de>
+Date:  Thu Jun 26 17:36:39 2008 +0200
+
+    ppc4xx: Rework 440GX UIC handling
+
+    This patch reworks the 440GX interrupt handling so that the common 4xx
+    code can be used. The 440GX is an exception to all other 4xx variants
+    by having the cascading interrupt vectors not on UIC0 but on a special
+    UIC named UICB0 (UIC Base 0). With this patch now, U-Boot references
+    the 440GX UICB0 when UIC0 is selected. And the common 4xx interrupt
+    handling is simpler without any 440GX special cases.
+
+    Also some additional cleanup to cpu/ppc4xx/interrupt.c is done.
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit d1631fe1a05b063ccaf62ea892a8887b829847d1
+Author: Stefan Roese <sr@denx.de>
+Date:  Thu Jun 26 13:40:57 2008 +0200
+
+    ppc4xx: Consolidate PPC4xx UIC defines
+
+    This 2nd patch now removes all UIC mask bit definition. They should be
+    generated from the vectors by using the UIC_MASK() macro from now on.
+    This way only the vectors need to get defined for new PPC's.
+
+    Also only the really used interrupt vectors are now defined. This makes
+    definitions for new PPC versions easier and less error prone.
+
+    Another part of this patch is that the 4xx emac driver got a little
+    cleanup, since now the usage of the interrupts is clearer.
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 4fb25a3db3b3839094aa9ab748efd7a95924690b
+Author: Stefan Roese <sr@denx.de>
+Date:  Wed Jun 25 10:59:22 2008 +0200
+
+    ppc4xx: Consolidate PPC4xx UIC defines
+
+    This patch is the first step to consolidate the UIC related defines in the
+    4xx headers. Move header from asm-ppc/ppc4xx-intvec.h to
+    asm-ppc/ppc4xx-uic.h as it will hold all UIC related defines in the next
+    steps.
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 7ee2619c20ccecd57966d74d844e6329e141261c
+Author: Stefan Roese <sr@denx.de>
+Date:  Tue Jun 24 17:18:50 2008 +0200
+
+    ppc4xx: Consolidate PPC4xx EBC defines
+
+    This patch removes all EBC related defines from the PPC4xx headers
+    ppc405.h and ppc440.h and introduces a new header
+
+    include/asm-ppc/ppc4xx-ebc.h
+
+    with all those defines.
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit e321801bed5a6d896d298c00fd20046f039d5d66
+Author: Stefan Roese <sr@denx.de>
+Date:  Thu Jul 10 13:52:44 2008 +0200
+
+    ppc4xx: Remove redundant ft_board_setup() functions from some 4xx boards
+
+    This patch removes some ft_board_setup() functions from some 4xx boards.
+    This can be done since we now have a default weak implementation for this
+    in cpu/ppc4xx/fdt.c. Only board in need for a different/custom
+    implementation like canyonlands need their own version.
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 08250eb2edbd96514d049602d9e134110ac3185f
+Author: Stefan Roese <sr@denx.de>
+Date:  Thu Jul 10 15:32:32 2008 +0200
+
+    ppc4xx: Fix merge problems in 44x_spd_ddr2.c
+
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 1740c1bf40e3c6d03ac16c29943fdd9fc1e87038
+Author: Grant Erickson <gerickson@nuovations.com>
+Date:  Tue Jul 8 08:35:00 2008 -0700
+
+    ppc4xx: Add MII mode support to the EMAC RGMII Bridge
+
+    This patch adds support for placing the RGMII bridge on the
+    PPC405EX(r) into MII/GMII mode and allows a board-specific
+    configuration to specify the bridge mode at compile-time.
+
+    Signed-off-by: Grant Erickson <gerickson@nuovations.com>
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 2e2050842e731c823ce8d41fb0c15579eb70ced9
+Author: Grant Erickson <gerickson@nuovations.com>
+Date:  Wed Jul 9 16:46:35 2008 -0700
+
+    ppc4xx: Add Mnemonics for AMCC/IBM DDR2 SDRAM Controller
+
+    This patch completes the preprocessor mneomics for the IBM DDR2 SDRAM
+    controller registers (MODT and INITPLR) used by the
+    PowerPC405EX(r). The MMODE and MEMODE registers are unified with their
+    peer values used for the INITPLR MR and EMR registers,
+    respectively. Finally, a spelling typo is correct (MANUEL to MANUAL).
+
+    With these mnemonics in place, the CFG_SDRAM0_* magic numbers for
+    Kilauea are replaced by equivalent mnemonics to make it easier to
+    compare and contrast other 405EX(r)-based boards (e.g. during board
+    bring-up).
+
+    Finally, unified the SDRAM controller register dump routine such that
+    it can be used across all processor variants that utilize the IBM DDR2
+    SDRAM controller core. It produces output of the form:
+
+       PPC4xx IBM DDR2 Register Dump:
+               ...
+               SDRAM_MB0CF[40] = 0x00006701
+               ...
+
+    which is '<mnemonic>[<DCR #>] = <value>'. The DCR number is included
+    since it is not uncommon that the DCR values in header files get mixed
+    up and it helps to validate, at a glance, they match what is printed
+    in the user manual.
+
+    Tested on:
+      AMCC Kilauea/Haleakala:
+      - NFS Linux Boot: PASSED
+      - NAND Linux Boot: PASSED
+
+    Signed-off-by: Grant Erickson <gerickson@nuovations.com>
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit ad7382d828982e9c1bafc4313ef1b666f6145f58
+Author: Grant Erickson <gerickson@nuovations.com>
+Date:  Wed Jul 9 16:31:59 2008 -0700
+
+    ppc4xx: Add AMCC/IBM DDR2 SDRAM ECC Field Mnemonics
+
+    Add additional DDR2 SDRAM memory controller DCR mneomnics, condition
+    revision ID DCR based on 405EX, and add field mnemonics for bus error
+    status and ECC error status registers.
+
+    Signed-off-by: Grant Erickson <gerickson@nuovations.com>
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 103201731bd8e85404d0f51a5b4e8abd14c0b6c6
+Author: Grant Erickson <gerickson@nuovations.com>
+Date:  Wed Jul 9 16:31:36 2008 -0700
+
+    ppc4xx: Add SDR0_SRST Mnemonics for the 405EX(r)
+
+    This patch adds bit field mnemonics for the 405EX(r) SDR0_SRST soft reset register.
+
+    Signed-off-by: Grant Erickson <gerickson@nuovations.com>
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 5b457d00730d4aa0c6450d21a9104723e606fb98
+Author: Grant Erickson <gerickson@nuovations.com>
+Date:  Wed Jul 9 11:55:46 2008 -0700
+
+    PPC4xx: Correct SDRAM_MCSTAT for PPC405EX(r)
+
+    While the PowerPC 405EX(r) shares in common the AMCC/IBM DDR2 SDRAM
+    controller core also used in the 440SP, 440SPe, 460EX, and 460GT, in
+    the 405EX(r), SDRAM_MCSTAT has a different DCR value.
+
+    Its present value on the 405EX(r) causes a read back of 0xFFFFFFFF
+    which causes SDRAM initialization to periodically fail since it can
+    prematurely indicate SDRAM ready status.
+
+    Signed-off-by: Grant Erickson <gerickson@nuovations.com>
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 0ce5c8675bb2c61f1d71fb97f0bbe822663fb93d
+Author: Feng Kan <fkan@amcc.com>
+Date:  Tue Jul 8 22:48:42 2008 -0700
+
+    ppc4xx: Initial framework of the AMCC PPC460SX redwood reference board.
+
+    Add AMCC Redwood reference board that uses the latest
+    PPC 464 CPU processor combined with a rich mix of peripheral
+    controllers. The board will support PCIe, mutiple Gig ethernet
+    ports, advanced hardware RAID assistance and IEEE 1588.
+
+    Signed-off-by: Feng Kan <fkan@amcc.com>
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 96e5fc0e6a1861d0fea4efa3cd376df95a5b1b89
+Author: Feng Kan <fkan@amcc.com>
+Date:  Tue Jul 8 22:48:07 2008 -0700
+
+    ppc4xx: Add initial 460SX reference board (redwood) config file and defines.
+
+    Signed-off-by: Feng Kan <fkan@amcc.com>
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
+commit 7d30793685efcada183891c78fc892e6c9ba50c7
+Author: Feng Kan <fkan@amcc.com>
+Date:  Tue Jul 8 22:47:31 2008 -0700
+
+    ppc4xx: Add initial 460SX defines for the cpu/ppc4xx directory.
+
+    Signed-off-by: Feng Kan <fkan@amcc.com>
+    Signed-off-by: Stefan Roese <sr@denx.de>
+
 commit 9b55a2536919f4de1bb1044e6eb8262c2f53bc96
 Author: Wolfgang Denk <wd@denx.de>
 Date:  Fri Jul 11 01:16:00 2008 +0200
index fa7a438b5ffe3f4e0e150e65144a614e5749e1a7..b94a2bf1d7ed1295a4b1e348c72c7db1283055e0 100644 (file)
@@ -35,7 +35,7 @@
 int mtdparts_init(void);
 int id_parse(const char *id, const char **ret_id, u8 *dev_type, u8 *dev_num);
 int find_dev_and_part(const char *id, struct mtd_device **dev,
-                      u8 *part_num, struct part_info **part);
+                     u8 *part_num, struct part_info **part);
 #endif
 
 static int nand_dump(nand_info_t *nand, ulong off, int only_oob)
@@ -68,7 +68,7 @@ static int nand_dump(nand_info_t *nand, ulong off, int only_oob)
        printf("Page %08lx dump:\n", off);
        i = nand->writesize >> 4;
        p = datbuf;
-               
+
        while (i--) {
                if (!only_oob)
                        printf("\t%02x %02x %02x %02x %02x %02x %02x %02x"
@@ -193,7 +193,7 @@ int do_nand(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
                for (i = 0; i < CFG_MAX_NAND_DEVICE; i++) {
                        if (nand_info[i].name)
                                printf("Device %d: %s, sector size %u KiB\n",
-                                      i, nand_info[i].name,
+                                      i, nand_info[i].name,
                                       nand_info[i].erasesize >> 10);
                }
                return 0;
@@ -336,10 +336,10 @@ int do_nand(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
                    !strcmp(s, ".e") || !strcmp(s, ".i")) {
                        if (read)
                                ret = nand_read_skip_bad(nand, off, &size,
-                                                        (u_char *)addr);
+                                                        (u_char *)addr);
                        else
                                ret = nand_write_skip_bad(nand, off, &size,
-                                                         (u_char *)addr);
+                                                         (u_char *)addr);
                } else if (s != NULL && !strcmp(s, ".oob")) {
                        /* out-of-band data */
                        mtd_oob_ops_t ops = {
@@ -469,26 +469,26 @@ usage:
 }
 
 U_BOOT_CMD(nand, 5, 1, do_nand,
-           "nand - NAND sub-system\n",
-           "info - show available NAND devices\n"
-           "nand device [dev] - show or set current device\n"
-           "nand read - addr off|partition size\n"
-           "nand write - addr off|partition size\n"
-           "    read/write 'size' bytes starting at offset 'off'\n"
-           "    to/from memory address 'addr', skipping bad blocks.\n"
-           "nand erase [clean] [off size] - erase 'size' bytes from\n"
-           "    offset 'off' (entire device if not specified)\n"
-           "nand bad - show bad blocks\n"
-           "nand dump[.oob] off - dump page\n"
-           "nand scrub - really clean NAND erasing bad blocks (UNSAFE)\n"
-           "nand markbad off - mark bad block at offset (UNSAFE)\n"
-           "nand biterr off - make a bit error at offset (UNSAFE)\n"
-           "nand lock [tight] [status]\n"
-           "    bring nand to lock state or display locked pages\n"
-           "nand unlock [offset] [size] - unlock section\n");
+          "nand - NAND sub-system\n",
+          "info - show available NAND devices\n"
+          "nand device [dev] - show or set current device\n"
+          "nand read - addr off|partition size\n"
+          "nand write - addr off|partition size\n"
+          "    read/write 'size' bytes starting at offset 'off'\n"
+          "    to/from memory address 'addr', skipping bad blocks.\n"
+          "nand erase [clean] [off size] - erase 'size' bytes from\n"
+          "    offset 'off' (entire device if not specified)\n"
+          "nand bad - show bad blocks\n"
+          "nand dump[.oob] off - dump page\n"
+          "nand scrub - really clean NAND erasing bad blocks (UNSAFE)\n"
+          "nand markbad off - mark bad block at offset (UNSAFE)\n"
+          "nand biterr off - make a bit error at offset (UNSAFE)\n"
+          "nand lock [tight] [status]\n"
+          "    bring nand to lock state or display locked pages\n"
+          "nand unlock [offset] [size] - unlock section\n");
 
 static int nand_load_image(cmd_tbl_t *cmdtp, nand_info_t *nand,
-                           ulong offset, ulong addr, char *cmd)
+                          ulong offset, ulong addr, char *cmd)
 {
        int r;
        char *ep, *s;
@@ -608,7 +608,7 @@ int do_nandboot(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
                        else
                                addr = CFG_LOAD_ADDR;
                        return nand_load_image(cmdtp, &nand_info[dev->id->num],
-                                              part->offset, addr, argv[0]);
+                                              part->offset, addr, argv[0]);
                }
        }
 #endif
@@ -837,7 +837,7 @@ int do_nand (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
                        off_t off = simple_strtoul (argv[3], NULL, 16);
                        size_t size = simple_strtoul (argv[4], NULL, 16);
                        int cmd = (strncmp (argv[1], "read", 4) == 0) ?
-                                 NANDRW_READ : NANDRW_WRITE;
+                                 NANDRW_READ : NANDRW_WRITE;
                        size_t total;
                        int ret;
                        char *cmdtail = strchr (argv[1], '.');
@@ -997,7 +997,7 @@ int do_nandboot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
            offset);
 
        if (nand_legacy_rw (nand_dev_desc + dev, NANDRW_READ, offset,
-                           SECTORSIZE, NULL, (u_char *)addr)) {
+                           SECTORSIZE, NULL, (u_char *)addr)) {
                printf ("** Read error on %d\n", dev);
                show_boot_progress (-56);
                return 1;
@@ -1028,8 +1028,8 @@ int do_nandboot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
        show_boot_progress (57);
 
        if (nand_legacy_rw (nand_dev_desc + dev, NANDRW_READ,
-                           offset + SECTORSIZE, cnt, NULL,
-                           (u_char *)(addr+SECTORSIZE))) {
+                           offset + SECTORSIZE, cnt, NULL,
+                           (u_char *)(addr+SECTORSIZE))) {
                printf ("** Read error on %d\n", dev);
                show_boot_progress (-58);
                return 1;
index ac4a518b39710fdd0d7bfd468f34e671b310fac1..d5e14ae22240ea8535893429805c9fce7c7a2f4b 100644 (file)
@@ -28,7 +28,7 @@ int do_ymount (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 {
     char *mtpoint = argv[1];
     cmd_yaffs_mount(mtpoint);
-    
+
     return(0);
 }
 
@@ -36,14 +36,14 @@ int do_yumount (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 {
     char *mtpoint = argv[1];
     cmd_yaffs_umount(mtpoint);
-    
+
     return(0);
 }
 
 int do_yls (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 {
     char *dirname = argv[argc-1];
-    
+
     cmd_yaffs_ls(dirname, (argc>2)?1:0);
 
     return(0);
@@ -136,7 +136,7 @@ int do_ydump (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 {
     char *dirname = argv[1];
     if (yaffs_DumpDevStruct(dirname) != 0)
-        printf("yaffs_DumpDevStruct returning error when dumping path: , %s\n", dirname);
+       printf("yaffs_DumpDevStruct returning error when dumping path: , %s\n", dirname);
     return 0;
 }
 
index 0bd1bdbcf00c4c45254774992fd761a4cd8e1925..674c542005c1421c7d0e1512a0683d2de9588256 100644 (file)
@@ -141,14 +141,14 @@ static void set_addr(struct mtd_info *mtd, int column, int page_addr, int oob)
        if (priv->page_size) {
                out_be32(&lbc->fbar, page_addr >> 6);
                out_be32(&lbc->fpar,
-                        ((page_addr << FPAR_LP_PI_SHIFT) & FPAR_LP_PI) |
-                        (oob ? FPAR_LP_MS : 0) | column);
+                        ((page_addr << FPAR_LP_PI_SHIFT) & FPAR_LP_PI) |
+                        (oob ? FPAR_LP_MS : 0) | column);
                buf_num = (page_addr & 1) << 2;
        } else {
                out_be32(&lbc->fbar, page_addr >> 5);
                out_be32(&lbc->fpar,
-                        ((page_addr << FPAR_SP_PI_SHIFT) & FPAR_SP_PI) |
-                        (oob ? FPAR_SP_MS : 0) | column);
+                        ((page_addr << FPAR_SP_PI_SHIFT) & FPAR_SP_PI) |
+                        (oob ? FPAR_SP_MS : 0) | column);
                buf_num = page_addr & 7;
        }
 
@@ -227,24 +227,24 @@ static void fsl_elbc_do_read(struct nand_chip *chip, int oob)
 
        if (priv->page_size) {
                out_be32(&lbc->fir,
-                        (FIR_OP_CW0 << FIR_OP0_SHIFT) |
-                        (FIR_OP_CA  << FIR_OP1_SHIFT) |
-                        (FIR_OP_PA  << FIR_OP2_SHIFT) |
-                        (FIR_OP_CW1 << FIR_OP3_SHIFT) |
-                        (FIR_OP_RBW << FIR_OP4_SHIFT));
+                        (FIR_OP_CW0 << FIR_OP0_SHIFT) |
+                        (FIR_OP_CA  << FIR_OP1_SHIFT) |
+                        (FIR_OP_PA  << FIR_OP2_SHIFT) |
+                        (FIR_OP_CW1 << FIR_OP3_SHIFT) |
+                        (FIR_OP_RBW << FIR_OP4_SHIFT));
 
                out_be32(&lbc->fcr, (NAND_CMD_READ0 << FCR_CMD0_SHIFT) |
-                                   (NAND_CMD_READSTART << FCR_CMD1_SHIFT));
+                                   (NAND_CMD_READSTART << FCR_CMD1_SHIFT));
        } else {
                out_be32(&lbc->fir,
-                        (FIR_OP_CW0 << FIR_OP0_SHIFT) |
-                        (FIR_OP_CA  << FIR_OP1_SHIFT) |
-                        (FIR_OP_PA  << FIR_OP2_SHIFT) |
-                        (FIR_OP_RBW << FIR_OP3_SHIFT));
+                        (FIR_OP_CW0 << FIR_OP0_SHIFT) |
+                        (FIR_OP_CA  << FIR_OP1_SHIFT) |
+                        (FIR_OP_PA  << FIR_OP2_SHIFT) |
+                        (FIR_OP_RBW << FIR_OP3_SHIFT));
 
                if (oob)
                        out_be32(&lbc->fcr,
-                                NAND_CMD_READOOB << FCR_CMD0_SHIFT);
+                                NAND_CMD_READOOB << FCR_CMD0_SHIFT);
                else
                        out_be32(&lbc->fcr, NAND_CMD_READ0 << FCR_CMD0_SHIFT);
        }
@@ -252,7 +252,7 @@ static void fsl_elbc_do_read(struct nand_chip *chip, int oob)
 
 /* cmdfunc send commands to the FCM */
 static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
-                             int column, int page_addr)
+                            int column, int page_addr)
 {
        struct nand_chip *chip = mtd->priv;
        struct fsl_elbc_mtd *priv = chip->priv;
@@ -306,8 +306,8 @@ static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
                vdbg("fsl_elbc_cmdfunc: NAND_CMD_READID.\n");
 
                out_be32(&lbc->fir, (FIR_OP_CW0 << FIR_OP0_SHIFT) |
-                                   (FIR_OP_UA  << FIR_OP1_SHIFT) |
-                                   (FIR_OP_RBW << FIR_OP2_SHIFT));
+                                   (FIR_OP_UA  << FIR_OP1_SHIFT) |
+                                   (FIR_OP_RBW << FIR_OP2_SHIFT));
                out_be32(&lbc->fcr, NAND_CMD_READID << FCR_CMD0_SHIFT);
                /* 5 bytes for manuf, device and exts */
                out_be32(&lbc->fbcr, 5);
@@ -331,13 +331,13 @@ static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
                vdbg("fsl_elbc_cmdfunc: NAND_CMD_ERASE2.\n");
 
                out_be32(&lbc->fir,
-                        (FIR_OP_CW0 << FIR_OP0_SHIFT) |
-                        (FIR_OP_PA  << FIR_OP1_SHIFT) |
-                        (FIR_OP_CM1 << FIR_OP2_SHIFT));
+                        (FIR_OP_CW0 << FIR_OP0_SHIFT) |
+                        (FIR_OP_PA  << FIR_OP1_SHIFT) |
+                        (FIR_OP_CM1 << FIR_OP2_SHIFT));
 
                out_be32(&lbc->fcr,
-                        (NAND_CMD_ERASE1 << FCR_CMD0_SHIFT) |
-                        (NAND_CMD_ERASE2 << FCR_CMD1_SHIFT));
+                        (NAND_CMD_ERASE1 << FCR_CMD0_SHIFT) |
+                        (NAND_CMD_ERASE2 << FCR_CMD1_SHIFT));
 
                out_be32(&lbc->fbcr, 0);
                ctrl->read_bytes = 0;
@@ -360,22 +360,22 @@ static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
                              (NAND_CMD_PAGEPROG << FCR_CMD1_SHIFT);
 
                        out_be32(&lbc->fir,
-                                (FIR_OP_CW0 << FIR_OP0_SHIFT) |
-                                (FIR_OP_CA  << FIR_OP1_SHIFT) |
-                                (FIR_OP_PA  << FIR_OP2_SHIFT) |
-                                (FIR_OP_WB  << FIR_OP3_SHIFT) |
-                                (FIR_OP_CW1 << FIR_OP4_SHIFT));
+                                (FIR_OP_CW0 << FIR_OP0_SHIFT) |
+                                (FIR_OP_CA  << FIR_OP1_SHIFT) |
+                                (FIR_OP_PA  << FIR_OP2_SHIFT) |
+                                (FIR_OP_WB  << FIR_OP3_SHIFT) |
+                                (FIR_OP_CW1 << FIR_OP4_SHIFT));
                } else {
                        fcr = (NAND_CMD_PAGEPROG << FCR_CMD1_SHIFT) |
                              (NAND_CMD_SEQIN << FCR_CMD2_SHIFT);
 
                        out_be32(&lbc->fir,
-                                (FIR_OP_CW0 << FIR_OP0_SHIFT) |
-                                (FIR_OP_CM2 << FIR_OP1_SHIFT) |
-                                (FIR_OP_CA  << FIR_OP2_SHIFT) |
-                                (FIR_OP_PA  << FIR_OP3_SHIFT) |
-                                (FIR_OP_WB  << FIR_OP4_SHIFT) |
-                                (FIR_OP_CW1 << FIR_OP5_SHIFT));
+                                (FIR_OP_CW0 << FIR_OP0_SHIFT) |
+                                (FIR_OP_CM2 << FIR_OP1_SHIFT) |
+                                (FIR_OP_CA  << FIR_OP2_SHIFT) |
+                                (FIR_OP_PA  << FIR_OP3_SHIFT) |
+                                (FIR_OP_WB  << FIR_OP4_SHIFT) |
+                                (FIR_OP_CW1 << FIR_OP5_SHIFT));
 
                        if (column >= mtd->writesize) {
                                /* OOB area --> READOOB */
@@ -430,7 +430,7 @@ static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
                        fsl_elbc_run_command(mtd);
 
                        memcpy_fromio(ctrl->oob_poi + 6,
-                                     &ctrl->addr[ctrl->index], 3);
+                                     &ctrl->addr[ctrl->index], 3);
                        ctrl->index += 3;
                }
 
@@ -442,8 +442,8 @@ static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
        /* Note - it does not wait for the ready line */
        case NAND_CMD_STATUS:
                out_be32(&lbc->fir,
-                        (FIR_OP_CM0 << FIR_OP0_SHIFT) |
-                        (FIR_OP_RBW << FIR_OP1_SHIFT));
+                        (FIR_OP_CM0 << FIR_OP0_SHIFT) |
+                        (FIR_OP_RBW << FIR_OP1_SHIFT));
                out_be32(&lbc->fcr, NAND_CMD_STATUS << FCR_CMD0_SHIFT);
                out_be32(&lbc->fbcr, 1);
                set_addr(mtd, 0, 0, 0);
@@ -467,7 +467,7 @@ static void fsl_elbc_cmdfunc(struct mtd_info *mtd, unsigned int command,
 
        default:
                printf("fsl_elbc_cmdfunc: error, unsupported command 0x%x.\n",
-                       command);
+                       command);
        }
 }
 
@@ -559,7 +559,7 @@ static void fsl_elbc_read_buf(struct mtd_info *mtd, u8 *buf, int len)
  * Verify buffer against the FCM Controller Data Buffer
  */
 static int fsl_elbc_verify_buf(struct mtd_info *mtd,
-                               const u_char *buf, int len)
+                              const u_char *buf, int len)
 {
        struct nand_chip *chip = mtd->priv;
        struct fsl_elbc_mtd *priv = chip->priv;
@@ -603,8 +603,8 @@ static int fsl_elbc_wait(struct mtd_info *mtd, struct nand_chip *chip)
        /* Use READ_STATUS command, but wait for the device to be ready */
        ctrl->use_mdr = 0;
        out_be32(&lbc->fir,
-                (FIR_OP_CW0 << FIR_OP0_SHIFT) |
-                (FIR_OP_RBW << FIR_OP1_SHIFT));
+                (FIR_OP_CW0 << FIR_OP0_SHIFT) |
+                (FIR_OP_RBW << FIR_OP1_SHIFT));
        out_be32(&lbc->fcr, NAND_CMD_STATUS << FCR_CMD0_SHIFT);
        out_be32(&lbc->fbcr, 1);
        set_addr(mtd, 0, 0, 0);
@@ -623,8 +623,8 @@ static int fsl_elbc_wait(struct mtd_info *mtd, struct nand_chip *chip)
 }
 
 static int fsl_elbc_read_page(struct mtd_info *mtd,
-                              struct nand_chip *chip,
-                              uint8_t *buf)
+                             struct nand_chip *chip,
+                             uint8_t *buf)
 {
        fsl_elbc_read_buf(mtd, buf, mtd->writesize);
        fsl_elbc_read_buf(mtd, chip->oob_poi, mtd->oobsize);
@@ -639,8 +639,8 @@ static int fsl_elbc_read_page(struct mtd_info *mtd,
  * waitfunc.
  */
 static void fsl_elbc_write_page(struct mtd_info *mtd,
-                                struct nand_chip *chip,
-                                const uint8_t *buf)
+                               struct nand_chip *chip,
+                               const uint8_t *buf)
 {
        struct fsl_elbc_mtd *priv = chip->priv;
        struct fsl_elbc_ctrl *ctrl = priv->ctrl;
@@ -737,8 +737,8 @@ int board_nand_init(struct nand_chip *nand)
                nand->ecc.mode = NAND_ECC_HW;
 
                nand->ecc.layout = (priv->fmr & FMR_ECCM) ?
-                                  &fsl_elbc_oob_sp_eccm1 :
-                                  &fsl_elbc_oob_sp_eccm0;
+                                  &fsl_elbc_oob_sp_eccm1 :
+                                  &fsl_elbc_oob_sp_eccm0;
 
                nand->ecc.size = 512;
                nand->ecc.bytes = 3;
@@ -758,8 +758,8 @@ int board_nand_init(struct nand_chip *nand)
                if ((br & BR_DECC) == BR_DECC_CHK_GEN) {
                        nand->ecc.steps = 4;
                        nand->ecc.layout = (priv->fmr & FMR_ECCM) ?
-                                          &fsl_elbc_oob_lp_eccm1 :
-                                          &fsl_elbc_oob_lp_eccm0;
+                                          &fsl_elbc_oob_lp_eccm1 :
+                                          &fsl_elbc_oob_lp_eccm0;
                }
        }
 
index 22820d55d02c64b93ac6b17b62c6b93744bca870..52b3d21b8f04d6352eb42158c56aa13143445929 100644 (file)
@@ -435,7 +435,7 @@ int nand_unlock(nand_info_t *meminfo, ulong start, ulong length)
  * @return image length including bad blocks
  */
 static size_t get_len_incl_bad (nand_info_t *nand, size_t offset,
-                                const size_t length)
+                               const size_t length)
 {
        size_t len_incl_bad = 0;
        size_t len_excl_bad = 0;
@@ -472,7 +472,7 @@ static size_t get_len_incl_bad (nand_info_t *nand, size_t offset,
  * @return             0 in case of success
  */
 int nand_write_skip_bad(nand_info_t *nand, size_t offset, size_t *length,
-                        u_char *buffer)
+                       u_char *buffer)
 {
        int rval;
        size_t left_to_write = *length;
@@ -497,7 +497,7 @@ int nand_write_skip_bad(nand_info_t *nand, size_t offset, size_t *length,
                rval = nand_write (nand, offset, length, buffer);
                if (rval != 0) {
                        printf ("NAND write to offset %x failed %d\n",
-                               offset, rval);
+                               offset, rval);
                        return rval;
                }
        }
@@ -521,7 +521,7 @@ int nand_write_skip_bad(nand_info_t *nand, size_t offset, size_t *length,
                rval = nand_write (nand, offset, &write_size, p_buffer);
                if (rval != 0) {
                        printf ("NAND write to offset %x failed %d\n",
-                               offset, rval);
+                               offset, rval);
                        *length -= left_to_write;
                        return rval;
                }
@@ -567,7 +567,7 @@ int nand_read_skip_bad(nand_info_t *nand, size_t offset, size_t *length,
                rval = nand_read (nand, offset, length, buffer);
                if (rval != 0) {
                        printf ("NAND read from offset %x failed %d\n",
-                               offset, rval);
+                               offset, rval);
                        return rval;
                }
        }
@@ -591,7 +591,7 @@ int nand_read_skip_bad(nand_info_t *nand, size_t offset, size_t *length,
                rval = nand_read (nand, offset, &read_length, p_buffer);
                if (rval != 0) {
                        printf ("NAND read from offset %x failed %d\n",
-                               offset, rval);
+                               offset, rval);
                        *length -= left_to_read;
                        return rval;
                }
index 8f12fa26e062cf670b36163ba3c6ffb1a16a90e9..9ce68e1a47c90905763b3cad235f7135d416ab70 100644 (file)
@@ -292,13 +292,13 @@ static int onenand_wait(struct mtd_info *mtd, int state)
 
        if (ctrl & ONENAND_CTRL_ERROR) {
                MTDDEBUG (MTD_DEBUG_LEVEL0,
-                         "onenand_wait: controller error = 0x%04x\n", ctrl);
+                         "onenand_wait: controller error = 0x%04x\n", ctrl);
                return -EAGAIN;
        }
 
        if (ctrl & ONENAND_CTRL_LOCK) {
                MTDDEBUG (MTD_DEBUG_LEVEL0,
-                         "onenand_wait: it's locked error = 0x%04x\n", ctrl);
+                         "onenand_wait: it's locked error = 0x%04x\n", ctrl);
                return -EIO;
        }
 
@@ -306,7 +306,7 @@ static int onenand_wait(struct mtd_info *mtd, int state)
                ecc = this->read_word(this->base + ONENAND_REG_ECC_STATUS);
                if (ecc & ONENAND_ECC_2BIT_ALL) {
                        MTDDEBUG (MTD_DEBUG_LEVEL0,
-                                 "onenand_wait: ECC error = 0x%04x\n", ecc);
+                                 "onenand_wait: ECC error = 0x%04x\n", ecc);
                        return -EBADMSG;
                }
        }
@@ -487,7 +487,7 @@ static int onenand_update_bufferram(struct mtd_info *mtd, loff_t addr,
  * Invalidate BufferRAM information
  */
 static void onenand_invalidate_bufferram(struct mtd_info *mtd, loff_t addr,
-                                         unsigned int len)
+                                        unsigned int len)
 {
        struct onenand_chip *this = mtd->priv;
        int i;
@@ -547,13 +547,13 @@ static int onenand_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
        int ret = 0;
 
        MTDDEBUG (MTD_DEBUG_LEVEL3, "onenand_read_ecc: "
-                 "from = 0x%08x, len = %i\n",
-                 (unsigned int)from, (int)len);
+                 "from = 0x%08x, len = %i\n",
+                 (unsigned int)from, (int)len);
 
        /* Do not allow reads past end of device */
        if ((from + len) > mtd->size) {
                MTDDEBUG (MTD_DEBUG_LEVEL0, "onenand_read_ecc: "
-                         "Attempt read beyond end of device\n");
+                         "Attempt read beyond end of device\n");
                *retlen = 0;
                return -EINVAL;
        }
@@ -585,7 +585,7 @@ static int onenand_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
 
                if (ret) {
                        MTDDEBUG (MTD_DEBUG_LEVEL0,
-                                 "onenand_read_ecc: read failed = %d\n", ret);
+                                 "onenand_read_ecc: read failed = %d\n", ret);
                        break;
                }
 
@@ -639,8 +639,8 @@ int onenand_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
        int ret = 0;
 
        MTDDEBUG (MTD_DEBUG_LEVEL3, "onenand_read_oob: "
-                 "from = 0x%08x, len = %i\n",
-                 (unsigned int)from, (int)len);
+                 "from = 0x%08x, len = %i\n",
+                 (unsigned int)from, (int)len);
 
        /* Initialize return length value */
        *retlen = 0;
@@ -648,7 +648,7 @@ int onenand_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
        /* Do not allow reads past end of device */
        if (unlikely((from + len) > mtd->size)) {
                MTDDEBUG (MTD_DEBUG_LEVEL0, "onenand_read_oob: "
-                         "Attempt read beyond end of device\n");
+                         "Attempt read beyond end of device\n");
                return -EINVAL;
        }
 
@@ -677,7 +677,7 @@ int onenand_read_oob(struct mtd_info *mtd, loff_t from, size_t len,
 
                if (ret) {
                        MTDDEBUG (MTD_DEBUG_LEVEL0,
-                                 "onenand_read_oob: read failed = %d\n", ret);
+                                 "onenand_read_oob: read failed = %d\n", ret);
                        break;
                }
 
@@ -756,8 +756,8 @@ static int onenand_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
        int ret = 0;
 
        MTDDEBUG (MTD_DEBUG_LEVEL3, "onenand_write_ecc: "
-                 "to = 0x%08x, len = %i\n",
-                 (unsigned int)to, (int)len);
+                 "to = 0x%08x, len = %i\n",
+                 (unsigned int)to, (int)len);
 
        /* Initialize retlen, in case of early exit */
        *retlen = 0;
@@ -765,14 +765,14 @@ static int onenand_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
        /* Do not allow writes past end of device */
        if (unlikely((to + len) > mtd->size)) {
                MTDDEBUG (MTD_DEBUG_LEVEL0, "onenand_write_ecc: "
-                         "Attempt write to past end of device\n");
+                         "Attempt write to past end of device\n");
                return -EINVAL;
        }
 
        /* Reject writes, which are not page aligned */
        if (unlikely(NOTALIGNED(to)) || unlikely(NOTALIGNED(len))) {
                MTDDEBUG (MTD_DEBUG_LEVEL0, "onenand_write_ecc: "
-                         "Attempt to write not page aligned data\n");
+                         "Attempt to write not page aligned data\n");
                return -EINVAL;
        }
 
@@ -796,7 +796,7 @@ static int onenand_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
                ret = this->wait(mtd, FL_WRITING);
                if (ret) {
                        MTDDEBUG (MTD_DEBUG_LEVEL0,
-                                 "onenand_write_ecc: write filaed %d\n", ret);
+                                 "onenand_write_ecc: write filaed %d\n", ret);
                        break;
                }
 
@@ -806,7 +806,7 @@ static int onenand_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
                ret = onenand_verify_page(mtd, (u_char *) buf, to);
                if (ret) {
                        MTDDEBUG (MTD_DEBUG_LEVEL0,
-                                 "onenand_write_ecc: verify failed %d\n", ret);
+                                 "onenand_write_ecc: verify failed %d\n", ret);
                        break;
                }
 
@@ -860,8 +860,8 @@ int onenand_write_oob(struct mtd_info *mtd, loff_t to, size_t len,
        int written = 0;
 
        MTDDEBUG (MTD_DEBUG_LEVEL3, "onenand_write_oob: "
-                 "to = 0x%08x, len = %i\n",
-                 (unsigned int)to, (int)len);
+                 "to = 0x%08x, len = %i\n",
+                 (unsigned int)to, (int)len);
 
        /* Initialize retlen, in case of early exit */
        *retlen = 0;
@@ -869,7 +869,7 @@ int onenand_write_oob(struct mtd_info *mtd, loff_t to, size_t len,
        /* Do not allow writes past end of device */
        if (unlikely((to + len) > mtd->size)) {
                MTDDEBUG (MTD_DEBUG_LEVEL0, "onenand_write_oob: "
-                         "Attempt write to past end of device\n");
+                         "Attempt write to past end of device\n");
                return -EINVAL;
        }
 
@@ -948,28 +948,28 @@ int onenand_erase(struct mtd_info *mtd, struct erase_info *instr)
        int ret = 0;
 
        MTDDEBUG (MTD_DEBUG_LEVEL3, "onenand_erase: start = 0x%08x, len = %i\n",
-                 (unsigned int)instr->addr, (unsigned int)instr->len);
+                 (unsigned int)instr->addr, (unsigned int)instr->len);
 
        block_size = (1 << this->erase_shift);
 
        /* Start address must align on block boundary */
        if (unlikely(instr->addr & (block_size - 1))) {
                MTDDEBUG (MTD_DEBUG_LEVEL0,
-                         "onenand_erase: Unaligned address\n");
+                         "onenand_erase: Unaligned address\n");
                return -EINVAL;
        }
 
        /* Length must align on block boundary */
        if (unlikely(instr->len & (block_size - 1))) {
                MTDDEBUG (MTD_DEBUG_LEVEL0,
-                         "onenand_erase: Length not block aligned\n");
+                         "onenand_erase: Length not block aligned\n");
                return -EINVAL;
        }
 
        /* Do not allow erase past end of device */
        if (unlikely((instr->len + instr->addr) > mtd->size)) {
                MTDDEBUG (MTD_DEBUG_LEVEL0,
-                         "onenand_erase: Erase past end of device\n");
+                         "onenand_erase: Erase past end of device\n");
                return -EINVAL;
        }
 
@@ -997,11 +997,11 @@ int onenand_erase(struct mtd_info *mtd, struct erase_info *instr)
                if (ret) {
                        if (ret == -EPERM)
                                MTDDEBUG (MTD_DEBUG_LEVEL0, "onenand_erase: "
-                                         "Device is write protected!!!\n");
+                                         "Device is write protected!!!\n");
                        else
                                MTDDEBUG (MTD_DEBUG_LEVEL0, "onenand_erase: "
-                                         "Failed erase, block %d\n",
-                                         (unsigned)(addr >> this->erase_shift));
+                                         "Failed erase, block %d\n",
+                                         (unsigned)(addr >> this->erase_shift));
                        instr->state = MTD_ERASE_FAILED;
                        instr->fail_addr = addr;
                        goto erase_exit;
index ab8b27f1da9f10e3c181defeabf656931059dca7..a2ef5e22f67b6eade8ed593a26a53eff4b2913fa 100644 (file)
@@ -31,7 +31,7 @@ SRCS    := $(COBJS-y:.o=.c)
 OBJS    := $(addprefix $(obj),$(COBJS-y))
 
 # -DCONFIG_YAFFS_NO_YAFFS1
-CFLAGS +=    -DCONFIG_YAFFS_DIRECT -DCONFIG_YAFFS_SHORT_NAMES_IN_RAM -DCONFIG_YAFFS_YAFFS2 -DNO_Y_INLINE -DLINUX_VERSION_CODE=0x20622 
+CFLAGS +=    -DCONFIG_YAFFS_DIRECT -DCONFIG_YAFFS_SHORT_NAMES_IN_RAM -DCONFIG_YAFFS_YAFFS2 -DNO_Y_INLINE -DLINUX_VERSION_CODE=0x20622
 
 all:  $(LIB)
 
@@ -53,4 +53,3 @@ include $(SRCTREE)/rules.mk
 sinclude $(obj).depend
 
 #########################################################################
-
index 589ae8dd344151e2e5824cfc34eb72c6e8341497..3851e360d817dbcf3e3f4a9acdc1d36d10a31d46 100644 (file)
@@ -8,7 +8,7 @@ in YAFFS2 mode (CONFIG_YAFFS_YAFFS2).
 
 A note on licencing
 -------------------
-YAFFS is available under the GPL and via alternative licensing 
+YAFFS is available under the GPL and via alternative licensing
 arrangements with Aleph One. If you're using YAFFS as a Linux kernel
 file system then it will be under the GPL. For use in other situations
 you should discuss licensing issues with Aleph One.
@@ -17,10 +17,10 @@ you should discuss licensing issues with Aleph One.
 Terminology
 -----------
 Page -  NAND addressable unit (normally 512b or 2Kbyte size) - can
-        be read, written, marked bad. Has associated OOB.
+       be read, written, marked bad. Has associated OOB.
 Block - Eraseable unit. 64 Pages. (128K on 2K NAND, 32K on 512b NAND)
 OOB -   'spare area' of each page for ECC, bad block marked and YAFFS
-        tags. 16 bytes per 512b - 64 bytes for 2K page size.
+       tags. 16 bytes per 512b - 64 bytes for 2K page size.
 Chunk - Basic YAFFS addressable unit. Same size as Page.
 Object - YAFFS Object: File, Directory, Link, Device etc.
 
@@ -48,28 +48,28 @@ is managed by moving deleted objects to the special, hidden 'unlinked'
 directory. These records are preserved until all the pages containing
 the object have been erased (We know when this happen by keeping a
 count of chunks remaining on the system for each object - when it
-reaches zero the object really is gone). 
+reaches zero the object really is gone).
 
 When data in a file is overwritten, the relevant chunks are replaced
 by writing new pages to flash containing the new data but the same
-tags. 
+tags.
 
-Pages are also marked with a short (2 bit) serial number that 
-increments each time the page at this position is incremented. The 
-reason for this is that if power loss/crash/other act of demonic 
-forces happens before the replaced page is marked as discarded, it is 
-possible to have two pages with the same tags. The serial number is 
+Pages are also marked with a short (2 bit) serial number that
+increments each time the page at this position is incremented. The
+reason for this is that if power loss/crash/other act of demonic
+forces happens before the replaced page is marked as discarded, it is
+possible to have two pages with the same tags. The serial number is
 used to arbitrate.
 
-A block containing only discarded pages (termed a dirty block) is an 
+A block containing only discarded pages (termed a dirty block) is an
 obvious candidate for garbage collection. Otherwise valid pages can be
-copied off a block thus rendering the whole block discarded and ready 
-for garbage collection.  
-          
+copied off a block thus rendering the whole block discarded and ready
+for garbage collection.
+
 In theory you don't need to hold the file structure in RAM... you
 could just scan the whole flash looking for pages when you need them.
 In practice though you'd want better file access times than that! The
-mechanism proposed here is to have a list of __u16 page addresses 
+mechanism proposed here is to have a list of __u16 page addresses
 associated with each file. Since there are 2^18 pages in a 128MB NAND,
 a __u16 is insufficient to uniquely identify a page but is does
 identify a group of 4 pages - a small enough region to search
@@ -77,17 +77,17 @@ exhaustively. This mechanism is clearly expandable to larger NAND
 devices - within reason. The RAM overhead with this approach is approx
 2 bytes per page - 512kB of RAM for a whole 128MB NAND.
 
-Boot-time scanning to build the file structure lists only requires    
+Boot-time scanning to build the file structure lists only requires
 one pass reading NAND. If proper shutdowns happen the current RAM
 summary of the filesystem status is saved to flash, called
 'checkpointing'. This saves re-scanning the flash on startup, and gives
-huge boot/mount time savings. 
+huge boot/mount time savings.
 
 YAFFS regenerates its state by 'replaying the tape'  - i.e. by
 scanning the chunks in their allocation order (i.e. block sequence ID
 order), which is usually different form the media block order. Each
 block is still only read once - starting from the end of the media and
-working back. 
+working back.
 
 YAFFS tags in YAFFS1 mode:
 
@@ -109,27 +109,27 @@ YAFFS tags in YAFFS2 mode:
  12 bytes ECC on data (3 bytes per 256 bytes of data)
 
 
-Page allocation and garbage collection       
-         
-Pages are allocated sequentially from the currently selected block.  
-When all the pages in the block are filled, another clean block is 
-selected for allocation. At least two or three clean blocks are 
-reserved for garbage collection purposes. If there are insufficient 
-clean blocks available, then a dirty block ( ie one containing only 
+Page allocation and garbage collection
+
+Pages are allocated sequentially from the currently selected block.
+When all the pages in the block are filled, another clean block is
+selected for allocation. At least two or three clean blocks are
+reserved for garbage collection purposes. If there are insufficient
+clean blocks available, then a dirty block ( ie one containing only
 discarded pages) is erased to free it up as a clean block. If no dirty
-blocks are available, then the dirtiest block is selected for garbage 
-collection.  
-          
-Garbage collection is performed by copying the valid data pages into 
-new data pages thus rendering all the pages in this block dirty and 
-freeing it up for erasure. I also like the idea of selecting a block 
+blocks are available, then the dirtiest block is selected for garbage
+collection.
+
+Garbage collection is performed by copying the valid data pages into
+new data pages thus rendering all the pages in this block dirty and
+freeing it up for erasure. I also like the idea of selecting a block
 at random some small percentage of the time - thus reducing the chance
 of wear differences.
 
 YAFFS is single-threaded. Garbage-collection is done as a parasitic
 task of writing data. So each time some data is written, a bit of
 pending garbage collection is done. More pages are garbage-collected
-when free space is tight. 
+when free space is tight.
 
 
 Flash writing
@@ -143,7 +143,7 @@ This comes as a side-effect of the block-allocation strategy. Data is
 always written on the next free block, so they are all used equally.
 Blocks containing data that is written but never erased will not get
 back into the free list, so wear is levelled over only blocks which
-are free or become free, not blocks which never change. 
+are free or become free, not blocks which never change.
 
 
 
@@ -183,7 +183,7 @@ image just had to know which bytes to use for YAFFS Tags.
 
 Option 3 is hardest as the image creator needs to know exactly what
 ECC bytes, endianness and algorithm to use as well as which bytes are
-available to YAFFS. 
+available to YAFFS.
 
 mkyaffs2image creates an image suitable for option 3 for the
 particular case of yaffs2 on 2K page NAND with default MTD layout.
@@ -195,7 +195,7 @@ Bootloaders
 -----------
 
 A bootloader using YAFFS needs to know how MTD is laying out the OOB
-so that it can skip bad blocks. 
+so that it can skip bad blocks.
 
 YAFFS Tracing
 -------------
index 9acda79e8608e8df254576c0166fd15a1fe4efd8..f6e53610d6b3995fce1a33b8c1814743114ca293 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
@@ -15,7 +15,7 @@
 
 /*
  * This file is just holds extra declarations used during development.
- * Most of these are from kernel includes placed here so we can use them in 
+ * Most of these are from kernel includes placed here so we can use them in
  * applications.
  *
  */
@@ -192,7 +192,7 @@ static __inline__ void list_splice(struct list_head *list,
  */
 #define list_for_each(pos, head) \
        for (pos = (head)->next, prefetch(pos->next); pos != (head); \
-               pos = pos->next, prefetch(pos->next))
+               pos = pos->next, prefetch(pos->next))
 
 /**
  * list_for_each_safe  -       iterate over a list safe against removal
index f97ba4b427280d0fb5a7447ecd5cc14466166bef..230f78fb899d5d82f099a3ad6ae43a3e0ccac607 100644 (file)
@@ -26,27 +26,27 @@ static int yaffs_CheckpointSpaceOk(yaffs_Device *dev)
 {
 
        int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks;
-       
+
        T(YAFFS_TRACE_CHECKPOINT,
                (TSTR("checkpt blocks available = %d" TENDSTR),
                blocksAvailable));
-               
-       
+
+
        return (blocksAvailable <= 0) ? 0 : 1;
 }
 
 
 static int yaffs_CheckpointErase(yaffs_Device *dev)
 {
-       
+
        int i;
-       
 
-       if(!dev->eraseBlockInNAND)      
+
+       if(!dev->eraseBlockInNAND)
                return 0;
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("checking blocks %d to %d"TENDSTR),
                dev->internalStartBlock,dev->internalEndBlock));
-               
+
        for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
                yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
                if(bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT){
@@ -62,9 +62,9 @@ static int yaffs_CheckpointErase(yaffs_Device *dev)
                        }
                }
        }
-       
+
        dev->blocksInCheckpoint = 0;
-       
+
        return 1;
 }
 
@@ -76,11 +76,11 @@ static void yaffs_CheckpointFindNextErasedBlock(yaffs_Device *dev)
        T(YAFFS_TRACE_CHECKPOINT,
                (TSTR("allocating checkpt block: erased %d reserved %d avail %d next %d "TENDSTR),
                dev->nErasedBlocks,dev->nReservedBlocks,blocksAvailable,dev->checkpointNextBlock));
-               
+
        if(dev->checkpointNextBlock >= 0 &&
           dev->checkpointNextBlock <= dev->internalEndBlock &&
           blocksAvailable > 0){
-       
+
                for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){
                        yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
                        if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY){
@@ -92,7 +92,7 @@ static void yaffs_CheckpointFindNextErasedBlock(yaffs_Device *dev)
                }
        }
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("out of checkpt blocks"TENDSTR)));
-       
+
        dev->checkpointNextBlock = -1;
        dev->checkpointCurrentBlock = -1;
 }
@@ -101,19 +101,19 @@ static void yaffs_CheckpointFindNextCheckpointBlock(yaffs_Device *dev)
 {
        int  i;
        yaffs_ExtendedTags tags;
-       
+
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: start:  blocks %d next %d" TENDSTR),
                dev->blocksInCheckpoint, dev->checkpointNextBlock));
-               
-       if(dev->blocksInCheckpoint < dev->checkpointMaxBlocks) 
+
+       if(dev->blocksInCheckpoint < dev->checkpointMaxBlocks)
                for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){
                        int chunk = i * dev->nChunksPerBlock;
                        int realignedChunk = chunk - dev->chunkOffset;
 
                        dev->readChunkWithTagsFromNAND(dev,realignedChunk,NULL,&tags);
-                       T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR), 
+                       T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR),
                                i, tags.objectId,tags.sequenceNumber,tags.eccResult));
-                                                     
+
                        if(tags.sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA){
                                /* Right kind of block */
                                dev->checkpointNextBlock = tags.objectId;
@@ -134,7 +134,7 @@ static void yaffs_CheckpointFindNextCheckpointBlock(yaffs_Device *dev)
 
 int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting)
 {
-       
+
        /* Got the functions we need? */
        if (!dev->writeChunkWithTagsToNAND ||
            !dev->readChunkWithTagsFromNAND ||
@@ -144,31 +144,31 @@ int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting)
 
        if(forWriting && !yaffs_CheckpointSpaceOk(dev))
                return 0;
-                       
+
        if(!dev->checkpointBuffer)
                dev->checkpointBuffer = YMALLOC_DMA(dev->nDataBytesPerChunk);
        if(!dev->checkpointBuffer)
                return 0;
 
-       
+
        dev->checkpointPageSequence = 0;
-       
+
        dev->checkpointOpenForWrite = forWriting;
-       
+
        dev->checkpointByteCount = 0;
        dev->checkpointSum = 0;
        dev->checkpointXor = 0;
        dev->checkpointCurrentBlock = -1;
        dev->checkpointCurrentChunk = -1;
        dev->checkpointNextBlock = dev->internalStartBlock;
-       
+
        /* Erase all the blocks in the checkpoint area */
        if(forWriting){
                memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk);
                dev->checkpointByteOffset = 0;
                return yaffs_CheckpointErase(dev);
-               
-               
+
+
        } else {
                int i;
                /* Set to a value that will kick off a read */
@@ -181,7 +181,7 @@ int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting)
                for(i = 0; i < dev->checkpointMaxBlocks; i++)
                        dev->checkpointBlockList[i] = -1;
        }
-       
+
        return 1;
 }
 
@@ -200,15 +200,15 @@ static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev)
        int realignedChunk;
 
        yaffs_ExtendedTags tags;
-       
+
        if(dev->checkpointCurrentBlock < 0){
                yaffs_CheckpointFindNextErasedBlock(dev);
                dev->checkpointCurrentChunk = 0;
        }
-       
+
        if(dev->checkpointCurrentBlock < 0)
                return 0;
-       
+
        tags.chunkDeleted = 0;
        tags.objectId = dev->checkpointNextBlock; /* Hint to next place to look */
        tags.chunkId = dev->checkpointPageSequence + 1;
@@ -221,25 +221,25 @@ static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev)
                bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT;
                dev->blocksInCheckpoint++;
        }
-       
+
        chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + dev->checkpointCurrentChunk;
 
-       
+
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR),
-               chunk, dev->checkpointCurrentBlock, dev->checkpointCurrentChunk,tags.objectId,tags.chunkId)); 
-       
+               chunk, dev->checkpointCurrentBlock, dev->checkpointCurrentChunk,tags.objectId,tags.chunkId));
+
        realignedChunk = chunk - dev->chunkOffset;
-       
+
        dev->writeChunkWithTagsToNAND(dev,realignedChunk,dev->checkpointBuffer,&tags);
        dev->checkpointByteOffset = 0;
-       dev->checkpointPageSequence++;     
+       dev->checkpointPageSequence++;
        dev->checkpointCurrentChunk++;
        if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock){
                dev->checkpointCurrentChunk = 0;
                dev->checkpointCurrentBlock = -1;
        }
        memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk);
-       
+
        return 1;
 }
 
@@ -249,37 +249,37 @@ int yaffs_CheckpointWrite(yaffs_Device *dev,const void *data, int nBytes)
        int i=0;
        int ok = 1;
 
-       
+
        __u8 * dataBytes = (__u8 *)data;
-       
-       
+
+
 
        if(!dev->checkpointBuffer)
                return 0;
-               
+
        if(!dev->checkpointOpenForWrite)
                return -1;
 
        while(i < nBytes && ok) {
-               
 
-               
+
+
                dev->checkpointBuffer[dev->checkpointByteOffset] = *dataBytes ;
                dev->checkpointSum += *dataBytes;
                dev->checkpointXor ^= *dataBytes;
-                
+
                dev->checkpointByteOffset++;
                i++;
                dataBytes++;
                dev->checkpointByteCount++;
-               
-               
+
+
                if(dev->checkpointByteOffset < 0 ||
-                  dev->checkpointByteOffset >= dev->nDataBytesPerChunk) 
+                  dev->checkpointByteOffset >= dev->nDataBytesPerChunk)
                        ok = yaffs_CheckpointFlushBuffer(dev);
 
        }
-       
+
        return  i;
 }
 
@@ -289,12 +289,12 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
        int ok = 1;
        yaffs_ExtendedTags tags;
 
-       
+
        int chunk;
        int realignedChunk;
 
        __u8 *dataBytes = (__u8 *)data;
-               
+
        if(!dev->checkpointBuffer)
                return 0;
 
@@ -302,31 +302,31 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
                return -1;
 
        while(i < nBytes && ok) {
-       
-       
+
+
                if(dev->checkpointByteOffset < 0 ||
                   dev->checkpointByteOffset >= dev->nDataBytesPerChunk) {
-                  
+
                        if(dev->checkpointCurrentBlock < 0){
                                yaffs_CheckpointFindNextCheckpointBlock(dev);
                                dev->checkpointCurrentChunk = 0;
                        }
-                       
+
                        if(dev->checkpointCurrentBlock < 0)
                                ok = 0;
                        else {
-                       
-                               chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + 
+
+                               chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock +
                                          dev->checkpointCurrentChunk;
 
                                realignedChunk = chunk - dev->chunkOffset;
 
                                /* read in the next chunk */
                                /* printf("read checkpoint page %d\n",dev->checkpointPage); */
-                               dev->readChunkWithTagsFromNAND(dev, realignedChunk, 
+                               dev->readChunkWithTagsFromNAND(dev, realignedChunk,
                                                               dev->checkpointBuffer,
                                                              &tags);
-                                                     
+
                                if(tags.chunkId != (dev->checkpointPageSequence + 1) ||
                                   tags.sequenceNumber != YAFFS_SEQUENCE_CHECKPOINT_DATA)
                                   ok = 0;
@@ -334,12 +334,12 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
                                dev->checkpointByteOffset = 0;
                                dev->checkpointPageSequence++;
                                dev->checkpointCurrentChunk++;
-                       
+
                                if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock)
                                        dev->checkpointCurrentBlock = -1;
                        }
                }
-               
+
                if(ok){
                        *dataBytes = dev->checkpointBuffer[dev->checkpointByteOffset];
                        dev->checkpointSum += *dataBytes;
@@ -350,14 +350,14 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
                        dev->checkpointByteCount++;
                }
        }
-       
+
        return  i;
 }
 
 int yaffs_CheckpointClose(yaffs_Device *dev)
 {
 
-       if(dev->checkpointOpenForWrite){        
+       if(dev->checkpointOpenForWrite){
                if(dev->checkpointByteOffset != 0)
                        yaffs_CheckpointFlushBuffer(dev);
        } else {
@@ -377,19 +377,19 @@ int yaffs_CheckpointClose(yaffs_Device *dev)
        dev->nFreeChunks -= dev->blocksInCheckpoint * dev->nChunksPerBlock;
        dev->nErasedBlocks -= dev->blocksInCheckpoint;
 
-               
+
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint byte count %d" TENDSTR),
                        dev->checkpointByteCount));
-                       
+
        if(dev->checkpointBuffer){
-               /* free the buffer */   
+               /* free the buffer */
                YFREE(dev->checkpointBuffer);
                dev->checkpointBuffer = NULL;
                return 1;
        }
        else
                return 0;
-       
+
 }
 
 int yaffs_CheckpointInvalidateStream(yaffs_Device *dev)
index f4b0c7dcaaf4b03e967179df46bf3b44c8e975f0..e59d151a276cddf50b85596018bb5028e0b329ca 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
@@ -32,4 +32,3 @@ int yaffs_CheckpointInvalidateStream(yaffs_Device *dev);
 
 
 #endif
-
index a05a6b583b634e10317c1aefd00171ef058dac0e..1b4a05d71b9e63b480645b01d3752d0c8dea4108 100644 (file)
@@ -14,9 +14,9 @@
 /*
  * This code implements the ECC algorithm used in SmartMedia.
  *
- * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes. 
+ * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes.
  * The two unused bit are set to 1.
- * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC 
+ * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC
  * blocks are used on a 512-byte NAND page.
  *
  */
@@ -231,8 +231,8 @@ int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc,
                return 1; /* Corrected the error */
        }
 
-       if ((yaffs_CountBits(d0) + 
-            yaffs_CountBits(d1) + 
+       if ((yaffs_CountBits(d0) +
+            yaffs_CountBits(d1) +
             yaffs_CountBits(d2)) ==  1) {
                /* Reccoverable error in ecc */
 
@@ -242,7 +242,7 @@ int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc,
 
                return 1; /* Corrected the error */
        }
-       
+
        /* Unrecoverable error */
 
        return -1;
@@ -296,7 +296,7 @@ int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes,
        if ((cDelta | lDelta | lDeltaPrime) == 0)
                return 0; /* no error */
 
-       if (lDelta == ~lDeltaPrime && 
+       if (lDelta == ~lDeltaPrime &&
            (((cDelta ^ (cDelta >> 1)) & 0x15) == 0x15))
        {
                /* Single bit (recoverable) error in data */
@@ -312,7 +312,7 @@ int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes,
 
                if(lDelta >= nBytes)
                        return -1;
-                       
+
                data[lDelta] ^= (1 << bit);
 
                return 1; /* corrected */
index 40fd02b9653ec750fe66ce4f991a3121e0310415..79bc3d117146d4d08f823dca2ec3700cc0c9bf9e 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
@@ -16,9 +16,9 @@
  /*
   * This code implements the ECC algorithm used in SmartMedia.
   *
-  * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes. 
+  * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes.
   * The two unused bit are set to 1.
-  * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC 
+  * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC
   * blocks are used on a 512-byte NAND page.
   *
   */
index f7f4e4227dbed1018e2324706871ebe1d64114bb..4e5157e25287dd35a96eaf36d8b08389a90da80e 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index 7dc62ef4d9955c740f385f021a92cc1042c36b39..b368844296ab3ffaf0b142d219b37161dc660c67 100644 (file)
@@ -146,71 +146,71 @@ static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, __u32 *chunk, __u3
                YBUG();
 }
 
-/* Function to return the number of shifts for a power of 2 greater than or equal 
+/* Function to return the number of shifts for a power of 2 greater than or equal
  * to the given number
  * Note we don't try to cater for all possible numbers and this does not have to
  * be hellishly efficient.
  */
+
 static __u32 ShiftsGE(__u32 x)
 {
        int extraBits;
        int nShifts;
-       
+
        nShifts = extraBits = 0;
-       
+
        while(x>1){
                if(x & 1) extraBits++;
                x>>=1;
                nShifts++;
        }
 
-       if(extraBits) 
+       if(extraBits)
                nShifts++;
-               
+
        return nShifts;
 }
 
 /* Function to return the number of shifts to get a 1 in bit 0
  */
+
 static __u32 ShiftDiv(__u32 x)
 {
        int nShifts;
-       
+
        nShifts =  0;
-       
+
        if(!x) return 0;
-       
+
        while( !(x&1)){
                x>>=1;
                nShifts++;
        }
-               
+
        return nShifts;
 }
 
 
 
-/* 
+/*
  * Temporary buffer manipulations.
  */
 
-static int yaffs_InitialiseTempBuffers(yaffs_Device *dev)      
+static int yaffs_InitialiseTempBuffers(yaffs_Device *dev)
 {
        int i;
        __u8 *buf = (__u8 *)1;
-               
+
        memset(dev->tempBuffer,0,sizeof(dev->tempBuffer));
-               
+
        for (i = 0; buf && i < YAFFS_N_TEMP_BUFFERS; i++) {
                dev->tempBuffer[i].line = 0;    /* not in use */
                dev->tempBuffer[i].buffer = buf =
                    YMALLOC_DMA(dev->nDataBytesPerChunk);
        }
-               
+
        return buf ? YAFFS_OK : YAFFS_FAIL;
-       
+
 }
 
 static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo)
@@ -283,8 +283,8 @@ int yaffs_IsManagedTempBuffer(yaffs_Device * dev, const __u8 * buffer)
        }
 
     for (i = 0; i < dev->nShortOpCaches; i++) {
-        if( dev->srCache[i].data == buffer )
-            return 1;
+       if( dev->srCache[i].data == buffer )
+           return 1;
 
     }
 
@@ -343,7 +343,7 @@ static Y_INLINE void yaffs_ClearChunkBit(yaffs_Device * dev, int blk, int chunk)
 static Y_INLINE void yaffs_SetChunkBit(yaffs_Device * dev, int blk, int chunk)
 {
        __u8 *blkBits = yaffs_BlockBits(dev, blk);
-       
+
        yaffs_VerifyChunkBitId(dev,blk,chunk);
 
        blkBits[chunk / 8] |= (1 << (chunk & 7));
@@ -381,16 +381,16 @@ static int yaffs_CountChunkBits(yaffs_Device * dev, int blk)
                                n++;
                        x >>=1;
                }
-                       
+
                blkBits++;
        }
        return n;
 }
 
-/* 
+/*
  * Verification code
  */
+
 static int yaffs_SkipVerification(yaffs_Device *dev)
 {
        return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL));
@@ -423,14 +423,14 @@ static void yaffs_VerifyBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
 {
        int actuallyUsed;
        int inUse;
-       
+
        if(yaffs_SkipVerification(dev))
                return;
-               
+
        /* Report illegal runtime states */
        if(bi->blockState <0 || bi->blockState >= YAFFS_NUMBER_OF_BLOCK_STATES)
                T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has undefined state %d"TENDSTR),n,bi->blockState));
-               
+
        switch(bi->blockState){
         case YAFFS_BLOCK_STATE_UNKNOWN:
         case YAFFS_BLOCK_STATE_SCANNING:
@@ -438,42 +438,42 @@ static void yaffs_VerifyBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
                T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has bad run-state %s"TENDSTR),
                n,blockStateName[bi->blockState]));
        }
-       
+
        /* Check pages in use and soft deletions are legal */
-       
+
        actuallyUsed = bi->pagesInUse - bi->softDeletions;
-       
+
        if(bi->pagesInUse < 0 || bi->pagesInUse > dev->nChunksPerBlock ||
           bi->softDeletions < 0 || bi->softDeletions > dev->nChunksPerBlock ||
           actuallyUsed < 0 || actuallyUsed > dev->nChunksPerBlock)
                T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has illegal values pagesInUsed %d softDeletions %d"TENDSTR),
                n,bi->pagesInUse,bi->softDeletions));
-       
-               
+
+
        /* Check chunk bitmap legal */
        inUse = yaffs_CountChunkBits(dev,n);
        if(inUse != bi->pagesInUse)
                T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has inconsistent values pagesInUse %d counted chunk bits %d"TENDSTR),
                        n,bi->pagesInUse,inUse));
-       
+
        /* Check that the sequence number is valid.
-        * Ten million is legal, but is very unlikely 
+        * Ten million is legal, but is very unlikely
         */
-       if(dev->isYaffs2 && 
+       if(dev->isYaffs2 &&
           (bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING || bi->blockState == YAFFS_BLOCK_STATE_FULL) &&
           (bi->sequenceNumber < YAFFS_LOWEST_SEQUENCE_NUMBER || bi->sequenceNumber > 10000000 ))
                T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has suspect sequence number of %d"TENDSTR),
                n,bi->sequenceNumber));
-               
+
 }
 
 static void yaffs_VerifyCollectedBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
 {
        yaffs_VerifyBlock(dev,bi,n);
-       
+
        /* After collection the block should be in the erased state */
        /* TODO: This will need to change if we do partial gc */
-       
+
        if(bi->blockState != YAFFS_BLOCK_STATE_EMPTY){
                T(YAFFS_TRACE_ERROR,(TSTR("Block %d is in state %d after gc, should be erased"TENDSTR),
                        n,bi->blockState));
@@ -485,14 +485,14 @@ static void yaffs_VerifyBlocks(yaffs_Device *dev)
        int i;
        int nBlocksPerState[YAFFS_NUMBER_OF_BLOCK_STATES];
        int nIllegalBlockStates = 0;
-       
+
 
        if(yaffs_SkipVerification(dev))
                return;
 
        memset(nBlocksPerState,0,sizeof(nBlocksPerState));
 
-               
+
        for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++){
                yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
                yaffs_VerifyBlock(dev,bi,i);
@@ -501,12 +501,12 @@ static void yaffs_VerifyBlocks(yaffs_Device *dev)
                        nBlocksPerState[bi->blockState]++;
                else
                        nIllegalBlockStates++;
-                                       
+
        }
-       
+
        T(YAFFS_TRACE_VERIFY,(TSTR(""TENDSTR)));
        T(YAFFS_TRACE_VERIFY,(TSTR("Block summary"TENDSTR)));
-       
+
        T(YAFFS_TRACE_VERIFY,(TSTR("%d blocks have illegal states"TENDSTR),nIllegalBlockStates));
        if(nBlocksPerState[YAFFS_BLOCK_STATE_ALLOCATING] > 1)
                T(YAFFS_TRACE_VERIFY,(TSTR("Too many allocating blocks"TENDSTR)));
@@ -515,17 +515,17 @@ static void yaffs_VerifyBlocks(yaffs_Device *dev)
                T(YAFFS_TRACE_VERIFY,
                  (TSTR("%s %d blocks"TENDSTR),
                  blockStateName[i],nBlocksPerState[i]));
-       
+
        if(dev->blocksInCheckpoint != nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT])
                T(YAFFS_TRACE_VERIFY,
                 (TSTR("Checkpoint block count wrong dev %d count %d"TENDSTR),
                 dev->blocksInCheckpoint, nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT]));
-                
+
        if(dev->nErasedBlocks != nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY])
                T(YAFFS_TRACE_VERIFY,
                 (TSTR("Erased block count wrong dev %d count %d"TENDSTR),
                 dev->nErasedBlocks, nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY]));
-                
+
        if(nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING] > 1)
                T(YAFFS_TRACE_VERIFY,
                 (TSTR("Too many collecting blocks %d (max is 1)"TENDSTR),
@@ -543,47 +543,47 @@ static void yaffs_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh,
 {
        if(yaffs_SkipVerification(obj->myDev))
                return;
-               
+
        if(!(tags && obj && oh)){
-               T(YAFFS_TRACE_VERIFY,
-                               (TSTR("Verifying object header tags %x obj %x oh %x"TENDSTR),
-                               (__u32)tags,(__u32)obj,(__u32)oh));
+               T(YAFFS_TRACE_VERIFY,
+                               (TSTR("Verifying object header tags %x obj %x oh %x"TENDSTR),
+                               (__u32)tags,(__u32)obj,(__u32)oh));
                return;
        }
-       
+
        if(oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN ||
           oh->type > YAFFS_OBJECT_TYPE_MAX)
-               T(YAFFS_TRACE_VERIFY,
+               T(YAFFS_TRACE_VERIFY,
                 (TSTR("Obj %d header type is illegal value 0x%x"TENDSTR),
                 tags->objectId, oh->type));
 
        if(tags->objectId != obj->objectId)
-               T(YAFFS_TRACE_VERIFY,
+               T(YAFFS_TRACE_VERIFY,
                 (TSTR("Obj %d header mismatch objectId %d"TENDSTR),
                 tags->objectId, obj->objectId));
 
 
        /*
         * Check that the object's parent ids match if parentCheck requested.
-        * 
+        *
         * Tests do not apply to the root object.
         */
-       
+
        if(parentCheck && tags->objectId > 1 && !obj->parent)
-               T(YAFFS_TRACE_VERIFY,
+               T(YAFFS_TRACE_VERIFY,
                 (TSTR("Obj %d header mismatch parentId %d obj->parent is NULL"TENDSTR),
-                tags->objectId, oh->parentObjectId));
-               
-       
+                tags->objectId, oh->parentObjectId));
+
+
        if(parentCheck && obj->parent &&
-          oh->parentObjectId != obj->parent->objectId && 
+          oh->parentObjectId != obj->parent->objectId &&
           (oh->parentObjectId != YAFFS_OBJECTID_UNLINKED ||
            obj->parent->objectId != YAFFS_OBJECTID_DELETED))
-               T(YAFFS_TRACE_VERIFY,
+               T(YAFFS_TRACE_VERIFY,
                 (TSTR("Obj %d header mismatch parentId %d parentObjectId %d"TENDSTR),
-                tags->objectId, oh->parentObjectId, obj->parent->objectId));
-               
-       
+                tags->objectId, oh->parentObjectId, obj->parent->objectId));
+
+
        if(tags->objectId > 1 && oh->name[0] == 0) /* Null name */
                T(YAFFS_TRACE_VERIFY,
                (TSTR("Obj %d header name is NULL"TENDSTR),
@@ -598,7 +598,7 @@ static void yaffs_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh,
 
 
 static int yaffs_VerifyTnodeWorker(yaffs_Object * obj, yaffs_Tnode * tn,
-                                       __u32 level, int chunkOffset)
+                                       __u32 level, int chunkOffset)
 {
        int i;
        yaffs_Device *dev = obj->myDev;
@@ -619,12 +619,12 @@ static int yaffs_VerifyTnodeWorker(yaffs_Object * obj, yaffs_Tnode * tn,
                        int i;
                        yaffs_ExtendedTags tags;
                        __u32 objectId = obj->objectId;
-                       
+
                        chunkOffset <<=  YAFFS_TNODES_LEVEL0_BITS;
-                       
+
                        for(i = 0; i < YAFFS_NTNODES_LEVEL0; i++){
                                __u32 theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
-                               
+
                                if(theChunk > 0){
                                        /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.objectId,tags.chunkId,theChunk)); */
                                        yaffs_ReadChunkWithTagsFromNAND(dev,theChunk,NULL, &tags);
@@ -655,13 +655,13 @@ static void yaffs_VerifyFile(yaffs_Object *obj)
        yaffs_ExtendedTags tags;
        yaffs_Tnode *tn;
        __u32 objectId;
-       
+
        if(obj && yaffs_SkipVerification(obj->myDev))
                return;
-       
+
        dev = obj->myDev;
        objectId = obj->objectId;
-       
+
        /* Check file size is consistent with tnode depth */
        lastChunk =  obj->variant.fileVariant.fileSize / dev->nDataBytesPerChunk + 1;
        x = lastChunk >> YAFFS_TNODES_LEVEL0_BITS;
@@ -670,23 +670,23 @@ static void yaffs_VerifyFile(yaffs_Object *obj)
                x >>= YAFFS_TNODES_INTERNAL_BITS;
                requiredTallness++;
        }
-       
+
        actualTallness = obj->variant.fileVariant.topLevel;
-       
+
        if(requiredTallness > actualTallness )
                T(YAFFS_TRACE_VERIFY,
                (TSTR("Obj %d had tnode tallness %d, needs to be %d"TENDSTR),
                 obj->objectId,actualTallness, requiredTallness));
-       
-       
-       /* Check that the chunks in the tnode tree are all correct. 
+
+
+       /* Check that the chunks in the tnode tree are all correct.
         * We do this by scanning through the tnode tree and
         * checking the tags for every chunk match.
         */
 
        if(yaffs_SkipNANDVerification(dev))
                return;
-               
+
        for(i = 1; i <= lastChunk; i++){
                tn = yaffs_FindLevel0Tnode(dev, &obj->variant.fileVariant,i);
 
@@ -711,14 +711,14 @@ static void yaffs_VerifyDirectory(yaffs_Object *obj)
 {
        if(obj && yaffs_SkipVerification(obj->myDev))
                return;
-       
+
 }
 
 static void yaffs_VerifyHardLink(yaffs_Object *obj)
 {
        if(obj && yaffs_SkipVerification(obj->myDev))
                return;
-               
+
        /* Verify sane equivalent object */
 }
 
@@ -726,7 +726,7 @@ static void yaffs_VerifySymlink(yaffs_Object *obj)
 {
        if(obj && yaffs_SkipVerification(obj->myDev))
                return;
-               
+
        /* Verify symlink string */
 }
 
@@ -739,32 +739,32 @@ static void yaffs_VerifySpecial(yaffs_Object *obj)
 static void yaffs_VerifyObject(yaffs_Object *obj)
 {
        yaffs_Device *dev;
-       
+
        __u32 chunkMin;
        __u32 chunkMax;
-       
+
        __u32 chunkIdOk;
        __u32 chunkIsLive;
-       
+
        if(!obj)
                return;
-       
+
        dev = obj->myDev;
-       
+
        if(yaffs_SkipVerification(dev))
                return;
-               
+
        /* Check sane object header chunk */
-       
+
        chunkMin = dev->internalStartBlock * dev->nChunksPerBlock;
        chunkMax = (dev->internalEndBlock+1) * dev->nChunksPerBlock - 1;
-       
+
        chunkIdOk = (obj->chunkId >= chunkMin && obj->chunkId <= chunkMax);
-       chunkIsLive = chunkIdOk && 
-                       yaffs_CheckChunkBit(dev, 
+       chunkIsLive = chunkIdOk &&
+                       yaffs_CheckChunkBit(dev,
                                            obj->chunkId / dev->nChunksPerBlock,
                                            obj->chunkId % dev->nChunksPerBlock);
-       if(!obj->fake && 
+       if(!obj->fake &&
            (!chunkIdOk || !chunkIsLive)) {
           T(YAFFS_TRACE_VERIFY,
           (TSTR("Obj %d has chunkId %d %s %s"TENDSTR),
@@ -772,36 +772,36 @@ static void yaffs_VerifyObject(yaffs_Object *obj)
           chunkIdOk ? "" : ",out of range",
           chunkIsLive || !chunkIdOk ? "" : ",marked as deleted"));
        }
-       
+
        if(chunkIdOk && chunkIsLive &&!yaffs_SkipNANDVerification(dev)) {
                yaffs_ExtendedTags tags;
                yaffs_ObjectHeader *oh;
                __u8 *buffer = yaffs_GetTempBuffer(dev,__LINE__);
-               
+
                oh = (yaffs_ObjectHeader *)buffer;
-               
+
                yaffs_ReadChunkWithTagsFromNAND(dev, obj->chunkId,buffer, &tags);
-               
+
                yaffs_VerifyObjectHeader(obj,oh,&tags,1);
-               
+
                yaffs_ReleaseTempBuffer(dev,buffer,__LINE__);
        }
-       
+
        /* Verify it has a parent */
        if(obj && !obj->fake &&
           (!obj->parent || obj->parent->myDev != dev)){
           T(YAFFS_TRACE_VERIFY,
           (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR),
-          obj->objectId,obj->parent));    
+          obj->objectId,obj->parent));
        }
-       
+
        /* Verify parent is a directory */
        if(obj->parent && obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY){
           T(YAFFS_TRACE_VERIFY,
           (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR),
-          obj->objectId,obj->parent->variantType));       
+          obj->objectId,obj->parent->variantType));
        }
-       
+
        switch(obj->variantType){
        case YAFFS_OBJECT_TYPE_FILE:
                yaffs_VerifyFile(obj);
@@ -822,11 +822,11 @@ static void yaffs_VerifyObject(yaffs_Object *obj)
        default:
                T(YAFFS_TRACE_VERIFY,
                (TSTR("Obj %d has illegaltype %d"TENDSTR),
-               obj->objectId,obj->variantType));          
+               obj->objectId,obj->variantType));
                break;
        }
-       
-       
+
+
 }
 
 static void yaffs_VerifyObjects(yaffs_Device *dev)
@@ -837,11 +837,11 @@ static void yaffs_VerifyObjects(yaffs_Device *dev)
 
        if(yaffs_SkipVerification(dev))
                return;
-       
+
        /* Iterate through the objects in each hash entry */
-        
+
         for(i = 0; i <  YAFFS_NOBJECT_BUCKETS; i++){
-               list_for_each(lh, &dev->objectBucket[i].list) {
+               list_for_each(lh, &dev->objectBucket[i].list) {
                        if (lh) {
                                obj = list_entry(lh, yaffs_Object, hashLink);
                                yaffs_VerifyObject(obj);
@@ -855,7 +855,7 @@ static void yaffs_VerifyObjects(yaffs_Device *dev)
 /*
  *  Simple hash function. Needs to have a reasonable spread
  */
+
 static Y_INLINE int yaffs_HashFunction(int n)
 {
 /* XXX U-BOOT XXX */
@@ -868,7 +868,7 @@ static Y_INLINE int yaffs_HashFunction(int n)
 /*
  * Access functions to useful fake objects
  */
+
 yaffs_Object *yaffs_Root(yaffs_Device * dev)
 {
        return dev->rootDir;
@@ -883,7 +883,7 @@ yaffs_Object *yaffs_LostNFound(yaffs_Device * dev)
 /*
  *  Erased NAND checking functions
  */
+
 int yaffs_CheckFF(__u8 * buffer, int nBytes)
 {
        /* Horrible, slow implementation */
@@ -905,10 +905,10 @@ static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
        int result;
 
        result = yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags);
-       
+
        if(tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR)
                retval = YAFFS_FAIL;
-               
+
 
        if (!yaffs_CheckFF(data, dev->nDataBytesPerChunk) || tags.chunkUsed) {
                T(YAFFS_TRACE_NANDACCESS,
@@ -998,9 +998,9 @@ static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
                /* Copy the data into the robustification buffer */
                yaffs_HandleWriteChunkOk(dev, chunk, data, tags);
 
-       } while (writeOk != YAFFS_OK && 
-               (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts));
-       
+       } while (writeOk != YAFFS_OK &&
+               (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts));
+
        if(!writeOk)
                chunk = -1;
 
@@ -1018,13 +1018,13 @@ static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
 /*
  * Block retiring for handling a broken block.
  */
+
 static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND)
 {
        yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
 
        yaffs_InvalidateCheckpoint(dev);
-       
+
        yaffs_MarkBlockBad(dev, blockInNAND);
 
        bi->blockState = YAFFS_BLOCK_STATE_DEAD;
@@ -1038,7 +1038,7 @@ static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND)
  * Functions for robustisizing TODO
  *
  */
+
 static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
                                     const __u8 * data,
                                     const yaffs_ExtendedTags * tags)
@@ -1056,13 +1056,13 @@ void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi)
                bi->gcPrioritise = 1;
                dev->hasPendingPrioritisedGCs = 1;
                bi->chunkErrorStrikes ++;
-               
+
                if(bi->chunkErrorStrikes > 3){
                        bi->needsRetiring = 1; /* Too many stikes, so retire this */
                        T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Block struck out" TENDSTR)));
 
                }
-               
+
        }
 }
 
@@ -1073,23 +1073,23 @@ static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND, int
        yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
 
        yaffs_HandleChunkError(dev,bi);
-               
-       
+
+
        if(erasedOk ) {
                /* Was an actual write failure, so mark the block for retirement  */
                bi->needsRetiring = 1;
                T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
                  (TSTR("**>> Block %d needs retiring" TENDSTR), blockInNAND));
 
-               
+
        }
-       
+
        /* Delete the chunk */
        yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__);
 }
 
 
-/*---------------- Name handling functions ------------*/ 
+/*---------------- Name handling functions ------------*/
 
 static __u16 yaffs_CalcNameSum(const YCHAR * name)
 {
@@ -1130,7 +1130,7 @@ static void yaffs_SetObjectName(yaffs_Object * obj, const YCHAR * name)
  * The list is hooked together using the first pointer
  * in the tnode.
  */
+
 /* yaffs_CreateTnodes creates a bunch more tnodes and
  * adds them to the tnode free list.
  * Don't use this function directly
@@ -1148,7 +1148,7 @@ static int yaffs_CreateTnodes(yaffs_Device * dev, int nTnodes)
 
        if (nTnodes < 1)
                return YAFFS_OK;
-               
+
        /* Calculate the tnode size in bytes for variable width tnode support.
         * Must be a multiple of 32-bits  */
        tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
@@ -1185,7 +1185,7 @@ static int yaffs_CreateTnodes(yaffs_Device * dev, int nTnodes)
                next = (yaffs_Tnode *) &mem[(i+1) * tnodeSize];
                curr->internal[0] = next;
        }
-       
+
        curr = (yaffs_Tnode *) &mem[(nTnodes - 1) * tnodeSize];
        curr->internal[0] = dev->freeTnodes;
        dev->freeTnodes = (yaffs_Tnode *)mem;
@@ -1200,7 +1200,7 @@ static int yaffs_CreateTnodes(yaffs_Device * dev, int nTnodes)
         * NB If we can't add this to the management list it isn't fatal
         * but it just means we can't free this bunch of tnodes later.
         */
-        
+
        tnl = YMALLOC(sizeof(yaffs_TnodeList));
        if (!tnl) {
                T(YAFFS_TRACE_ERROR,
@@ -1249,11 +1249,11 @@ static yaffs_Tnode *yaffs_GetTnodeRaw(yaffs_Device * dev)
 static yaffs_Tnode *yaffs_GetTnode(yaffs_Device * dev)
 {
        yaffs_Tnode *tn = yaffs_GetTnodeRaw(dev);
-       
+
        if(tn)
                memset(tn, 0, (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
 
-       return tn;      
+       return tn;
 }
 
 /* FreeTnode frees up a tnode and puts it back on the free list */
@@ -1309,19 +1309,19 @@ void yaffs_PutLevel0Tnode(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos, unsi
   __u32 bitInWord;
   __u32 wordInMap;
   __u32 mask;
-  
+
   pos &= YAFFS_TNODES_LEVEL0_MASK;
   val >>= dev->chunkGroupBits;
-  
+
   bitInMap = pos * dev->tnodeWidth;
   wordInMap = bitInMap /32;
   bitInWord = bitInMap & (32 -1);
-  
+
   mask = dev->tnodeMask << bitInWord;
-  
+
   map[wordInMap] &= ~mask;
   map[wordInMap] |= (mask & (val << bitInWord));
-  
+
   if(dev->tnodeWidth > (32-bitInWord)) {
     bitInWord = (32 - bitInWord);
     wordInMap++;;
@@ -1338,24 +1338,24 @@ static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, unsigne
   __u32 bitInWord;
   __u32 wordInMap;
   __u32 val;
-  
+
   pos &= YAFFS_TNODES_LEVEL0_MASK;
-  
+
   bitInMap = pos * dev->tnodeWidth;
   wordInMap = bitInMap /32;
   bitInWord = bitInMap & (32 -1);
-  
+
   val = map[wordInMap] >> bitInWord;
-  
+
   if(dev->tnodeWidth > (32-bitInWord)) {
     bitInWord = (32 - bitInWord);
     wordInMap++;;
     val |= (map[wordInMap] << bitInWord);
   }
-  
+
   val &= dev->tnodeMask;
   val <<= dev->chunkGroupBits;
-  
+
   return val;
 }
 
@@ -1404,9 +1404,9 @@ static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device * dev,
        while (level > 0 && tn) {
                tn = tn->
                    internal[(chunkId >>
-                              ( YAFFS_TNODES_LEVEL0_BITS + 
-                                (level - 1) *
-                                YAFFS_TNODES_INTERNAL_BITS)
+                              ( YAFFS_TNODES_LEVEL0_BITS +
+                                (level - 1) *
+                                YAFFS_TNODES_INTERNAL_BITS)
                              ) &
                             YAFFS_TNODES_INTERNAL_MASK];
                level--;
@@ -1426,7 +1426,7 @@ static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device * dev,
  *  If the tn argument is NULL, then a fresh tnode will be added otherwise the specified tn will
  *  be plugged into the ttree.
  */
+
 static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev,
                                               yaffs_FileStructure * fStruct,
                                               __u32 chunkId,
@@ -1463,7 +1463,7 @@ static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev,
        if (requiredTallness > fStruct->topLevel) {
                /* Not tall enough,gotta make the tree taller */
                for (i = fStruct->topLevel; i < requiredTallness; i++) {
-               
+
                        tn = yaffs_GetTnode(dev);
 
                        if (tn) {
@@ -1482,7 +1482,7 @@ static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev,
 
        l = fStruct->topLevel;
        tn = fStruct->top;
-       
+
        if(l > 0) {
                while (l > 0 && tn) {
                        x = (chunkId >>
@@ -1497,18 +1497,18 @@ static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev,
 
                        } else if(l == 1) {
                                /* Looking from level 1 at level 0 */
-                               if (passedTn) {
+                               if (passedTn) {
                                        /* If we already have one, then release it.*/
                                        if(tn->internal[x])
                                                yaffs_FreeTnode(dev,tn->internal[x]);
                                        tn->internal[x] = passedTn;
-                       
+
                                } else if(!tn->internal[x]) {
                                        /* Don't have one, none passed in */
                                        tn->internal[x] = yaffs_GetTnode(dev);
                                }
                        }
-               
+
                        tn = tn->internal[x];
                        l--;
                }
@@ -1549,7 +1549,7 @@ static int yaffs_FindChunkInGroup(yaffs_Device * dev, int theChunk,
 
 /* DeleteWorker scans backwards through the tnode tree and deletes all the
  * chunks and tnodes in the file
- * Returns 1 if the tree was deleted. 
+ * Returns 1 if the tree was deleted.
  * Returns 0 if it stopped early due to hitting the limit and the delete is incomplete.
  */
 
@@ -1602,7 +1602,7 @@ static int yaffs_DeleteWorker(yaffs_Object * in, yaffs_Tnode * tn, __u32 level,
 
                        for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0 && !hitLimit;
                             i--) {
-                               theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
+                               theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
                                if (theChunk) {
 
                                        chunkInInode =
@@ -1663,7 +1663,7 @@ static void yaffs_SoftDeleteChunk(yaffs_Device * dev, int chunk)
  * of the tnode.
  * Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted.
  */
+
 static int yaffs_SoftDeleteWorker(yaffs_Object * in, yaffs_Tnode * tn,
                                  __u32 level, int chunkOffset)
 {
@@ -1704,7 +1704,7 @@ static int yaffs_SoftDeleteWorker(yaffs_Object * in, yaffs_Tnode * tn,
                                theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
                                if (theChunk) {
                                        /* Note this does not find the real chunk, only the chunk group.
-                                        * We make an assumption that a chunk group is not larger than 
+                                        * We make an assumption that a chunk group is not larger than
                                         * a block.
                                         */
                                        yaffs_SoftDeleteChunk(dev, theChunk);
@@ -1806,7 +1806,7 @@ static int yaffs_PruneFileStructure(yaffs_Device * dev,
                /* Now we have a tree with all the non-zero branches NULL but the height
                 * is the same as it was.
                 * Let's see if we can trim internal tnodes to shorten the tree.
-                * We can do this if only the 0th element in the tnode is in use 
+                * We can do this if only the 0th element in the tnode is in use
                 * (ie all the non-zero are NULL)
                 */
 
@@ -1860,7 +1860,7 @@ static int yaffs_CreateFreeObjects(yaffs_Device * dev, int nObjects)
                  (TSTR("yaffs: Could not allocate more objects" TENDSTR)));
                return YAFFS_FAIL;
        }
-       
+
        /* Hook them into the free list */
        for (i = 0; i < nObjects - 1; i++) {
                newObjects[i].siblings.next =
@@ -2149,7 +2149,7 @@ yaffs_Object *yaffs_CreateNewObject(yaffs_Device * dev, int number,
        theObject = yaffs_AllocateEmptyObject(dev);
        if(!theObject)
                return NULL;
-               
+
        if(type == YAFFS_OBJECT_TYPE_FILE){
                tn = yaffs_GetTnode(dev);
                if(!tn){
@@ -2157,8 +2157,8 @@ yaffs_Object *yaffs_CreateNewObject(yaffs_Device * dev, int number,
                        return NULL;
                }
        }
-               
-       
+
+
 
        if (theObject) {
                theObject->fake = 0;
@@ -2222,7 +2222,7 @@ static yaffs_Object *yaffs_FindOrCreateObjectByNumber(yaffs_Device * dev,
        return theObject;
 
 }
-                       
+
 
 static YCHAR *yaffs_CloneString(const YCHAR * str)
 {
@@ -2244,7 +2244,7 @@ static YCHAR *yaffs_CloneString(const YCHAR * str)
  * aliasString only has meaning for a sumlink.
  * rdev only has meaning for devices (a subset of special objects)
  */
+
 static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
                                       yaffs_Object * parent,
                                       const YCHAR * name,
@@ -2265,7 +2265,7 @@ static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
        }
 
        in = yaffs_CreateNewObject(dev, -1, type);
-       
+
        if(type == YAFFS_OBJECT_TYPE_SYMLINK){
                str = yaffs_CloneString(aliasString);
                if(!str){
@@ -2273,8 +2273,8 @@ static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
                        return NULL;
                }
        }
-       
-       
+
+
 
        if (in) {
                in->chunkId = -1;
@@ -2315,7 +2315,7 @@ static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
                            equivalentObject->objectId;
                        list_add(&in->hardLinks, &equivalentObject->hardLinks);
                        break;
-               case YAFFS_OBJECT_TYPE_FILE:    
+               case YAFFS_OBJECT_TYPE_FILE:
                case YAFFS_OBJECT_TYPE_DIRECTORY:
                case YAFFS_OBJECT_TYPE_SPECIAL:
                case YAFFS_OBJECT_TYPE_UNKNOWN:
@@ -2399,7 +2399,7 @@ static int yaffs_ChangeObjectName(yaffs_Object * obj, yaffs_Object * newDir,
                    TENDSTR)));
                YBUG();
        }
-       
+
        /* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */
        if (obj->myDev->isYaffs2) {
                unlinkOp = (newDir == obj->myDev->unlinkedDir);
@@ -2412,9 +2412,9 @@ static int yaffs_ChangeObjectName(yaffs_Object * obj, yaffs_Object * newDir,
 
        existingTarget = yaffs_FindObjectByName(newDir, newName);
 
-       /* If the object is a file going into the unlinked directory, 
+       /* If the object is a file going into the unlinked directory,
         *   then it is OK to just stuff it in since duplicate names are allowed.
-        *   else only proceed if the new name does not exist and if we're putting 
+        *   else only proceed if the new name does not exist and if we're putting
         *   it into a directory.
         */
        if ((unlinkOp ||
@@ -2478,7 +2478,7 @@ int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName,
                        /* There is a target that is a non-empty directory, so we fail */
                        return YAFFS_FAIL;      /* EEXIST or ENOTEMPTY */
                } else if (existingTarget && existingTarget != obj) {
-                       /* Nuke the target first, using shadowing, 
+                       /* Nuke the target first, using shadowing,
                         * but only if it isn't the same object
                         */
                        yaffs_ChangeObjectName(obj, newDir, newName, force,
@@ -2496,10 +2496,10 @@ int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName,
 static int yaffs_InitialiseBlocks(yaffs_Device * dev)
 {
        int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
-       
+
        dev->blockInfo = NULL;
        dev->chunkBits = NULL;
-       
+
        dev->allocationBlock = -1;      /* force it to get a new one */
 
        /* If the first allocation strategy fails, thry the alternate one */
@@ -2510,9 +2510,9 @@ static int yaffs_InitialiseBlocks(yaffs_Device * dev)
        }
        else
                dev->blockInfoAlt = 0;
-               
+
        if(dev->blockInfo){
-       
+
                /* Set up dynamic blockinfo stuff. */
                dev->chunkBitmapStride = (dev->nChunksPerBlock + 7) / 8; /* round up bytes */
                dev->chunkBits = YMALLOC(dev->chunkBitmapStride * nBlocks);
@@ -2523,7 +2523,7 @@ static int yaffs_InitialiseBlocks(yaffs_Device * dev)
                else
                        dev->chunkBitsAlt = 0;
        }
-       
+
        if (dev->blockInfo && dev->chunkBits) {
                memset(dev->blockInfo, 0, nBlocks * sizeof(yaffs_BlockInfo));
                memset(dev->chunkBits, 0, dev->chunkBitmapStride * nBlocks);
@@ -2544,7 +2544,7 @@ static void yaffs_DeinitialiseBlocks(yaffs_Device * dev)
        dev->blockInfoAlt = 0;
 
        dev->blockInfo = NULL;
-       
+
        if(dev->chunkBitsAlt && dev->chunkBits)
                YFREE_ALT(dev->chunkBits);
        else if(dev->chunkBits)
@@ -2608,14 +2608,14 @@ static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev,
        int prioritised=0;
        yaffs_BlockInfo *bi;
        int pendingPrioritisedExist = 0;
-       
+
        /* First let's see if we need to grab a prioritised block */
        if(dev->hasPendingPrioritisedGCs){
                for(i = dev->internalStartBlock; i < dev->internalEndBlock && !prioritised; i++){
 
                        bi = yaffs_GetBlockInfo(dev, i);
                        //yaffs_VerifyBlock(dev,bi,i);
-                       
+
                        if(bi->gcPrioritise) {
                                pendingPrioritisedExist = 1;
                                if(bi->blockState == YAFFS_BLOCK_STATE_FULL &&
@@ -2627,7 +2627,7 @@ static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev,
                                }
                        }
                }
-               
+
                if(!pendingPrioritisedExist) /* None found, so we can clear this */
                        dev->hasPendingPrioritisedGCs = 0;
        }
@@ -2646,7 +2646,7 @@ static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev,
 
        if(!prioritised)
                pagesInUse =
-                       (aggressive) ? dev->nChunksPerBlock : YAFFS_PASSIVE_GC_CHUNKS + 1;
+                       (aggressive) ? dev->nChunksPerBlock : YAFFS_PASSIVE_GC_CHUNKS + 1;
 
        if (aggressive) {
                iterations =
@@ -2679,12 +2679,12 @@ static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev,
                        dirtiest = b;
                        pagesInUse = 0;
                }
-               else 
+               else
 #endif
 
                if (bi->blockState == YAFFS_BLOCK_STATE_FULL &&
                       (bi->pagesInUse - bi->softDeletions) < pagesInUse &&
-                       yaffs_BlockNotDisqualifiedFromGC(dev, bi)) {
+                       yaffs_BlockNotDisqualifiedFromGC(dev, bi)) {
                        dirtiest = b;
                        pagesInUse = (bi->pagesInUse - bi->softDeletions);
                }
@@ -2716,11 +2716,11 @@ static void yaffs_BlockBecameDirty(yaffs_Device * dev, int blockNo)
        /* If the block is still healthy erase it and mark as clean.
         * If the block has had a data failure, then retire it.
         */
-        
+
        T(YAFFS_TRACE_GC | YAFFS_TRACE_ERASE,
                (TSTR("yaffs_BlockBecameDirty block %d state %d %s"TENDSTR),
                blockNo, bi->blockState, (bi->needsRetiring) ? "needs retiring" : ""));
-               
+
        bi->blockState = YAFFS_BLOCK_STATE_DIRTY;
 
        if (!bi->needsRetiring) {
@@ -2733,7 +2733,7 @@ static void yaffs_BlockBecameDirty(yaffs_Device * dev, int blockNo)
                }
        }
 
-       if (erasedOk && 
+       if (erasedOk &&
            ((yaffs_traceMask & YAFFS_TRACE_ERASE) || !yaffs_SkipVerification(dev))) {
                int i;
                for (i = 0; i < dev->nChunksPerBlock; i++) {
@@ -2784,7 +2784,7 @@ static int yaffs_FindBlockForAllocation(yaffs_Device * dev)
 
                return -1;
        }
-       
+
        /* Find an empty block. */
 
        for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
@@ -2825,13 +2825,13 @@ static int yaffs_CheckSpaceForAllocation(yaffs_Device * dev)
        int reservedChunks;
        int reservedBlocks = dev->nReservedBlocks;
        int checkpointBlocks;
-       
+
        checkpointBlocks =  dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
        if(checkpointBlocks < 0)
                checkpointBlocks = 0;
-       
+
        reservedChunks = ((reservedBlocks + checkpointBlocks) * dev->nChunksPerBlock);
-       
+
        return (dev->nFreeChunks > reservedChunks);
 }
 
@@ -2878,10 +2878,10 @@ static int yaffs_AllocateChunk(yaffs_Device * dev, int useReserve, yaffs_BlockIn
 
                if(blockUsedPtr)
                        *blockUsedPtr = bi;
-                       
+
                return retVal;
        }
-       
+
        T(YAFFS_TRACE_ERROR,
          (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
 
@@ -2924,7 +2924,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
        yaffs_Object *object;
 
        isCheckpointBlock = (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT);
-       
+
        bi->blockState = YAFFS_BLOCK_STATE_COLLECTING;
 
        T(YAFFS_TRACE_TRACING,
@@ -2952,7 +2952,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
        } else {
 
                __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__);
-               
+
                yaffs_VerifyBlock(dev,bi,block);
 
                for (chunkInBlock = 0, oldChunk = block * dev->nChunksPerBlock;
@@ -2979,7 +2979,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
                                   ("Collecting page %d, %d %d %d " TENDSTR),
                                   chunkInBlock, tags.objectId, tags.chunkId,
                                   tags.byteCount));
-                                  
+
                                if(object && !yaffs_SkipVerification(dev)){
                                        if(tags.chunkId == 0)
                                                matchingChunk = object->chunkId;
@@ -2987,12 +2987,12 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
                                                matchingChunk = oldChunk; /* Defeat the test */
                                        else
                                                matchingChunk = yaffs_FindChunkInFile(object,tags.chunkId,NULL);
-                                       
+
                                        if(oldChunk != matchingChunk)
                                                T(YAFFS_TRACE_ERROR,
                                                  (TSTR("gc: page in gc mismatch: %d %d %d %d"TENDSTR),
                                                  oldChunk,matchingChunk,tags.objectId, tags.chunkId));
-                                               
+
                                }
 
                                if (!object) {
@@ -3007,7 +3007,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
                                    && tags.chunkId != 0) {
                                        /* Data chunk in a deleted file, throw it away
                                         * It's a soft deleted data chunk,
-                                        * No need to copy this, just forget about it and 
+                                        * No need to copy this, just forget about it and
                                         * fix up the object.
                                         */
 
@@ -3057,7 +3057,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
                                                oh->shadowsObject = -1;
                                                tags.extraShadows = 0;
                                                tags.extraIsShrinkHeader = 0;
-                                               
+
                                                yaffs_VerifyObjectHeader(object,oh,&tags,1);
                                        }
 
@@ -3116,7 +3116,7 @@ static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
        }
 
        yaffs_VerifyCollectedBlock(dev,bi,block);
-         
+
        if (chunksBefore >= (chunksAfter = yaffs_GetErasedChunks(dev))) {
                T(YAFFS_TRACE_GC,
                  (TSTR
@@ -3144,21 +3144,21 @@ static int yaffs_CheckGarbageCollection(yaffs_Device * dev)
        int aggressive;
        int gcOk = YAFFS_OK;
        int maxTries = 0;
-       
+
        int checkpointBlockAdjust;
 
        if (dev->isDoingGC) {
                /* Bail out so we don't get recursive gc */
                return YAFFS_OK;
        }
-       
+
        /* This loop should pass the first time.
         * We'll only see looping here if the erase of the collected block fails.
         */
 
        do {
                maxTries++;
-               
+
                checkpointBlockAdjust = (dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint);
                if(checkpointBlockAdjust < 0)
                        checkpointBlockAdjust = 0;
@@ -3343,11 +3343,11 @@ static int yaffs_CheckFileSanity(yaffs_Object * in)
 static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
                                  int chunkInNAND, int inScan)
 {
-       /* NB inScan is zero unless scanning. 
-        * For forward scanning, inScan is > 0; 
+       /* NB inScan is zero unless scanning.
+        * For forward scanning, inScan is > 0;
         * for backward scanning inScan is < 0
         */
-        
+
        yaffs_Tnode *tn;
        yaffs_Device *dev = in->myDev;
        int existingChunk;
@@ -3371,7 +3371,7 @@ static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
                return YAFFS_OK;
        }
 
-       tn = yaffs_AddOrFindLevel0Tnode(dev, 
+       tn = yaffs_AddOrFindLevel0Tnode(dev,
                                        &in->variant.fileVariant,
                                        chunkInInode,
                                        NULL);
@@ -3383,7 +3383,7 @@ static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
 
        if (inScan != 0) {
                /* If we're scanning then we need to test for duplicates
-                * NB This does not need to be efficient since it should only ever 
+                * NB This does not need to be efficient since it should only ever
                 * happen when the power fails during a write, then only one
                 * chunk should ever be affected.
                 *
@@ -3424,7 +3424,7 @@ static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
 
                        }
 
-                       /* NB The deleted flags should be false, otherwise the chunks will 
+                       /* NB The deleted flags should be false, otherwise the chunks will
                         * not be loaded during a scan
                         */
 
@@ -3435,7 +3435,7 @@ static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
                            (in->myDev->isYaffs2 ||
                             existingChunk <= 0 ||
                             ((existingSerial + 1) & 3) == newSerial)) {
-                               /* Forward scanning.                            
+                               /* Forward scanning.
                                 * Use new
                                 * Delete the old one and drop through to update the tnode
                                 */
@@ -3476,7 +3476,7 @@ static int yaffs_ReadChunkDataFromObject(yaffs_Object * in, int chunkInInode,
                  (TSTR("Chunk %d not found zero instead" TENDSTR),
                   chunkInNAND));
                /* get sane (zero) data if you read a hole */
-               memset(buffer, 0, in->myDev->nDataBytesPerChunk);       
+               memset(buffer, 0, in->myDev->nDataBytesPerChunk);
                return 0;
        }
 
@@ -3491,7 +3491,7 @@ void yaffs_DeleteChunk(yaffs_Device * dev, int chunkId, int markNAND, int lyn)
 
        if (chunkId <= 0)
                return;
-               
+
 
        dev->nDeletions++;
        block = chunkId / dev->nChunksPerBlock;
@@ -3500,8 +3500,8 @@ void yaffs_DeleteChunk(yaffs_Device * dev, int chunkId, int markNAND, int lyn)
 
        if(!yaffs_CheckChunkBit(dev,block,page))
                T(YAFFS_TRACE_VERIFY,
-                       (TSTR("Deleting invalid chunk %d"TENDSTR),
-                        chunkId));
+                       (TSTR("Deleting invalid chunk %d"TENDSTR),
+                        chunkId));
 
        bi = yaffs_GetBlockInfo(dev, block);
 
@@ -3619,7 +3619,7 @@ int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, int force,
        YCHAR oldName[YAFFS_MAX_NAME_LENGTH + 1];
 
        yaffs_ObjectHeader *oh = NULL;
-       
+
        yaffs_strcpy(oldName,"silly old name");
 
        if (!in->fake || force) {
@@ -3635,9 +3635,9 @@ int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, int force,
                if (prevChunkId >= 0) {
                        result = yaffs_ReadChunkWithTagsFromNAND(dev, prevChunkId,
                                                        buffer, &oldTags);
-                       
+
                        yaffs_VerifyObjectHeader(in,oh,&oldTags,0);
-                                                                               
+
                        memcpy(oldName, oh->name, sizeof(oh->name));
                }
 
@@ -3765,11 +3765,11 @@ int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, int force,
 
 /*------------------------ Short Operations Cache ----------------------------------------
  *   In many situations where there is no high level buffering (eg WinCE) a lot of
- *   reads might be short sequential reads, and a lot of writes may be short 
+ *   reads might be short sequential reads, and a lot of writes may be short
  *   sequential writes. eg. scanning/writing a jpeg file.
- *   In these cases, a short read/write cache can provide a huge perfomance benefit 
+ *   In these cases, a short read/write cache can provide a huge perfomance benefit
  *   with dumb-as-a-rock code.
- *   In Linux, the page cache provides read buffering aand the short op cache provides write 
+ *   In Linux, the page cache provides read buffering aand the short op cache provides write
  *   buffering.
  *
  *   There are a limited number (~10) of cache chunks per device so that we don't
@@ -3782,14 +3782,14 @@ static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj)
        int i;
        yaffs_ChunkCache *cache;
        int nCaches = obj->myDev->nShortOpCaches;
-       
+
        for(i = 0; i < nCaches; i++){
                cache = &dev->srCache[i];
                if (cache->object == obj &&
                    cache->dirty)
                        return 1;
        }
-       
+
        return 0;
 }
 
@@ -3855,7 +3855,7 @@ void yaffs_FlushEntireDeviceCache(yaffs_Device *dev)
        yaffs_Object *obj;
        int nCaches = dev->nShortOpCaches;
        int i;
-       
+
        /* Find a dirty object in the cache and flush it...
         * until there are no further dirty objects.
         */
@@ -3865,18 +3865,18 @@ void yaffs_FlushEntireDeviceCache(yaffs_Device *dev)
                        if (dev->srCache[i].object &&
                            dev->srCache[i].dirty)
                                obj = dev->srCache[i].object;
-                           
+
                }
                if(obj)
                        yaffs_FlushFilesChunkCache(obj);
-                       
+
        } while(obj);
-       
+
 }
 
 
 /* Grab us a cache chunk for use.
- * First look for an empty one. 
+ * First look for an empty one.
  * Then look for the least recently used non-dirty one.
  * Then look for the least recently used dirty one...., flush and look again.
  */
@@ -3888,7 +3888,7 @@ static yaffs_ChunkCache *yaffs_GrabChunkCacheWorker(yaffs_Device * dev)
 
        if (dev->nShortOpCaches > 0) {
                for (i = 0; i < dev->nShortOpCaches; i++) {
-                       if (!dev->srCache[i].object) 
+                       if (!dev->srCache[i].object)
                                return &dev->srCache[i];
                }
 
@@ -4049,14 +4049,14 @@ static void yaffs_InvalidateWholeChunkCache(yaffs_Object * in)
 static int yaffs_WriteCheckpointValidityMarker(yaffs_Device *dev,int head)
 {
        yaffs_CheckpointValidity cp;
-       
+
        memset(&cp,0,sizeof(cp));
-       
+
        cp.structType = sizeof(cp);
        cp.magic = YAFFS_MAGIC;
        cp.version = YAFFS_CHECKPOINT_VERSION;
        cp.head = (head) ? 1 : 0;
-       
+
        return (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp))?
                1 : 0;
 }
@@ -4065,9 +4065,9 @@ static int yaffs_ReadCheckpointValidityMarker(yaffs_Device *dev, int head)
 {
        yaffs_CheckpointValidity cp;
        int ok;
-       
+
        ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
-       
+
        if(ok)
                ok = (cp.structType == sizeof(cp)) &&
                     (cp.magic == YAFFS_MAGIC) &&
@@ -4076,20 +4076,20 @@ static int yaffs_ReadCheckpointValidityMarker(yaffs_Device *dev, int head)
        return ok ? 1 : 0;
 }
 
-static void yaffs_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp, 
+static void yaffs_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp,
                                           yaffs_Device *dev)
 {
        cp->nErasedBlocks = dev->nErasedBlocks;
        cp->allocationBlock = dev->allocationBlock;
        cp->allocationPage = dev->allocationPage;
        cp->nFreeChunks = dev->nFreeChunks;
-       
+
        cp->nDeletedFiles = dev->nDeletedFiles;
        cp->nUnlinkedFiles = dev->nUnlinkedFiles;
        cp->nBackgroundDeletions = dev->nBackgroundDeletions;
        cp->sequenceNumber = dev->sequenceNumber;
        cp->oldestDirtySequence = dev->oldestDirtySequence;
-       
+
 }
 
 static void yaffs_CheckpointDeviceToDevice(yaffs_Device *dev,
@@ -4099,7 +4099,7 @@ static void yaffs_CheckpointDeviceToDevice(yaffs_Device *dev,
        dev->allocationBlock = cp->allocationBlock;
        dev->allocationPage = cp->allocationPage;
        dev->nFreeChunks = cp->nFreeChunks;
-       
+
        dev->nDeletedFiles = cp->nDeletedFiles;
        dev->nUnlinkedFiles = cp->nUnlinkedFiles;
        dev->nBackgroundDeletions = cp->nBackgroundDeletions;
@@ -4115,20 +4115,20 @@ static int yaffs_WriteCheckpointDevice(yaffs_Device *dev)
        __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1);
 
        int ok;
-               
+
        /* Write device runtime values*/
        yaffs_DeviceToCheckpointDevice(&cp,dev);
        cp.structType = sizeof(cp);
-       
+
        ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
-       
+
        /* Write block info */
        if(ok) {
                nBytes = nBlocks * sizeof(yaffs_BlockInfo);
                ok = (yaffs_CheckpointWrite(dev,dev->blockInfo,nBytes) == nBytes);
        }
-               
-       /* Write chunk bits */          
+
+       /* Write chunk bits */
        if(ok) {
                nBytes = nBlocks * dev->chunkBitmapStride;
                ok = (yaffs_CheckpointWrite(dev,dev->chunkBits,nBytes) == nBytes);
@@ -4143,28 +4143,28 @@ static int yaffs_ReadCheckpointDevice(yaffs_Device *dev)
        __u32 nBytes;
        __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1);
 
-       int ok; 
-       
+       int ok;
+
        ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
        if(!ok)
                return 0;
-               
+
        if(cp.structType != sizeof(cp))
                return 0;
-               
-       
+
+
        yaffs_CheckpointDeviceToDevice(dev,&cp);
-       
+
        nBytes = nBlocks * sizeof(yaffs_BlockInfo);
-       
+
        ok = (yaffs_CheckpointRead(dev,dev->blockInfo,nBytes) == nBytes);
-       
+
        if(!ok)
                return 0;
        nBytes = nBlocks * dev->chunkBitmapStride;
-       
+
        ok = (yaffs_CheckpointRead(dev,dev->chunkBits,nBytes) == nBytes);
-       
+
        return ok ? 1 : 0;
 }
 
@@ -4175,7 +4175,7 @@ static void yaffs_ObjectToCheckpointObject(yaffs_CheckpointObject *cp,
        cp->objectId = obj->objectId;
        cp->parentId = (obj->parent) ? obj->parent->objectId : 0;
        cp->chunkId = obj->chunkId;
-       cp->variantType = obj->variantType;                     
+       cp->variantType = obj->variantType;
        cp->deleted = obj->deleted;
        cp->softDeleted = obj->softDeleted;
        cp->unlinked = obj->unlinked;
@@ -4184,7 +4184,7 @@ static void yaffs_ObjectToCheckpointObject(yaffs_CheckpointObject *cp,
        cp->unlinkAllowed = obj->unlinkAllowed;
        cp->serial = obj->serial;
        cp->nDataChunks = obj->nDataChunks;
-       
+
        if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
                cp->fileSizeOrEquivalentObjectId = obj->variant.fileVariant.fileSize;
        else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
@@ -4195,9 +4195,9 @@ static void yaffs_CheckpointObjectToObject( yaffs_Object *obj,yaffs_CheckpointOb
 {
 
        yaffs_Object *parent;
-       
+
        obj->objectId = cp->objectId;
-       
+
        if(cp->parentId)
                parent = yaffs_FindOrCreateObjectByNumber(
                                        obj->myDev,
@@ -4205,12 +4205,12 @@ static void yaffs_CheckpointObjectToObject( yaffs_Object *obj,yaffs_CheckpointOb
                                        YAFFS_OBJECT_TYPE_DIRECTORY);
        else
                parent = NULL;
-               
+
        if(parent)
                yaffs_AddObjectToDirectory(parent, obj);
-               
+
        obj->chunkId = cp->chunkId;
-       obj->variantType = cp->variantType;                     
+       obj->variantType = cp->variantType;
        obj->deleted = cp->deleted;
        obj->softDeleted = cp->softDeleted;
        obj->unlinked = cp->unlinked;
@@ -4219,12 +4219,12 @@ static void yaffs_CheckpointObjectToObject( yaffs_Object *obj,yaffs_CheckpointOb
        obj->unlinkAllowed = cp->unlinkAllowed;
        obj->serial = cp->serial;
        obj->nDataChunks = cp->nDataChunks;
-       
+
        if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
                obj->variant.fileVariant.fileSize = cp->fileSizeOrEquivalentObjectId;
        else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
                obj->variant.hardLinkVariant.equivalentObjectId = cp->fileSizeOrEquivalentObjectId;
-               
+
        if(obj->objectId >= YAFFS_NOBJECT_BUCKETS)
                obj->lazyLoaded = 1;
 }
@@ -4232,7 +4232,7 @@ static void yaffs_CheckpointObjectToObject( yaffs_Object *obj,yaffs_CheckpointOb
 
 
 static int yaffs_CheckpointTnodeWorker(yaffs_Object * in, yaffs_Tnode * tn,
-                                       __u32 level, int chunkOffset)
+                                       __u32 level, int chunkOffset)
 {
        int i;
        yaffs_Device *dev = in->myDev;
@@ -4267,17 +4267,17 @@ static int yaffs_WriteCheckpointTnodes(yaffs_Object *obj)
 {
        __u32 endMarker = ~0;
        int ok = 1;
-       
+
        if(obj->variantType == YAFFS_OBJECT_TYPE_FILE){
                ok = yaffs_CheckpointTnodeWorker(obj,
                                            obj->variant.fileVariant.top,
                                            obj->variant.fileVariant.topLevel,
                                            0);
                if(ok)
-                       ok = (yaffs_CheckpointWrite(obj->myDev,&endMarker,sizeof(endMarker)) == 
+                       ok = (yaffs_CheckpointWrite(obj->myDev,&endMarker,sizeof(endMarker)) ==
                                sizeof(endMarker));
        }
-       
+
        return ok ? 1 : 0;
 }
 
@@ -4289,14 +4289,14 @@ static int yaffs_ReadCheckpointTnodes(yaffs_Object *obj)
        yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant;
        yaffs_Tnode *tn;
        int nread = 0;
-       
+
        ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
-       
+
        while(ok && (~baseChunk)){
                nread++;
                /* Read level 0 tnode */
-               
-               
+
+
                /* printf("read  tnode at %d\n",baseChunk); */
                tn = yaffs_GetTnodeRaw(dev);
                if(tn)
@@ -4304,27 +4304,27 @@ static int yaffs_ReadCheckpointTnodes(yaffs_Object *obj)
                              (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
                else
                        ok = 0;
-                       
+
                if(tn && ok){
                        ok = yaffs_AddOrFindLevel0Tnode(dev,
-                                                       fileStructPtr,
-                                                       baseChunk,
-                                                       tn) ? 1 : 0;
-                                                       
+                                                       fileStructPtr,
+                                                       baseChunk,
+                                                       tn) ? 1 : 0;
+
                }
-                       
+
                if(ok)
                        ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
-               
+
        }
 
        T(YAFFS_TRACE_CHECKPOINT,(
                TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR),
                nread,baseChunk,ok));
 
-       return ok ? 1 : 0;      
+       return ok ? 1 : 0;
 }
+
 
 static int yaffs_WriteCheckpointObjects(yaffs_Device *dev)
 {
@@ -4334,13 +4334,13 @@ static int yaffs_WriteCheckpointObjects(yaffs_Device *dev)
        int ok = 1;
        struct list_head *lh;
 
-       
+
        /* Iterate through the objects in each hash entry,
         * dumping them to the checkpointing stream.
         */
-        
+
         for(i = 0; ok &&  i <  YAFFS_NOBJECT_BUCKETS; i++){
-               list_for_each(lh, &dev->objectBucket[i].list) {
+               list_for_each(lh, &dev->objectBucket[i].list) {
                        if (lh) {
                                obj = list_entry(lh, yaffs_Object, hashLink);
                                if (!obj->deferedFree) {
@@ -4350,9 +4350,9 @@ static int yaffs_WriteCheckpointObjects(yaffs_Device *dev)
                                        T(YAFFS_TRACE_CHECKPOINT,(
                                                TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %x" TENDSTR),
                                                cp.objectId,cp.parentId,cp.variantType,cp.chunkId,(unsigned) obj));
-                                               
+
                                        ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
-                                       
+
                                        if(ok && obj->variantType == YAFFS_OBJECT_TYPE_FILE){
                                                ok = yaffs_WriteCheckpointTnodes(obj);
                                        }
@@ -4360,14 +4360,14 @@ static int yaffs_WriteCheckpointObjects(yaffs_Device *dev)
                        }
                }
         }
-        
+
         /* Dump end of list */
        memset(&cp,0xFF,sizeof(yaffs_CheckpointObject));
        cp.structType = sizeof(cp);
-       
+
        if(ok)
                ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
-               
+
        return ok ? 1 : 0;
 }
 
@@ -4378,7 +4378,7 @@ static int yaffs_ReadCheckpointObjects(yaffs_Device *dev)
        int ok = 1;
        int done = 0;
        yaffs_Object *hardList = NULL;
-       
+
        while(ok && !done) {
                ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
                if(cp.structType != sizeof(cp)) {
@@ -4386,10 +4386,10 @@ static int yaffs_ReadCheckpointObjects(yaffs_Device *dev)
                                cp.structType,sizeof(cp),ok));
                        ok = 0;
                }
-                       
+
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR),
                        cp.objectId,cp.parentId,cp.variantType,cp.chunkId));
-                       
+
                if(ok && cp.objectId == ~0)
                        done = 1;
                else if(ok){
@@ -4404,14 +4404,14 @@ static int yaffs_ReadCheckpointObjects(yaffs_Device *dev)
                                                    hardList;
                                        hardList = obj;
                                }
-                          
+
                        }
                }
        }
-       
+
        if(ok)
                yaffs_HardlinkFixup(dev,hardList);
-       
+
        return ok ? 1 : 0;
 }
 
@@ -4419,14 +4419,14 @@ static int yaffs_WriteCheckpointSum(yaffs_Device *dev)
 {
        __u32 checkpointSum;
        int ok;
-       
+
        yaffs_GetCheckpointSum(dev,&checkpointSum);
-       
+
        ok = (yaffs_CheckpointWrite(dev,&checkpointSum,sizeof(checkpointSum)) == sizeof(checkpointSum));
-       
+
        if(!ok)
                return 0;
-       
+
        return 1;
 }
 
@@ -4435,17 +4435,17 @@ static int yaffs_ReadCheckpointSum(yaffs_Device *dev)
        __u32 checkpointSum0;
        __u32 checkpointSum1;
        int ok;
-       
+
        yaffs_GetCheckpointSum(dev,&checkpointSum0);
-       
+
        ok = (yaffs_CheckpointRead(dev,&checkpointSum1,sizeof(checkpointSum1)) == sizeof(checkpointSum1));
-       
+
        if(!ok)
                return 0;
-               
+
        if(checkpointSum0 != checkpointSum1)
                return 0;
-       
+
        return 1;
 }
 
@@ -4454,15 +4454,15 @@ static int yaffs_WriteCheckpointData(yaffs_Device *dev)
 {
 
        int ok = 1;
-       
+
        if(dev->skipCheckpointWrite || !dev->isYaffs2){
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint write" TENDSTR)));
                ok = 0;
        }
-               
+
        if(ok)
                ok = yaffs_CheckpointOpen(dev,1);
-       
+
        if(ok){
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR)));
                ok = yaffs_WriteCheckpointValidityMarker(dev,1);
@@ -4479,19 +4479,19 @@ static int yaffs_WriteCheckpointData(yaffs_Device *dev)
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR)));
                ok = yaffs_WriteCheckpointValidityMarker(dev,0);
        }
-       
+
        if(ok){
                ok = yaffs_WriteCheckpointSum(dev);
        }
-       
-       
+
+
        if(!yaffs_CheckpointClose(dev))
                 ok = 0;
-                
+
        if(ok)
-               dev->isCheckpointed = 1;
-        else 
-               dev->isCheckpointed = 0;
+               dev->isCheckpointed = 1;
+        else
+               dev->isCheckpointed = 0;
 
        return dev->isCheckpointed;
 }
@@ -4499,17 +4499,17 @@ static int yaffs_WriteCheckpointData(yaffs_Device *dev)
 static int yaffs_ReadCheckpointData(yaffs_Device *dev)
 {
        int ok = 1;
-       
+
        if(dev->skipCheckpointRead || !dev->isYaffs2){
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint read" TENDSTR)));
                ok = 0;
        }
-       
+
        if(ok)
                ok = yaffs_CheckpointOpen(dev,0); /* open for read */
-       
+
        if(ok){
-               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));   
+               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
                ok = yaffs_ReadCheckpointValidityMarker(dev,1);
        }
        if(ok){
@@ -4517,14 +4517,14 @@ static int yaffs_ReadCheckpointData(yaffs_Device *dev)
                ok = yaffs_ReadCheckpointDevice(dev);
        }
        if(ok){
-               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint objects" TENDSTR)));    
+               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint objects" TENDSTR)));
                ok = yaffs_ReadCheckpointObjects(dev);
        }
        if(ok){
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
                ok = yaffs_ReadCheckpointValidityMarker(dev,0);
        }
-       
+
        if(ok){
                ok = yaffs_ReadCheckpointSum(dev);
                T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint checksum %d" TENDSTR),ok));
@@ -4534,9 +4534,9 @@ static int yaffs_ReadCheckpointData(yaffs_Device *dev)
                ok = 0;
 
        if(ok)
-               dev->isCheckpointed = 1;
-        else 
-               dev->isCheckpointed = 0;
+               dev->isCheckpointed = 1;
+        else
+               dev->isCheckpointed = 0;
 
        return ok ? 1 : 0;
 
@@ -4544,7 +4544,7 @@ static int yaffs_ReadCheckpointData(yaffs_Device *dev)
 
 static void yaffs_InvalidateCheckpoint(yaffs_Device *dev)
 {
-       if(dev->isCheckpointed || 
+       if(dev->isCheckpointed ||
           dev->blocksInCheckpoint > 0){
                dev->isCheckpointed = 0;
                yaffs_CheckpointInvalidateStream(dev);
@@ -4567,7 +4567,7 @@ int yaffs_CheckpointSave(yaffs_Device *dev)
                yaffs_InvalidateCheckpoint(dev);
                yaffs_WriteCheckpointData(dev);
        }
-       
+
        T(YAFFS_TRACE_ALWAYS,(TSTR("save exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
 
        return dev->isCheckpointed;
@@ -4577,7 +4577,7 @@ int yaffs_CheckpointRestore(yaffs_Device *dev)
 {
        int retval;
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore entry: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
-               
+
        retval = yaffs_ReadCheckpointData(dev);
 
        if(dev->isCheckpointed){
@@ -4587,7 +4587,7 @@ int yaffs_CheckpointRestore(yaffs_Device *dev)
        }
 
        T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
-       
+
        return retval;
 }
 
@@ -4623,7 +4623,7 @@ int yaffs_ReadDataFromFile(yaffs_Object * in, __u8 * buffer, loff_t offset,
                chunk++;
 
                /* OK now check for the curveball where the start and end are in
-                * the same chunk.      
+                * the same chunk.
                 */
                if ((start + n) < dev->nDataBytesPerChunk) {
                        nToCopy = n;
@@ -4780,7 +4780,7 @@ int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, loff_t offset,
                                yaffs_ChunkCache *cache;
                                /* If we can't find the data in the cache, then load the cache */
                                cache = yaffs_FindChunkCache(in, chunk);
-                               
+
                                if (!cache
                                    && yaffs_CheckSpaceForAllocation(in->
                                                                     myDev)) {
@@ -4793,12 +4793,12 @@ int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, loff_t offset,
                                                                      cache->
                                                                      data);
                                }
-                               else if(cache && 
-                                       !cache->dirty &&
+                               else if(cache &&
+                                       !cache->dirty &&
                                        !yaffs_CheckSpaceForAllocation(in->myDev)){
                                        /* Drop the cache if it was a read cache item and
                                         * no space check has been made for it.
-                                        */ 
+                                        */
                                         cache = NULL;
                                }
 
@@ -4962,7 +4962,7 @@ int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize)
        int oldFileSize = in->variant.fileVariant.fileSize;
        int newSizeOfPartialChunk;
        int newFullChunks;
-       
+
        yaffs_Device *dev = in->myDev;
 
        yaffs_AddrToChunk(dev, newSize, &newFullChunks, &newSizeOfPartialChunk);
@@ -4986,7 +4986,7 @@ int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize)
 
                if (newSizeOfPartialChunk != 0) {
                        int lastChunk = 1 + newFullChunks;
-                       
+
                        __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
 
                        /* Got to read and rewrite the last chunk with its new size and zero pad */
@@ -5010,8 +5010,8 @@ int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize)
                in->variant.fileVariant.fileSize = newSize;
        }
 
-               
-       
+
+
        /* Write a new object header.
         * show we've shrunk the file, if need be
         * Do this only if the file is not in the deleted directories.
@@ -5333,7 +5333,7 @@ static void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList)
 {
        yaffs_Object *hl;
        yaffs_Object *in;
-       
+
        while (hardList) {
                hl = hardList;
                hardList = (yaffs_Object *) (hardList->hardLinks.next);
@@ -5369,9 +5369,9 @@ static int ybicmp(const void *a, const void *b){
     register int ablock = ((yaffs_BlockIndex *)a)->block;
     register int bblock = ((yaffs_BlockIndex *)b)->block;
     if( aseq == bseq )
-        return ablock - bblock;
+       return ablock - bblock;
     else
-        return aseq - bseq;
+       return aseq - bseq;
 
 }
 
@@ -5396,9 +5396,9 @@ static int yaffs_Scan(yaffs_Device * dev)
        yaffs_Object *in;
        yaffs_Object *parent;
        int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
-       
+
        int alloc_failed = 0;
-       
+
 
        __u8 *chunkData;
 
@@ -5409,9 +5409,9 @@ static int yaffs_Scan(yaffs_Device * dev)
                  (TSTR("yaffs_Scan is not for YAFFS2!" TENDSTR)));
                return YAFFS_FAIL;
        }
-       
+
        //TODO  Throw all the yaffs2 stuuf out of yaffs_Scan since it is only for yaffs1 format.
-       
+
        T(YAFFS_TRACE_SCAN,
          (TSTR("yaffs_Scan starts  intstartblk %d intendblk %d..." TENDSTR),
           dev->internalStartBlock, dev->internalEndBlock));
@@ -5540,7 +5540,7 @@ static int yaffs_Scan(yaffs_Device * dev)
                                /*T((" %d %d deleted\n",blk,c)); */
                        } else if (!tags.chunkUsed) {
                                /* An unassigned chunk in the block
-                                * This means that either the block is empty or 
+                                * This means that either the block is empty or
                                 * this is the one being allocated from
                                 */
 
@@ -5557,9 +5557,9 @@ static int yaffs_Scan(yaffs_Device * dev)
                                        state = YAFFS_BLOCK_STATE_ALLOCATING;
                                        dev->allocationBlock = blk;
                                        dev->allocationPage = c;
-                                       dev->allocationBlockFinder = blk;       
+                                       dev->allocationBlockFinder = blk;
                                        /* Set it to here to encourage the allocator to go forth from here. */
-                                       
+
                                        /* Yaffs2 sanity check:
                                         * This should be the one with the highest sequence number
                                         */
@@ -5589,7 +5589,7 @@ static int yaffs_Scan(yaffs_Device * dev)
                                /* PutChunkIntoFile checks for a clash (two data chunks with
                                 * the same chunkId).
                                 */
-                                
+
                                if(!in)
                                        alloc_failed = 1;
 
@@ -5597,11 +5597,11 @@ static int yaffs_Scan(yaffs_Device * dev)
                                        if(!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk,1))
                                                alloc_failed = 1;
                                }
-                               
+
                                endpos =
                                    (tags.chunkId - 1) * dev->nDataBytesPerChunk +
                                    tags.byteCount;
-                               if (in && 
+                               if (in &&
                                    in->variantType == YAFFS_OBJECT_TYPE_FILE
                                    && in->variant.fileVariant.scannedFileSize <
                                    endpos) {
@@ -5633,7 +5633,7 @@ static int yaffs_Scan(yaffs_Device * dev)
                                                              tags.objectId);
                                if (in && in->variantType != oh->type) {
                                        /* This should not happen, but somehow
-                                        * Wev'e ended up with an objectId that has been reused but not yet 
+                                        * Wev'e ended up with an objectId that has been reused but not yet
                                         * deleted, and worse still it has changed type. Delete the old object.
                                         */
 
@@ -5649,7 +5649,7 @@ static int yaffs_Scan(yaffs_Device * dev)
 
                                if(!in)
                                        alloc_failed = 1;
-                                       
+
                                if (in && oh->shadowsObject > 0) {
                                        yaffs_HandleShadowedObject(dev,
                                                                   oh->
@@ -5772,11 +5772,11 @@ static int yaffs_Scan(yaffs_Device * dev)
                                         * Since we might scan a hardlink before its equivalent object is scanned
                                         * we put them all in a list.
                                         * After scanning is complete, we should have all the objects, so we run through this
-                                        * list and fix up all the chains.              
+                                        * list and fix up all the chains.
                                         */
 
                                        switch (in->variantType) {
-                                       case YAFFS_OBJECT_TYPE_UNKNOWN: 
+                                       case YAFFS_OBJECT_TYPE_UNKNOWN:
                                                /* Todo got a problem */
                                                break;
                                        case YAFFS_OBJECT_TYPE_FILE:
@@ -5811,7 +5811,7 @@ static int yaffs_Scan(yaffs_Device * dev)
                                        case YAFFS_OBJECT_TYPE_SPECIAL:
                                                /* Do nothing */
                                                break;
-                                       case YAFFS_OBJECT_TYPE_SYMLINK: 
+                                       case YAFFS_OBJECT_TYPE_SYMLINK:
                                                in->variant.symLinkVariant.alias =
                                                    yaffs_CloneString(oh->alias);
                                                if(!in->variant.symLinkVariant.alias)
@@ -5846,11 +5846,11 @@ static int yaffs_Scan(yaffs_Device * dev)
        if (blockIndex) {
                YFREE(blockIndex);
        }
-       
-       
+
+
        /* Ok, we've done all the scanning.
         * Fix up the hard link chains.
-        * We should now have scanned all the objects, now it's time to add these 
+        * We should now have scanned all the objects, now it's time to add these
         * hardlinks.
         */
 
@@ -5880,9 +5880,9 @@ static int yaffs_Scan(yaffs_Device * dev)
        if(alloc_failed){
                return YAFFS_FAIL;
        }
-       
+
        T(YAFFS_TRACE_SCAN, (TSTR("yaffs_Scan ends" TENDSTR)));
-       
+
 
        return YAFFS_OK;
 }
@@ -5898,7 +5898,7 @@ static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in)
 
        if(!in)
                return;
-               
+
 #if 0
        T(YAFFS_TRACE_SCAN,(TSTR("details for object %d %s loaded" TENDSTR),
                in->objectId,
@@ -5910,7 +5910,7 @@ static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in)
                chunkData = yaffs_GetTempBuffer(dev, __LINE__);
 
                result = yaffs_ReadChunkWithTagsFromNAND(dev,in->chunkId,chunkData,&tags);
-               oh = (yaffs_ObjectHeader *) chunkData;          
+               oh = (yaffs_ObjectHeader *) chunkData;
 
                in->yst_mode = oh->yst_mode;
 #ifdef CONFIG_YAFFS_WINCE
@@ -5927,17 +5927,17 @@ static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in)
                in->yst_mtime = oh->yst_mtime;
                in->yst_ctime = oh->yst_ctime;
                in->yst_rdev = oh->yst_rdev;
-               
+
 #endif
                yaffs_SetObjectName(in, oh->name);
-               
+
                if(in->variantType == YAFFS_OBJECT_TYPE_SYMLINK){
                         in->variant.symLinkVariant.alias =
                                                    yaffs_CloneString(oh->alias);
                        if(!in->variant.symLinkVariant.alias)
                                alloc_failed = 1; /* Not returned to caller */
                }
-                                                   
+
                yaffs_ReleaseTempBuffer(dev,chunkData, __LINE__);
        }
 }
@@ -5965,13 +5965,13 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
        int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
        int itsUnlinked;
        __u8 *chunkData;
-       
+
        int fileSize;
        int isShrink;
        int foundChunksInBlock;
        int equivalentObjectId;
        int alloc_failed = 0;
-       
+
 
        yaffs_BlockIndex *blockIndex = NULL;
        int altBlockIndex = 0;
@@ -5991,20 +5991,20 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
        dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER;
 
        blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex));
-       
+
        if(!blockIndex) {
                blockIndex = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockIndex));
                altBlockIndex = 1;
        }
-       
+
        if(!blockIndex) {
                T(YAFFS_TRACE_SCAN,
                  (TSTR("yaffs_Scan() could not allocate block index!" TENDSTR)));
                return YAFFS_FAIL;
        }
-       
+
        dev->blocksInCheckpoint = 0;
-       
+
        chunkData = yaffs_GetTempBuffer(dev, __LINE__);
 
        /* Scan all the blocks to determine their state */
@@ -6021,15 +6021,15 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 
                if(bi->sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA)
                        bi->blockState = state = YAFFS_BLOCK_STATE_CHECKPOINT;
-                       
+
                T(YAFFS_TRACE_SCAN_DEBUG,
                  (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk,
                   state, sequenceNumber));
 
-               
+
                if(state == YAFFS_BLOCK_STATE_CHECKPOINT){
                        dev->blocksInCheckpoint++;
-                       
+
                } else if (state == YAFFS_BLOCK_STATE_DEAD) {
                        T(YAFFS_TRACE_BAD_BLOCKS,
                          (TSTR("block %d is bad" TENDSTR), blk));
@@ -6079,8 +6079,8 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
        }
 #else
        {
-               /* Dungy old bubble sort... */
-               
+               /* Dungy old bubble sort... */
+
                yaffs_BlockIndex temp;
                int i;
                int j;
@@ -6097,7 +6097,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 
        YYIELD();
 
-       T(YAFFS_TRACE_SCAN, (TSTR("...done" TENDSTR)));
+       T(YAFFS_TRACE_SCAN, (TSTR("...done" TENDSTR)));
 
        /* Now scan the blocks looking at the data. */
        startIterator = 0;
@@ -6108,30 +6108,30 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
        /* For each block.... backwards */
        for (blockIterator = endIterator; !alloc_failed && blockIterator >= startIterator;
             blockIterator--) {
-               /* Cooperative multitasking! This loop can run for so
+               /* Cooperative multitasking! This loop can run for so
                   long that watchdog timers expire. */
-               YYIELD();
+               YYIELD();
 
                /* get the block to scan in the correct order */
                blk = blockIndex[blockIterator].block;
 
                bi = yaffs_GetBlockInfo(dev, blk);
-               
-               
+
+
                state = bi->blockState;
 
                deleted = 0;
 
                /* For each chunk in each block that needs scanning.... */
                foundChunksInBlock = 0;
-               for (c = dev->nChunksPerBlock - 1; 
+               for (c = dev->nChunksPerBlock - 1;
                     !alloc_failed && c >= 0 &&
                     (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
                      state == YAFFS_BLOCK_STATE_ALLOCATING); c--) {
-                       /* Scan backwards... 
+                       /* Scan backwards...
                         * Read the tags and decide what to do
                         */
-                       
+
                        chunk = blk * dev->nChunksPerBlock + c;
 
                        result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL,
@@ -6145,14 +6145,14 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                 * it is a chunk that was skipped due to failing the erased
                                 * check. Just skip it so that it can be deleted.
                                 * But, more typically, We get here when this is an unallocated
-                                * chunk and his means that either the block is empty or 
+                                * chunk and his means that either the block is empty or
                                 * this is the one being allocated from
                                 */
 
                                if(foundChunksInBlock)
                                {
                                        /* This is a chunk that was skipped due to failing the erased check */
-                                       
+
                                } else if (c == 0) {
                                        /* We're looking at the first chunk in the block so the block is unused */
                                        state = YAFFS_BLOCK_STATE_EMPTY;
@@ -6160,9 +6160,9 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                } else {
                                        if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
                                            state == YAFFS_BLOCK_STATE_ALLOCATING) {
-                                               if(dev->sequenceNumber == bi->sequenceNumber) {
+                                               if(dev->sequenceNumber == bi->sequenceNumber) {
                                                        /* this is the block being allocated from */
-                                               
+
                                                        T(YAFFS_TRACE_SCAN,
                                                          (TSTR
                                                           (" Allocating from %d %d"
@@ -6171,34 +6171,34 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                        state = YAFFS_BLOCK_STATE_ALLOCATING;
                                                        dev->allocationBlock = blk;
                                                        dev->allocationPage = c;
-                                                       dev->allocationBlockFinder = blk;       
+                                                       dev->allocationBlockFinder = blk;
                                                }
                                                else {
                                                        /* This is a partially written block that is not
                                                         * the current allocation block. This block must have
                                                         * had a write failure, so set up for retirement.
                                                         */
-                                                 
+
                                                         bi->needsRetiring = 1;
                                                         bi->gcPrioritise = 1;
-                                                                                                        
+
                                                         T(YAFFS_TRACE_ALWAYS,
                                                         (TSTR("Partially written block %d being set for retirement" TENDSTR),
                                                         blk));
                                                }
 
                                        }
-                                        
+
                                }
 
                                dev->nFreeChunks++;
-                               
+
                        } else if (tags.chunkId > 0) {
                                /* chunkId > 0 so it is a data chunk... */
                                unsigned int endpos;
                                __u32 chunkBase =
                                    (tags.chunkId - 1) * dev->nDataBytesPerChunk;
-                                                               
+
                                foundChunksInBlock = 1;
 
 
@@ -6213,7 +6213,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                        /* Out of memory */
                                        alloc_failed = 1;
                                }
-                               
+
                                if (in &&
                                    in->variantType == YAFFS_OBJECT_TYPE_FILE
                                    && chunkBase <
@@ -6224,14 +6224,14 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                alloc_failed = 1;
                                        }
 
-                                       /* File size is calculated by looking at the data chunks if we have not 
+                                       /* File size is calculated by looking at the data chunks if we have not
                                         * seen an object header yet. Stop this practice once we find an object header.
                                         */
                                        endpos =
                                            (tags.chunkId -
                                             1) * dev->nDataBytesPerChunk +
                                            tags.byteCount;
-                                           
+
                                        if (!in->valid &&       /* have not got an object header yet */
                                            in->variant.fileVariant.
                                            scannedFileSize < endpos) {
@@ -6277,7 +6277,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                    ) {
 
                                        /* If we don't have  valid info then we need to read the chunk
-                                        * TODO In future we can probably defer reading the chunk and 
+                                        * TODO In future we can probably defer reading the chunk and
                                         * living with invalid data until needed.
                                         */
 
@@ -6305,12 +6305,12 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 
                                if (in->valid) {
                                        /* We have already filled this one.
-                                        * We have a duplicate that will be discarded, but 
+                                        * We have a duplicate that will be discarded, but
                                         * we first have to suck out resize info if it is a file.
                                         */
 
-                                       if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) && 
-                                            ((oh && 
+                                       if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) &&
+                                            ((oh &&
                                               oh-> type == YAFFS_OBJECT_TYPE_FILE)||
                                              (tags.extraHeaderInfoAvailable  &&
                                               tags.extraObjectType == YAFFS_OBJECT_TYPE_FILE))
@@ -6361,7 +6361,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                     YAFFS_OBJECTID_LOSTNFOUND)) {
                                        /* We only load some info, don't fiddle with directory structure */
                                        in->valid = 1;
-                                       
+
                                        if(oh) {
                                                in->variantType = oh->type;
 
@@ -6380,13 +6380,13 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                in->yst_mtime = oh->yst_mtime;
                                                in->yst_ctime = oh->yst_ctime;
                                                in->yst_rdev = oh->yst_rdev;
-               
+
 #endif
                                        } else {
                                                in->variantType = tags.extraObjectType;
                                                in->lazyLoaded = 1;
                                        }
-                                               
+
                                        in->chunkId = chunk;
 
                                } else if (!in->valid) {
@@ -6394,7 +6394,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 
                                        in->valid = 1;
                                        in->chunkId = chunk;
-                                       
+
                                        if(oh) {
                                                in->variantType = oh->type;
 
@@ -6415,21 +6415,21 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                in->yst_rdev = oh->yst_rdev;
 #endif
 
-                                               if (oh->shadowsObject > 0) 
+                                               if (oh->shadowsObject > 0)
                                                        yaffs_HandleShadowedObject(dev,
                                                                           oh->
                                                                           shadowsObject,
                                                                           1);
-                                       
+
 
                                                yaffs_SetObjectName(in, oh->name);
                                                parent =
                                                    yaffs_FindOrCreateObjectByNumber
-                                                       (dev, oh->parentObjectId,
-                                                        YAFFS_OBJECT_TYPE_DIRECTORY);
+                                                       (dev, oh->parentObjectId,
+                                                        YAFFS_OBJECT_TYPE_DIRECTORY);
 
                                                 fileSize = oh->fileSize;
-                                                isShrink = oh->isShrink;
+                                                isShrink = oh->isShrink;
                                                 equivalentObjectId = oh->equivalentObjectId;
 
                                        }
@@ -6437,8 +6437,8 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                in->variantType = tags.extraObjectType;
                                                parent =
                                                    yaffs_FindOrCreateObjectByNumber
-                                                       (dev, tags.extraParentObjectId,
-                                                        YAFFS_OBJECT_TYPE_DIRECTORY);
+                                                       (dev, tags.extraParentObjectId,
+                                                        YAFFS_OBJECT_TYPE_DIRECTORY);
                                                 fileSize = tags.extraFileLength;
                                                 isShrink = tags.extraIsShrinkHeader;
                                                 equivalentObjectId = tags.extraEquivalentObjectId;
@@ -6488,11 +6488,11 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                         * Since we might scan a hardlink before its equivalent object is scanned
                                         * we put them all in a list.
                                         * After scanning is complete, we should have all the objects, so we run
-                                        * through this list and fix up all the chains.              
+                                        * through this list and fix up all the chains.
                                         */
 
                                        switch (in->variantType) {
-                                       case YAFFS_OBJECT_TYPE_UNKNOWN: 
+                                       case YAFFS_OBJECT_TYPE_UNKNOWN:
                                                /* Todo got a problem */
                                                break;
                                        case YAFFS_OBJECT_TYPE_FILE:
@@ -6501,7 +6501,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                    scannedFileSize < fileSize) {
                                                        /* This covers the case where the file size is greater
                                                         * than where the data is
-                                                        * This will happen if the file is resized to be larger 
+                                                        * This will happen if the file is resized to be larger
                                                         * than its current data extents.
                                                         */
                                                        in->variant.fileVariant.fileSize = fileSize;
@@ -6536,13 +6536,13 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
                                                    yaffs_CloneString(oh->
                                                                      alias);
                                                   if(!in->variant.symLinkVariant.alias)
-                                                       alloc_failed = 1;
+                                                       alloc_failed = 1;
                                                }
                                                break;
                                        }
 
                                }
-                               
+
                        }
 
                } /* End of scanning for each chunk */
@@ -6563,19 +6563,19 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 
        }
 
-       if (altBlockIndex) 
+       if (altBlockIndex)
                YFREE_ALT(blockIndex);
        else
                YFREE(blockIndex);
-       
+
        /* Ok, we've done all the scanning.
         * Fix up the hard link chains.
-        * We should now have scanned all the objects, now it's time to add these 
+        * We should now have scanned all the objects, now it's time to add these
         * hardlinks.
         */
        yaffs_HardlinkFixup(dev,hardList);
-       
-       
+
+
        /*
        *  Sort out state of unlinked and deleted objects.
        */
@@ -6608,7 +6608,7 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
        }
 
        yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
-       
+
        if(alloc_failed){
                return YAFFS_FAIL;
        }
@@ -6623,10 +6623,10 @@ static int yaffs_ScanBackwards(yaffs_Device * dev)
 static void yaffs_RemoveObjectFromDirectory(yaffs_Object * obj)
 {
        yaffs_Device *dev = obj->myDev;
-       
+
        if(dev && dev->removeObjectCallback)
                dev->removeObjectCallback(obj);
-          
+
        list_del_init(&obj->siblings);
        obj->parent = NULL;
 }
@@ -6704,7 +6704,7 @@ yaffs_Object *yaffs_FindObjectByName(yaffs_Object * directory,
        list_for_each(i, &directory->variant.directoryVariant.children) {
                if (i) {
                        l = list_entry(i, yaffs_Object, siblings);
-                       
+
                        yaffs_CheckObjectDetailsLoaded(l);
 
                        /* Special case for lost-n-found */
@@ -6712,7 +6712,7 @@ yaffs_Object *yaffs_FindObjectByName(yaffs_Object * directory,
                                if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == 0) {
                                        return l;
                                }
-                       } else if (yaffs_SumCompare(l->sum, sum) || l->chunkId <= 0)    
+                       } else if (yaffs_SumCompare(l->sum, sum) || l->chunkId <= 0)
                        {
                                /* LostnFound cunk called Objxxx
                                 * Do a real check
@@ -6784,7 +6784,7 @@ yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object * obj)
 int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize)
 {
        memset(name, 0, buffSize * sizeof(YCHAR));
-       
+
        yaffs_CheckObjectDetailsLoaded(obj);
 
        if (obj->objectId == YAFFS_OBJECTID_LOSTNFOUND) {
@@ -7016,13 +7016,13 @@ static int yaffs_CheckDevFunctions(const yaffs_Device * dev)
 static int yaffs_CreateInitialDirectories(yaffs_Device *dev)
 {
        /* Initialise the unlinked, deleted, root and lost and found directories */
-       
+
        dev->lostNFoundDir = dev->rootDir =  NULL;
        dev->unlinkedDir = dev->deletedDir = NULL;
 
        dev->unlinkedDir =
            yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_UNLINKED, S_IFDIR);
-       
+
        dev->deletedDir =
            yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_DELETED, S_IFDIR);
 
@@ -7032,12 +7032,12 @@ static int yaffs_CreateInitialDirectories(yaffs_Device *dev)
        dev->lostNFoundDir =
            yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_LOSTNFOUND,
                                      YAFFS_LOSTNFOUND_MODE | S_IFDIR);
-       
+
        if(dev->lostNFoundDir && dev->rootDir && dev->unlinkedDir && dev->deletedDir){
                yaffs_AddObjectToDirectory(dev->rootDir, dev->lostNFoundDir);
                return YAFFS_OK;
        }
-       
+
        return YAFFS_FAIL;
 }
 
@@ -7071,12 +7071,12 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 
        /* Check geometry parameters. */
 
-       if ((dev->isYaffs2 && dev->nDataBytesPerChunk < 1024) || 
-           (!dev->isYaffs2 && dev->nDataBytesPerChunk != 512) || 
-            dev->nChunksPerBlock < 2 || 
-            dev->nReservedBlocks < 2 || 
-            dev->internalStartBlock <= 0 || 
-            dev->internalEndBlock <= 0 || 
+       if ((dev->isYaffs2 && dev->nDataBytesPerChunk < 1024) ||
+           (!dev->isYaffs2 && dev->nDataBytesPerChunk != 512) ||
+            dev->nChunksPerBlock < 2 ||
+            dev->nReservedBlocks < 2 ||
+            dev->internalStartBlock <= 0 ||
+            dev->internalEndBlock <= 0 ||
             dev->internalEndBlock <= (dev->internalStartBlock + dev->nReservedBlocks + 2)      // otherwise it is too small
            ) {
                T(YAFFS_TRACE_ALWAYS,
@@ -7122,28 +7122,28 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 
 
        /* OK now calculate a few things for the device */
-       
+
        /*
-        *  Calculate all the chunk size manipulation numbers: 
+        *  Calculate all the chunk size manipulation numbers:
         */
         /* Start off assuming it is a power of 2 */
         dev->chunkShift = ShiftDiv(dev->nDataBytesPerChunk);
         dev->chunkMask = (1<<dev->chunkShift) - 1;
 
         if(dev->nDataBytesPerChunk == (dev->chunkMask + 1)){
-               /* Yes it is a power of 2, disable crumbs */
+               /* Yes it is a power of 2, disable crumbs */
                dev->crumbMask = 0;
                dev->crumbShift = 0;
                dev->crumbsPerChunk = 0;
         } else {
-               /* Not a power of 2, use crumbs instead */
+               /* Not a power of 2, use crumbs instead */
                dev->crumbShift = ShiftDiv(sizeof(yaffs_PackedTags2TagsPart));
                dev->crumbMask = (1<<dev->crumbShift)-1;
                dev->crumbsPerChunk = dev->nDataBytesPerChunk/(1 << dev->crumbShift);
                dev->chunkShift = 0;
                dev->chunkMask = 0;
        }
-               
+
 
        /*
         * Calculate chunkGroupBits.
@@ -7151,9 +7151,9 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
         */
 
        x = dev->nChunksPerBlock * (dev->internalEndBlock + 1);
-       
+
        bits = ShiftsGE(x);
-       
+
        /* Set up tnode width if wide tnodes are enabled. */
        if(!dev->wideTnodesDisabled){
                /* bits must be even so that we end up with 32-bit words */
@@ -7166,20 +7166,20 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
        }
        else
                dev->tnodeWidth = 16;
+
        dev->tnodeMask = (1<<dev->tnodeWidth)-1;
-               
+
        /* Level0 Tnodes are 16 bits or wider (if wide tnodes are enabled),
         * so if the bitwidth of the
         * chunk range we're using is greater than 16 we need
         * to figure out chunk shift and chunkGroupSize
         */
-                
+
        if (bits <= dev->tnodeWidth)
                dev->chunkGroupBits = 0;
        else
                dev->chunkGroupBits = bits - dev->tnodeWidth;
-               
+
 
        dev->chunkGroupSize = 1 << dev->chunkGroupBits;
 
@@ -7217,11 +7217,11 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
        /* Initialise temporary buffers and caches. */
        if(!yaffs_InitialiseTempBuffers(dev))
                init_failed = 1;
-       
+
        dev->srCache = NULL;
        dev->gcCleanupList = NULL;
-       
-       
+
+
        if (!init_failed &&
            dev->nShortOpCaches > 0) {
                int i;
@@ -7233,10 +7233,10 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
                }
 
                buf = dev->srCache =  YMALLOC(srCacheBytes);
-                   
+
                if(dev->srCache)
                        memset(dev->srCache,0,srCacheBytes);
-                  
+
                for (i = 0; i < dev->nShortOpCaches && buf; i++) {
                        dev->srCache[i].object = NULL;
                        dev->srCache[i].lastUse = 0;
@@ -7245,12 +7245,12 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
                }
                if(!buf)
                        init_failed = 1;
-                       
+
                dev->srLastUse = 0;
        }
 
        dev->cacheHits = 0;
-       
+
        if(!init_failed){
                dev->gcCleanupList = YMALLOC(dev->nChunksPerBlock * sizeof(__u32));
                if(!dev->gcCleanupList)
@@ -7262,7 +7262,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
        }
        if(!init_failed && !yaffs_InitialiseBlocks(dev))
                init_failed = 1;
-               
+
        yaffs_InitialiseTnodes(dev);
        yaffs_InitialiseObjects(dev);
 
@@ -7278,14 +7278,14 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
                                  (TSTR("yaffs: restored from checkpoint" TENDSTR)));
                        } else {
 
-                               /* Clean up the mess caused by an aborted checkpoint load 
-                                * and scan backwards. 
+                               /* Clean up the mess caused by an aborted checkpoint load
+                                * and scan backwards.
                                 */
                                yaffs_DeinitialiseBlocks(dev);
                                yaffs_DeinitialiseTnodes(dev);
                                yaffs_DeinitialiseObjects(dev);
-                               
-                       
+
+
                                dev->nErasedBlocks = 0;
                                dev->nFreeChunks = 0;
                                dev->allocationBlock = -1;
@@ -7297,7 +7297,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 
                                if(!init_failed && !yaffs_InitialiseBlocks(dev))
                                        init_failed = 1;
-                                       
+
                                yaffs_InitialiseTnodes(dev);
                                yaffs_InitialiseObjects(dev);
 
@@ -7311,7 +7311,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
                        if(!yaffs_Scan(dev))
                                init_failed = 1;
        }
-               
+
        if(init_failed){
                /* Clean up the mess */
                T(YAFFS_TRACE_TRACING,
@@ -7332,7 +7332,7 @@ int yaffs_GutsInitialise(yaffs_Device * dev)
 
        yaffs_VerifyFreeChunks(dev);
        yaffs_VerifyBlocks(dev);
-       
+
 
        T(YAFFS_TRACE_TRACING,
          (TSTR("yaffs: yaffs_GutsInitialise() done.\n" TENDSTR)));
@@ -7416,7 +7416,7 @@ int yaffs_GetNumberOfFreeChunks(yaffs_Device * dev)
 #endif
 
        nFree += dev->nDeletedFiles;
-       
+
        /* Now count the number of dirty chunks in the cache and subtract those */
 
        {
@@ -7430,12 +7430,12 @@ int yaffs_GetNumberOfFreeChunks(yaffs_Device * dev)
        nFree -= nDirtyCacheChunks;
 
        nFree -= ((dev->nReservedBlocks + 1) * dev->nChunksPerBlock);
-       
+
        /* Now we figure out how much to reserve for the checkpoint and report that... */
        blocksForCheckpoint = dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
        if(blocksForCheckpoint < 0)
                blocksForCheckpoint = 0;
-               
+
        nFree -= (blocksForCheckpoint * dev->nChunksPerBlock);
 
        if (nFree < 0)
@@ -7451,10 +7451,10 @@ static void yaffs_VerifyFreeChunks(yaffs_Device * dev)
 {
        int counted;
        int difference;
-       
+
        if(yaffs_SkipVerification(dev))
                return;
-       
+
        counted = yaffs_CountFreeChunks(dev);
 
        difference = dev->nFreeChunks - counted;
@@ -7470,11 +7470,11 @@ static void yaffs_VerifyFreeChunks(yaffs_Device * dev)
 /*---------------------------------------- YAFFS test code ----------------------*/
 
 #define yaffs_CheckStruct(structure,syze, name) \
-           if(sizeof(structure) != syze) \
+          if(sizeof(structure) != syze) \
               { \
-                T(YAFFS_TRACE_ALWAYS,(TSTR("%s should be %d but is %d\n" TENDSTR),\
+                T(YAFFS_TRACE_ALWAYS,(TSTR("%s should be %d but is %d\n" TENDSTR),\
                 name,syze,sizeof(structure))); \
-                return YAFFS_FAIL; \
+                return YAFFS_FAIL; \
                }
 
 static int yaffs_CheckStructures(void)
index ecf701f5a086960c70975025b0f7e50c156fc931..1f75efd09810e59100e2a47d851311598c26261e 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
 #define YAFFS_OK       1
 #define YAFFS_FAIL  0
 
-/* Give us a  Y=0x59, 
- * Give us an A=0x41, 
- * Give us an FF=0xFF 
+/* Give us a  Y=0x59,
+ * Give us an A=0x41,
+ * Give us an FF=0xFF
  * Give us an S=0x53
- * And what have we got... 
+ * And what have we got...
  */
 #define YAFFS_MAGIC                    0x5941FF53
 
  * The range is limited slightly to help distinguish bad numbers from good.
  * This also allows us to perhaps in the future use special numbers for
  * special purposes.
- * EFFFFF00 allows the allocation of 8 blocks per second (~1Mbytes) for 15 years, 
+ * EFFFFF00 allows the allocation of 8 blocks per second (~1Mbytes) for 15 years,
  * and is a larger number than the lifetime of a 2GB device.
  */
 #define YAFFS_LOWEST_SEQUENCE_NUMBER   0x00001000
@@ -178,7 +178,7 @@ typedef struct {
 
        /* The following stuff only has meaning when we read */
        yaffs_ECCResult eccResult;
-       unsigned blockBad;      
+       unsigned blockBad;
 
        /* YAFFS 1 stuff */
        unsigned chunkDeleted;  /* The chunk is marked deleted */
@@ -244,29 +244,29 @@ typedef enum {
        /* This block is empty */
 
        YAFFS_BLOCK_STATE_ALLOCATING,
-       /* This block is partially allocated. 
+       /* This block is partially allocated.
         * At least one page holds valid data.
         * This is the one currently being used for page
         * allocation. Should never be more than one of these
         */
 
-       YAFFS_BLOCK_STATE_FULL, 
+       YAFFS_BLOCK_STATE_FULL,
        /* All the pages in this block have been allocated.
         */
 
        YAFFS_BLOCK_STATE_DIRTY,
-       /* All pages have been allocated and deleted. 
+       /* All pages have been allocated and deleted.
         * Erase me, reuse me.
         */
 
-       YAFFS_BLOCK_STATE_CHECKPOINT,   
+       YAFFS_BLOCK_STATE_CHECKPOINT,
        /* This block is assigned to holding checkpoint data.
         */
 
-       YAFFS_BLOCK_STATE_COLLECTING,   
+       YAFFS_BLOCK_STATE_COLLECTING,
        /* This block is being garbage collected */
 
-       YAFFS_BLOCK_STATE_DEAD  
+       YAFFS_BLOCK_STATE_DEAD
        /* This block has failed and is not in use */
 } yaffs_BlockState;
 
@@ -279,11 +279,11 @@ typedef struct {
        int pagesInUse:10;      /* number of pages in use */
        unsigned blockState:4;  /* One of the above block states. NB use unsigned because enum is sometimes an int */
        __u32 needsRetiring:1;  /* Data has failed on this block, need to get valid data off */
-                               /* and retire the block. */
+                               /* and retire the block. */
        __u32 skipErasedCheck: 1; /* If this is set we can skip the erased check on this block */
-       __u32 gcPrioritise: 1;  /* An ECC check or blank check has failed on this block. 
+       __u32 gcPrioritise: 1;  /* An ECC check or blank check has failed on this block.
                                   It should be prioritised for GC */
-        __u32 chunkErrorStrikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */
+       __u32 chunkErrorStrikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */
 
 #ifdef CONFIG_YAFFS_YAFFS2
        __u32 hasShrinkHeader:1; /* This block has at least one shrink object header */
@@ -408,7 +408,7 @@ struct yaffs_ObjectStruct {
        __u8 renameAllowed:1;   /* Some objects are not allowed to be renamed. */
        __u8 unlinkAllowed:1;
        __u8 dirty:1;           /* the object needs to be written to flash */
-       __u8 valid:1;           /* When the file system is being loaded up, this 
+       __u8 valid:1;           /* When the file system is being loaded up, this
                                 * object might be created before the data
                                 * is available (ie. file data records appear before the header).
                                 */
@@ -430,11 +430,11 @@ struct yaffs_ObjectStruct {
 
        /* directory structure stuff */
        /* also used for linking up the free list */
-       struct yaffs_ObjectStruct *parent; 
+       struct yaffs_ObjectStruct *parent;
        struct list_head siblings;
 
        /* Where's my object header in NAND? */
-       int chunkId;            
+       int chunkId;
 
        int nDataChunks;        /* Number of data chunks attached to the file. */
 
@@ -491,26 +491,26 @@ typedef struct {
 } yaffs_ObjectBucket;
 
 
-/* yaffs_CheckpointObject holds the definition of an object as dumped 
+/* yaffs_CheckpointObject holds the definition of an object as dumped
  * by checkpointing.
  */
 
 typedef struct {
-        int structType;
-       __u32 objectId;         
+       int structType;
+       __u32 objectId;
        __u32 parentId;
        int chunkId;
-                       
+
        yaffs_ObjectType variantType:3;
-       __u8 deleted:1;         
-       __u8 softDeleted:1;     
-       __u8 unlinked:1;        
-       __u8 fake:1;            
+       __u8 deleted:1;
+       __u8 softDeleted:1;
+       __u8 unlinked:1;
+       __u8 fake:1;
        __u8 renameAllowed:1;
        __u8 unlinkAllowed:1;
-       __u8 serial;            
-       
-       int nDataChunks;        
+       __u8 serial;
+
+       int nDataChunks;
        __u32 fileSizeOrEquivalentObjectId;
 
 }yaffs_CheckpointObject;
@@ -540,14 +540,14 @@ struct yaffs_DeviceStruct {
        int endBlock;           /* End block we're allowed to use */
        int nReservedBlocks;    /* We want this tuneable so that we can reduce */
                                /* reserved blocks on NOR and RAM. */
-       
-       
+
+
        /* Stuff used by the shared space checkpointing mechanism */
        /* If this value is zero, then this mechanism is disabled */
-       
+
        int nCheckpointReservedBlocks; /* Blocks to reserve for checkpoint data */
 
-       
+
 
 
        int nShortOpCaches;     /* If <= 0, then short op caching is disabled, else
@@ -561,8 +561,8 @@ struct yaffs_DeviceStruct {
        void *genericDevice;    /* Pointer to device context
                                 * On an mtd this holds the mtd pointer.
                                 */
-        void *superBlock;
-        
+       void *superBlock;
+
        /* NAND access functions (Must be set before calling YAFFS)*/
 
        int (*writeChunkToNAND) (struct yaffs_DeviceStruct * dev,
@@ -588,21 +588,21 @@ struct yaffs_DeviceStruct {
 #endif
 
        int isYaffs2;
-       
-       /* The removeObjectCallback function must be supplied by OS flavours that 
+
+       /* The removeObjectCallback function must be supplied by OS flavours that
         * need it. The Linux kernel does not use this, but yaffs direct does use
         * it to implement the faster readdir
         */
        void (*removeObjectCallback)(struct yaffs_ObjectStruct *obj);
-       
+
        /* Callback to mark the superblock dirsty */
        void (*markSuperBlockDirty)(void * superblock);
-       
+
        int wideTnodesDisabled; /* Set to disable wide tnodes */
-       
+
 
        /* End of stuff that must be set before initialisation. */
-       
+
        /* Checkpoint control. Can be set before or after initialisation */
        __u8 skipCheckpointRead;
        __u8 skipCheckpointWrite;
@@ -611,21 +611,21 @@ struct yaffs_DeviceStruct {
 
        __u16 chunkGroupBits;   /* 0 for devices <= 32MB. else log2(nchunks) - 16 */
        __u16 chunkGroupSize;   /* == 2^^chunkGroupBits */
-       
+
        /* Stuff to support wide tnodes */
        __u32 tnodeWidth;
        __u32 tnodeMask;
-       
+
        /* Stuff to support various file offses to chunk/offset translations */
        /* "Crumbs" for nDataBytesPerChunk not being a power of 2 */
        __u32 crumbMask;
        __u32 crumbShift;
        __u32 crumbsPerChunk;
-       
+
        /* Straight shifting for nDataBytesPerChunk being a power of 2 */
        __u32 chunkShift;
        __u32 chunkMask;
-       
+
 
 /* XXX U-BOOT XXX */
 #if 0
@@ -636,12 +636,12 @@ struct yaffs_DeviceStruct {
        void (*putSuperFunc) (struct super_block * sb);
 #endif
 #endif
-       __u8 *spareBuffer;      /* For mtdif2 use. Don't know the size of the buffer 
+       __u8 *spareBuffer;      /* For mtdif2 use. Don't know the size of the buffer
                                 * at compile time so we have to allocate it.
                                 */
 
        int isMounted;
-       
+
        int isCheckpointed;
 
 
@@ -650,7 +650,7 @@ struct yaffs_DeviceStruct {
        int internalEndBlock;
        int blockOffset;
        int chunkOffset;
-       
+
 
        /* Runtime checkpointing stuff */
        int checkpointPageSequence;   /* running sequence number of checkpoint pages */
@@ -666,13 +666,13 @@ struct yaffs_DeviceStruct {
        int checkpointMaxBlocks;
        __u32 checkpointSum;
        __u32 checkpointXor;
-       
+
        /* Block Info */
        yaffs_BlockInfo *blockInfo;
        __u8 *chunkBits;        /* bitmap of chunks in use */
        unsigned blockInfoAlt:1;        /* was allocated using alternative strategy */
        unsigned chunkBitsAlt:1;        /* was allocated using alternative strategy */
-       int chunkBitmapStride;  /* Number of bytes of chunkBits per block. 
+       int chunkBitmapStride;  /* Number of bytes of chunkBits per block.
                                 * Must be consistent with nChunksPerBlock.
                                 */
 
@@ -720,7 +720,7 @@ struct yaffs_DeviceStruct {
        int tagsEccUnfixed;
        int nDeletions;
        int nUnmarkedDeletions;
-       
+
        int hasPendingPrioritisedGCs; /* We think this device might have pending prioritised gcs */
 
        /* Special directories */
@@ -731,7 +731,7 @@ struct yaffs_DeviceStruct {
         *      __u8            bufferedData[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK];
         *      yaffs_Spare bufferedSpare[YAFFS_CHUNKS_PER_BLOCK];
         */
-       
+
        int bufferedBlock;      /* Which block is buffered here? */
        int doingBufferedBlockRewrite;
 
@@ -764,7 +764,7 @@ typedef struct yaffs_DeviceStruct yaffs_Device;
 
 /* The static layout of bllock usage etc is stored in the super block header */
 typedef struct {
-        int StructType;
+       int StructType;
        int version;
        int checkpointStartBlock;
        int checkpointEndBlock;
@@ -772,12 +772,12 @@ typedef struct {
        int endBlock;
        int rfu[100];
 } yaffs_SuperBlockHeader;
-       
+
 /* The CheckpointDevice structure holds the device information that changes at runtime and
  * must be preserved over unmount/mount cycles.
  */
 typedef struct {
-        int structType;
+       int structType;
        int nErasedBlocks;
        int allocationBlock;    /* Current block being allocated off */
        __u32 allocationPage;
index 122fb4c06f8ae2f94f349324ed7a467899bf335b..3ed6175163aa001320f78c36cc82743dd2cc5368 100644 (file)
@@ -1,6 +1,6 @@
 #ifndef __YAFFS_MALLOC_H__
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
  *
  * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
  */
+
 /* XXX U-BOOT XXX */
 #if 0
 #include <stdlib.h>
-#endif 
+#endif
 
-void *yaffs_malloc(size_t size); 
+void *yaffs_malloc(size_t size);
 void yaffs_free(void *ptr);
-#endif
 
+#endif
index 407ef2b4e2cb9169e0d0217e104343986b14edad..d0e16d088ef07727014525252471b7c3f57c3671 100644 (file)
@@ -175,7 +175,7 @@ int nandmtd_ReadChunkFromNAND(yaffs_Device * dev, int chunkInNAND, __u8 * data,
        __u8 *spareAsBytes = (__u8 *) spare;
 
        if (data && spare) {
-               if (dev->useNANDECC) {  
+               if (dev->useNANDECC) {
                        /* Careful, this call adds 2 ints */
                        /* to the end of the spare data.  Calling function */
                        /* should allocate enough memory for spare, */
index f75e08c23a40ef11f825f0e1e6701c579a2d111c..317600cac972c8f1b3af48652a9cff64e6a563d9 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index cd2a2a15c76274973c89aa07e4eac7f6f54080d4..f569b999f48ae2be80ea1e7841b0811d9e1937f5 100644 (file)
@@ -162,7 +162,7 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
 
        if (tags)
                yaffs_UnpackTags2(tags, &pt);
-       
+
        if(tags && retval == -EBADMSG && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR)
                tags->eccResult = YAFFS_ECC_RESULT_UNFIXED;
 
index e70d751c21eb9d188a0785df60a8db7bbcf33c1b..b67ba52aa42771448a3b3120dc7d947e034338be 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index b20165584fe62786cc8536c13a4d084f3ed1040c..e790be61a54ecf7e0f7e56dab487cf97e4fc6393 100644 (file)
@@ -10,7 +10,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
+
 /* XXX U-BOOT XXX */
 #include <common.h>
 
@@ -28,9 +28,9 @@ int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
 {
        int result;
        yaffs_ExtendedTags localTags;
-       
+
        int realignedChunkInNAND = chunkInNAND - dev->chunkOffset;
-       
+
        /* If there are no tags provided, use local tags to get prioritised gc working */
        if(!tags)
                tags = &localTags;
@@ -42,14 +42,14 @@ int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
                result = yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(dev,
                                                                        realignedChunkInNAND,
                                                                        buffer,
-                                                                       tags);  
-       if(tags && 
+                                                                       tags);
+       if(tags &&
           tags->eccResult > YAFFS_ECC_RESULT_NO_ERROR){
-       
+
                yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, chunkInNAND/dev->nChunksPerBlock);
-                yaffs_HandleChunkError(dev,bi);
+               yaffs_HandleChunkError(dev,bi);
        }
-                                                               
+
        return result;
 }
 
@@ -60,7 +60,7 @@ int yaffs_WriteChunkWithTagsToNAND(yaffs_Device * dev,
 {
        chunkInNAND -= dev->chunkOffset;
 
-       
+
        if (tags) {
                tags->sequenceNumber = dev->sequenceNumber;
                tags->chunkUsed = 1;
index 8ed1a2d5c4a39bc2bc20176741cd0e572562c06b..48e3f7ec6dd2d4ae696b19382ce3f300613c2f05 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
@@ -41,4 +41,3 @@ int yaffs_EraseBlockInNAND(struct yaffs_DeviceStruct *dev,
 int yaffs_InitialiseNAND(struct yaffs_DeviceStruct *dev);
 
 #endif
-
index 13520e10593210f4c70de42289268a88f5d4f2b9..cd2e96f7ae44468a040c78f68cb50b3b14a23096 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index 627b2f8f5282da825cbb5a4d68302e408b0f8b41..776c5c256c24044300c518cf3e84bd535a74bc59 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index 467d5ac1be34d53b5c62cf3945d6449d725216ca..474400999b34ce888a675c489016d5359743066e 100644 (file)
@@ -131,10 +131,10 @@ void yaffs_UnpackTags2(yaffs_ExtendedTags * t, yaffs_PackedTags2 * pt)
                                                  (yaffs_PackedTags2TagsPart),
                                                  &pt->ecc, &ecc);
                        switch(result){
-                               case 0: 
-                                       t->eccResult = YAFFS_ECC_RESULT_NO_ERROR; 
+                               case 0:
+                                       t->eccResult = YAFFS_ECC_RESULT_NO_ERROR;
                                        break;
-                               case 1: 
+                               case 1:
                                        t->eccResult = YAFFS_ECC_RESULT_FIXED;
                                        break;
                                case -1:
index 7c4a72c483daa83477db3df3a7d4247e1bfb6777..c2242ffe76220470bd94c7135d7ac29db7a363f6 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index a74709f0eb278dcf2214cef718038e822ff31237..4d56f96afb142edfc9bcfb5c266728b583eb0307 100644 (file)
@@ -44,7 +44,7 @@
                register TYPE   t = *pi;                \
                *pi++ = *pj;                            \
                *pj++ = t;                              \
-        } while (--i > 0);                             \
+       } while (--i > 0);                              \
 }
 
 #define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \
@@ -53,7 +53,7 @@
 static __inline void
 swapfunc(char *a, char *b, int n, int swaptype)
 {
-       if (swaptype <= 1) 
+       if (swaptype <= 1)
                swapcode(long, a, b, n)
        else
                swapcode(char, a, b, n)
@@ -74,7 +74,7 @@ med3(char *a, char *b, char *c, int (*cmp)(const void *, const void *))
 {
        return cmp(a, b) < 0 ?
               (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a ))
-              :(cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c ));
+             :(cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c ));
 }
 
 #ifndef min
@@ -140,7 +140,7 @@ loop:       SWAPINIT(a, es);
        }
        if (swap_cnt == 0) {  /* Switch to insertion sort */
                for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es)
-                       for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0; 
+                       for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0;
                             pl -= es)
                                swap(pl, pl - es);
                return;
@@ -153,7 +153,7 @@ loop:       SWAPINIT(a, es);
        vecswap(pb, pn - r, r);
        if ((r = pb - pa) > es)
                yaffs_qsort(a, r / es, es, cmp);
-       if ((r = pd - pc) > es) { 
+       if ((r = pd - pc) > es) {
                /* Iterate rather than recurse to save stack space */
                a = pn - r;
                n = r / es;
index 3ec73979de0488538264ed1de57148cddf843de0..19083da51a2e0826ec6f329da4c457eea43c0a26 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
@@ -18,6 +18,6 @@
 #define __YAFFS_QSORT_H__
 
 extern void yaffs_qsort (void *const base, size_t total_elems, size_t size,
-                   int (*cmp)(const void *, const void *));
+                  int (*cmp)(const void *, const void *));
 
 #endif
index 045ab42db53215a9d6c0bd4afc681ff351f809d6..3cff8bee795ca45b28158811d3c21bbcc7bd8613 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index c1edb6a19ab859e69c0456c6752959646ce03c12..a61e3ba14f1ffeff4937c61847112ca18ebf6356 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index ba56727fffa837efb27039ca29deaf67602e4983..2fd0c24ed26c456cc88530d714680e68dc380311 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index a4a0924ef9114b7255600b083d4c55b83fae8177..3beb34d14592d2c0cfa532520405626b240dc81b 100644 (file)
@@ -83,7 +83,7 @@ void yaffsfs_LocalInitialisation(void)
 // NB Though /boot and /flash occupy the same physical device they
 // are still disticnt "yaffs_Devices. You may think of these as "partitions"
 // using non-overlapping areas in the same device.
-// 
+//
 
 #include "yaffs_ramdisk.h"
 #include "yaffs_flashif.h"
@@ -124,7 +124,7 @@ int yaffs_StartUp(void)
        // Stuff to configure YAFFS
        // Stuff to initialise anything special (eg lock semaphore).
        yaffsfs_LocalInitialisation();
-       
+
        // Set up devices
 
 /* XXX U-BOOT XXX */
@@ -134,7 +134,7 @@ int yaffs_StartUp(void)
        ramDev.nChunksPerBlock = 32;
        ramDev.nReservedBlocks = 2; // Set this smaller for RAM
        ramDev.startBlock = 1; // Can't use block 0
-       ramDev.endBlock = 127; // Last block in 2MB.    
+       ramDev.endBlock = 127; // Last block in 2MB.
        ramDev.useNANDECC = 1;
        ramDev.nShortOpCaches = 0;      // Disable caching on this device.
        ramDev.genericDevice = (void *) 0;      // Used to identify the device in fstat.
@@ -148,7 +148,7 @@ int yaffs_StartUp(void)
        bootDev.nChunksPerBlock = 32;
        bootDev.nReservedBlocks = 5;
        bootDev.startBlock = 1; // Can't use block 0
-       bootDev.endBlock = 127; // Last block in 2MB.   
+       bootDev.endBlock = 127; // Last block in 2MB.
        bootDev.useNANDECC = 0; // use YAFFS's ECC
        bootDev.nShortOpCaches = 10; // Use caches
        bootDev.genericDevice = (void *) 1;     // Used to identify the device in fstat.
@@ -196,13 +196,13 @@ int yaffs_StartUp(void)
                flashDev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK;
                flashDev->nDataBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
        }
-       
+
        /* ... and common functions */
        flashDev->eraseBlockInNAND = nandmtd_EraseBlockInNAND;
        flashDev->initialiseNAND = nandmtd_InitialiseNAND;
 
        yaffs_initialise(yaffsfs_config);
-       
+
        return 0;
 }
 
@@ -219,19 +219,19 @@ void make_a_file(char *yaffsName,char bval,int sizeOfFile)
                printf("Error opening file: %d\n", outh);
                return;
        }
-       
+
        memset(buffer,bval,100);
-       
+
        do{
                i = sizeOfFile;
                if(i > 100) i = 100;
                sizeOfFile -= i;
-               
+
                yaffs_write(outh,buffer,i);
-               
+
        } while (sizeOfFile > 0);
-       
-               
+
+
        yaffs_close(outh);
 }
 
@@ -252,7 +252,7 @@ void read_a_file(char *fn)
        {
                printf("%02x ",b);
                i++;
-               if(i > 32) 
+               if(i > 32)
                {
                   printf("\n");
                   i = 0;;
@@ -305,7 +305,7 @@ void cmd_yaffs_mread_file(char *fn, char *addr)
 {
        int h;
        struct yaffs_stat s;
-       
+
        checkMount();
 
        yaffs_stat(fn,&s);
@@ -317,7 +317,7 @@ void cmd_yaffs_mread_file(char *fn, char *addr)
                printf("File not found\n");
                return;
        }
-                               
+
        yaffs_read(h,addr,(int)s.st_size);
        printf("\t[DONE]\n");
 
@@ -335,9 +335,9 @@ void cmd_yaffs_mwrite_file(char *fn, char *addr, int size)
        {
                printf("Error opening file: %d\n", outh);
        }
-       
+
        yaffs_write(outh,addr,size);
-       
+
        yaffs_close(outh);
 }
 
@@ -381,7 +381,7 @@ void cmd_yaffs_mkdir(const char *dir)
        checkMount();
 
        int retval = yaffs_mkdir(dir, 0);
-       
+
        if ( retval < 0)
                printf("yaffs_mkdir returning error: %d\n", retval);
 }
@@ -391,7 +391,7 @@ void cmd_yaffs_rmdir(const char *dir)
        checkMount();
 
        int retval = yaffs_rmdir(dir);
-       
+
        if ( retval < 0)
                printf("yaffs_rmdir returning error: %d\n", retval);
 }
@@ -401,7 +401,7 @@ void cmd_yaffs_rm(const char *path)
        checkMount();
 
        int retval = yaffs_unlink(path);
-       
+
        if ( retval < 0)
                printf("yaffs_unlink returning error: %d\n", retval);
 }
@@ -411,7 +411,7 @@ void cmd_yaffs_mv(const char *oldPath, const char *newPath)
        checkMount();
 
        int retval = yaffs_rename(newPath, oldPath);
-       
+
        if ( retval < 0)
                printf("yaffs_unlink returning error: %d\n", retval);
 }
index 6ae169612b884ecee64b47c6dd550624780cc38f..3503dc863fb3e0093271d39f884161e290e52719 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
@@ -43,4 +43,3 @@ void yaffsfs_SetError(int err);
 int yaffsfs_GetError(void);
 
 #endif
-
index f62c952ddcc9d1c8b8a27307f799c3483014cffe..111cb348c0dc66c98cb41af24c5810d16cea2edc 100644 (file)
@@ -10,7 +10,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
+
 /* XXX U-BOOT XXX */
 #include <common.h>
 #include <malloc.h>
@@ -44,7 +44,7 @@ static void yaffsfs_RemoveObjectCallback(yaffs_Object *obj);
 
 
 // Handle management.
-// 
+//
 
 
 unsigned int yaffs_wr_attempts;
@@ -82,7 +82,7 @@ yaffsfs_Handle *yaffsfs_GetHandlePointer(int h)
        {
                return NULL;
        }
-       
+
        return &yaffsfs_handle[h];
 }
 
@@ -94,7 +94,7 @@ yaffs_Object *yaffsfs_GetHandleObject(int handle)
        {
                return h->obj;
        }
-       
+
        return NULL;
 }
 
@@ -107,7 +107,7 @@ static int yaffsfs_GetHandle(void)
 {
        int i;
        yaffsfs_Handle *h;
-       
+
        for(i = 0; i < YAFFSFS_N_HANDLES; i++)
        {
                h = yaffsfs_GetHandlePointer(i);
@@ -131,7 +131,7 @@ static int yaffsfs_GetHandle(void)
 static int yaffsfs_PutHandle(int handle)
 {
        yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle);
-       
+
        if(h)
        {
                h->inUse = 0;
@@ -164,7 +164,7 @@ static yaffs_Device *yaffsfs_FindDevice(const char *path, char **restOfPath)
        yaffs_Device *retval = NULL;
        int thisMatchLength;
        int longestMatch = -1;
-       
+
        // Check all configs, choose the one that:
        // 1) Actually matches a prefix (ie /a amd /abc will not match
        // 2) Matches the longest.
@@ -173,10 +173,10 @@ static yaffs_Device *yaffsfs_FindDevice(const char *path, char **restOfPath)
                leftOver = path;
                p = cfg->prefix;
                thisMatchLength = 0;
-               
-               while(*p &&  //unmatched part of prefix 
+
+               while(*p &&  //unmatched part of prefix
                      strcmp(p,"/") && // the rest of the prefix is not / (to catch / at end)
-                     *leftOver && 
+                     *leftOver &&
                      yaffsfs_Match(*p,*leftOver))
                {
                        p++;
@@ -201,7 +201,7 @@ static yaffs_Object *yaffsfs_FindRoot(const char *path, char **restOfPath)
 {
 
        yaffs_Device *dev;
-       
+
        dev= yaffsfs_FindDevice(path,restOfPath);
        if(dev && dev->isMounted)
        {
@@ -216,7 +216,7 @@ static yaffs_Object *yaffsfs_FollowLink(yaffs_Object *obj,int symDepth)
        while(obj && obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
        {
                char *alias = obj->variant.symLinkVariant.alias;
-                                               
+
                if(*alias == '/')
                {
                        // Starts with a /, need to scan from root up
@@ -242,12 +242,12 @@ static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,const char *
        char *restOfPath;
        char str[YAFFS_MAX_NAME_LENGTH+1];
        int i;
-       
+
        if(symDepth > YAFFSFS_MAX_SYMLINK_DEREFERENCES)
        {
                return NULL;
        }
-       
+
        if(startDir)
        {
                dir = startDir;
@@ -257,20 +257,20 @@ static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,const char *
        {
                dir = yaffsfs_FindRoot(path,&restOfPath);
        }
-       
+
        while(dir)
-       {       
+       {
                // parse off /.
-               // curve ball: also throw away surplus '/' 
+               // curve ball: also throw away surplus '/'
                // eg. "/ram/x////ff" gets treated the same as "/ram/x/ff"
                while(*restOfPath == '/')
                {
                        restOfPath++; // get rid of '/'
                }
-               
+
                *name = restOfPath;
                i = 0;
-               
+
                while(*restOfPath && *restOfPath != '/')
                {
                        if (i < YAFFS_MAX_NAME_LENGTH)
@@ -281,7 +281,7 @@ static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,const char *
                        }
                        restOfPath++;
                }
-               
+
                if(!*restOfPath)
                {
                        // got to the end of the string
@@ -300,14 +300,14 @@ static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,const char *
                        else
                        {
                                dir = yaffs_FindObjectByName(dir,str);
-                               
+
                                while(dir && dir->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
                                {
-                               
+
                                        dir = yaffsfs_FollowLink(dir,symDepth);
-               
+
                                }
-                               
+
                                if(dir && dir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
                                {
                                        dir = NULL;
@@ -325,19 +325,19 @@ static yaffs_Object *yaffsfs_FindDirectory(yaffs_Object *relativeDirectory,const
 }
 
 // yaffsfs_FindObject turns a path for an existing object into the object
-// 
+//
 static yaffs_Object *yaffsfs_FindObject(yaffs_Object *relativeDirectory, const char *path,int symDepth)
 {
        yaffs_Object *dir;
        char *name;
-       
+
        dir = yaffsfs_FindDirectory(relativeDirectory,path,&name,symDepth);
-       
+
        if(dir && *name)
        {
                return yaffs_FindObjectByName(dir,name);
        }
-       
+
        return dir;
 }
 
@@ -355,29 +355,29 @@ int yaffs_open(const char *path, int oflag, int mode)
        int openDenied = 0;
        int symDepth = 0;
        int errorReported = 0;
-       
+
        int i;
-       
-       
+
+
        // todo sanity check oflag (eg. can't have O_TRUNC without WRONLY or RDWR
-       
-       
+
+
        yaffsfs_Lock();
-       
+
        handle = yaffsfs_GetHandle();
-       
+
        if(handle >= 0)
        {
 
                h = yaffsfs_GetHandlePointer(handle);
-       
-       
+
+
                // try to find the exisiting object
                obj = yaffsfs_FindObject(NULL,path,0);
-               
+
                if(obj && obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
                {
-               
+
                        obj = yaffsfs_FollowLink(obj,symDepth++);
                }
 
@@ -385,10 +385,10 @@ int yaffs_open(const char *path, int oflag, int mode)
                {
                        // Check if the object is already in use
                        alreadyOpen = alreadyExclusive = 0;
-                       
+
                        for(i = 0; i <= YAFFSFS_N_HANDLES; i++)
                        {
-                               
+
                                if(i != handle &&
                                   yaffsfs_handle[i].inUse &&
                                    obj == yaffsfs_handle[i].obj)
@@ -405,7 +405,7 @@ int yaffs_open(const char *path, int oflag, int mode)
                        {
                                openDenied = 1;
                        }
-                       
+
                        // Open should fail if O_CREAT and O_EXCL are specified
                        if((oflag & O_EXCL) && (oflag & O_CREAT))
                        {
@@ -413,7 +413,7 @@ int yaffs_open(const char *path, int oflag, int mode)
                                yaffsfs_SetError(-EEXIST);
                                errorReported = 1;
                        }
-                       
+
                        // Check file permissions
                        if( (oflag & (O_RDWR | O_WRONLY)) == 0 &&     // ie O_RDONLY
                           !(obj->yst_mode & S_IREAD))
@@ -421,34 +421,34 @@ int yaffs_open(const char *path, int oflag, int mode)
                                openDenied = 1;
                        }
 
-                       if( (oflag & O_RDWR) && 
+                       if( (oflag & O_RDWR) &&
                           !(obj->yst_mode & S_IREAD))
                        {
                                openDenied = 1;
                        }
 
-                       if( (oflag & (O_RDWR | O_WRONLY)) && 
+                       if( (oflag & (O_RDWR | O_WRONLY)) &&
                           !(obj->yst_mode & S_IWRITE))
                        {
                                openDenied = 1;
                        }
-                       
+
                }
-               
+
                else if((oflag & O_CREAT))
                {
                        // Let's see if we can create this file
                        dir = yaffsfs_FindDirectory(NULL,path,&name,0);
                        if(dir)
                        {
-                               obj = yaffs_MknodFile(dir,name,mode,0,0);       
+                               obj = yaffs_MknodFile(dir,name,mode,0,0);
                        }
                        else
                        {
                                yaffsfs_SetError(-ENOTDIR);
                        }
                }
-               
+
                if(obj && !openDenied)
                {
                        h->obj = obj;
@@ -457,14 +457,14 @@ int yaffs_open(const char *path, int oflag, int mode)
                        h->append =  (oflag & O_APPEND) ? 1 : 0;
                        h->exclusive = (oflag & O_EXCL) ? 1 : 0;
                        h->position = 0;
-                       
+
                        obj->inUse++;
                        if((oflag & O_TRUNC) && !h->readOnly)
                        {
                                //todo truncate
                                yaffs_ResizeFile(obj,0);
                        }
-                       
+
                }
                else
                {
@@ -476,23 +476,23 @@ int yaffs_open(const char *path, int oflag, int mode)
                        }
                        handle = -1;
                }
-               
+
        }
-       
+
        yaffsfs_Unlock();
-       
-       return handle;          
+
+       return handle;
 }
 
 int yaffs_close(int fd)
 {
        yaffsfs_Handle *h = NULL;
        int retVal = 0;
-       
+
        yaffsfs_Lock();
 
        h = yaffsfs_GetHandlePointer(fd);
-       
+
        if(h && h->inUse)
        {
                // clean up
@@ -508,12 +508,12 @@ int yaffs_close(int fd)
        else
        {
                // bad handle
-               yaffsfs_SetError(-EBADF);               
+               yaffsfs_SetError(-EBADF);
                retVal = -1;
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
 }
 
@@ -524,15 +524,15 @@ int yaffs_read(int fd, void *buf, unsigned int nbyte)
        int pos = 0;
        int nRead = -1;
        int maxRead;
-       
+
        yaffsfs_Lock();
        h = yaffsfs_GetHandlePointer(fd);
        obj = yaffsfs_GetHandleObject(fd);
-       
+
        if(!h || !obj)
        {
                // bad handle
-               yaffsfs_SetError(-EBADF);               
+               yaffsfs_SetError(-EBADF);
        }
        else if( h && obj)
        {
@@ -551,7 +551,7 @@ int yaffs_read(int fd, void *buf, unsigned int nbyte)
                        nbyte = maxRead;
                }
 
-               
+
                if(nbyte > 0)
                {
                        nRead = yaffs_ReadDataFromFile(obj,buf,pos,nbyte);
@@ -568,14 +568,14 @@ int yaffs_read(int fd, void *buf, unsigned int nbyte)
                {
                        nRead = 0;
                }
-               
+
        }
-       
+
        yaffsfs_Unlock();
-       
-       
+
+
        return (nRead >= 0) ? nRead : -1;
-               
+
 }
 
 int yaffs_write(int fd, const void *buf, unsigned int nbyte)
@@ -585,15 +585,15 @@ int yaffs_write(int fd, const void *buf, unsigned int nbyte)
        int pos = 0;
        int nWritten = -1;
        int writeThrough = 0;
-       
+
        yaffsfs_Lock();
        h = yaffsfs_GetHandlePointer(fd);
        obj = yaffsfs_GetHandleObject(fd);
-       
+
        if(!h || !obj)
        {
                // bad handle
-               yaffsfs_SetError(-EBADF);               
+               yaffsfs_SetError(-EBADF);
        }
        else if( h && obj && h->readOnly)
        {
@@ -609,9 +609,9 @@ int yaffs_write(int fd, const void *buf, unsigned int nbyte)
                {
                        pos = h->position;
                }
-               
+
                nWritten = yaffs_WriteDataToFile(obj,buf,pos,nbyte,writeThrough);
-               
+
                if(nWritten >= 0)
                {
                        h->position = pos + nWritten;
@@ -620,12 +620,12 @@ int yaffs_write(int fd, const void *buf, unsigned int nbyte)
                {
                        //todo error
                }
-               
+
        }
-       
+
        yaffsfs_Unlock();
-       
-       
+
+
        return (nWritten >= 0) ? nWritten : -1;
 
 }
@@ -635,43 +635,43 @@ int yaffs_truncate(int fd, off_t newSize)
        yaffsfs_Handle *h = NULL;
        yaffs_Object *obj = NULL;
        int result = 0;
-       
+
        yaffsfs_Lock();
        h = yaffsfs_GetHandlePointer(fd);
        obj = yaffsfs_GetHandleObject(fd);
-       
+
        if(!h || !obj)
        {
                // bad handle
-               yaffsfs_SetError(-EBADF);               
+               yaffsfs_SetError(-EBADF);
        }
        else
        {
                // resize the file
                result = yaffs_ResizeFile(obj,newSize);
-       }       
+       }
        yaffsfs_Unlock();
-       
-       
+
+
        return (result) ? 0 : -1;
 
 }
 
-off_t yaffs_lseek(int fd, off_t offset, int whence) 
+off_t yaffs_lseek(int fd, off_t offset, int whence)
 {
        yaffsfs_Handle *h = NULL;
        yaffs_Object *obj = NULL;
        int pos = -1;
        int fSize = -1;
-       
+
        yaffsfs_Lock();
        h = yaffsfs_GetHandlePointer(fd);
        obj = yaffsfs_GetHandleObject(fd);
-       
+
        if(!h || !obj)
        {
                // bad handle
-               yaffsfs_SetError(-EBADF);               
+               yaffsfs_SetError(-EBADF);
        }
        else if(whence == SEEK_SET)
        {
@@ -695,7 +695,7 @@ off_t yaffs_lseek(int fd, off_t offset, int whence)
                        pos = fSize + offset;
                }
        }
-       
+
        if(pos >= 0)
        {
                h->position = pos;
@@ -705,20 +705,20 @@ off_t yaffs_lseek(int fd, off_t offset, int whence)
                // todo error
        }
 
-       
+
        yaffsfs_Unlock();
-       
+
        return pos;
 }
 
 
-int yaffsfs_DoUnlink(const char *path,int isDirectory) 
+int yaffsfs_DoUnlink(const char *path,int isDirectory)
 {
        yaffs_Object *dir = NULL;
        yaffs_Object *obj = NULL;
        char *name;
        int result = YAFFS_FAIL;
-       
+
        yaffsfs_Lock();
 
        obj = yaffsfs_FindObject(NULL,path,0);
@@ -742,25 +742,25 @@ int yaffsfs_DoUnlink(const char *path,int isDirectory)
        else
        {
                result = yaffs_Unlink(dir,name);
-               
+
                if(result == YAFFS_FAIL && isDirectory)
                {
                        yaffsfs_SetError(-ENOTEMPTY);
                }
        }
-       
+
        yaffsfs_Unlock();
-       
+
        // todo error
-       
+
        return (result == YAFFS_FAIL) ? -1 : 0;
 }
-int yaffs_rmdir(const char *path) 
+int yaffs_rmdir(const char *path)
 {
        return yaffsfs_DoUnlink(path,1);
 }
 
-int yaffs_unlink(const char *path) 
+int yaffs_unlink(const char *path)
 {
        return yaffsfs_DoUnlink(path,0);
 }
@@ -774,34 +774,34 @@ int yaffs_rename(const char *oldPath, const char *newPath)
        char *newname;
        int result= YAFFS_FAIL;
        int renameAllowed = 1;
-       
+
        yaffsfs_Lock();
-       
+
        olddir = yaffsfs_FindDirectory(NULL,oldPath,&oldname,0);
        newdir = yaffsfs_FindDirectory(NULL,newPath,&newname,0);
        obj = yaffsfs_FindObject(NULL,oldPath,0);
-       
+
        if(!olddir || !newdir || !obj)
        {
                // bad file
-               yaffsfs_SetError(-EBADF);       
-               renameAllowed = 0;      
+               yaffsfs_SetError(-EBADF);
+               renameAllowed = 0;
        }
        else if(olddir->myDev != newdir->myDev)
        {
                // oops must be on same device
                // todo error
                yaffsfs_SetError(-EXDEV);
-               renameAllowed = 0;      
+               renameAllowed = 0;
        }
        else if(obj && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
        {
-               // It is a directory, check that it is not being renamed to 
+               // It is a directory, check that it is not being renamed to
                // being its own decendent.
                // Do this by tracing from the new directory back to the root, checking for obj
-               
+
                yaffs_Object *xx = newdir;
-               
+
                while( renameAllowed && xx)
                {
                        if(xx == obj)
@@ -812,15 +812,15 @@ int yaffs_rename(const char *oldPath, const char *newPath)
                }
                if(!renameAllowed) yaffsfs_SetError(-EACCESS);
        }
-       
+
        if(renameAllowed)
        {
                result = yaffs_RenameObject(olddir,oldname,newdir,newname);
        }
-       
+
        yaffsfs_Unlock();
-       
-       return (result == YAFFS_FAIL) ? -1 : 0; 
+
+       return (result == YAFFS_FAIL) ? -1 : 0;
 }
 
 
@@ -838,12 +838,12 @@ static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf)
        buf->st_dev = (int)obj->myDev->genericDevice;
        buf->st_ino = obj->objectId;
        buf->st_mode = obj->yst_mode & ~S_IFMT; // clear out file type bits
-       
-               if(obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) 
+
+               if(obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
                {
                        buf->st_mode |= S_IFDIR;
                }
-               else if(obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) 
+               else if(obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
                {
                        buf->st_mode |= S_IFLNK;
                }
@@ -851,17 +851,17 @@ static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf)
                {
                        buf->st_mode |= S_IFREG;
                }
-               
+
        buf->st_nlink = yaffs_GetObjectLinkCount(obj);
-       buf->st_uid = 0;    
-       buf->st_gid = 0;;     
+       buf->st_uid = 0;
+       buf->st_gid = 0;;
        buf->st_rdev = obj->yst_rdev;
        buf->st_size = yaffs_GetObjectFileLength(obj);
                buf->st_blksize = obj->myDev->nDataBytesPerChunk;
        buf->st_blocks = (buf->st_size + buf->st_blksize -1)/buf->st_blksize;
-       buf->yst_atime = obj->yst_atime; 
-       buf->yst_ctime = obj->yst_ctime; 
-       buf->yst_mtime = obj->yst_mtime; 
+       buf->yst_atime = obj->yst_atime;
+       buf->yst_ctime = obj->yst_ctime;
+       buf->yst_mtime = obj->yst_mtime;
                retVal = 0;
        }
        return retVal;
@@ -870,17 +870,17 @@ static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf)
 static int yaffsfs_DoStatOrLStat(const char *path, struct yaffs_stat *buf,int doLStat)
 {
        yaffs_Object *obj;
-       
+
        int retVal = -1;
-       
+
        yaffsfs_Lock();
        obj = yaffsfs_FindObject(NULL,path,0);
-       
+
        if(!doLStat && obj)
        {
                obj = yaffsfs_FollowLink(obj,0);
        }
-       
+
        if(obj)
        {
                retVal = yaffsfs_DoStat(obj,buf);
@@ -890,11 +890,11 @@ static int yaffsfs_DoStatOrLStat(const char *path, struct yaffs_stat *buf,int do
                // todo error not found
                yaffsfs_SetError(-ENOENT);
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
-       
+
 }
 
 int yaffs_stat(const char *path, struct yaffs_stat *buf)
@@ -910,12 +910,12 @@ int yaffs_lstat(const char *path, struct yaffs_stat *buf)
 int yaffs_fstat(int fd, struct yaffs_stat *buf)
 {
        yaffs_Object *obj;
-       
+
        int retVal = -1;
-       
+
        yaffsfs_Lock();
        obj = yaffsfs_GetHandleObject(fd);
-       
+
        if(obj)
        {
                retVal = yaffsfs_DoStat(obj,buf);
@@ -923,11 +923,11 @@ int yaffs_fstat(int fd, struct yaffs_stat *buf)
        else
        {
                // bad handle
-               yaffsfs_SetError(-EBADF);               
+               yaffsfs_SetError(-EBADF);
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
 }
 
@@ -939,14 +939,14 @@ static int yaffsfs_DoChMod(yaffs_Object *obj,mode_t mode)
        {
                obj = yaffs_GetEquivalentObject(obj);
        }
-       
+
        if(obj)
        {
                obj->yst_mode = mode;
                obj->dirty = 1;
                result = yaffs_FlushFile(obj,0);
        }
-       
+
        return result == YAFFS_OK ? 0 : -1;
 }
 
@@ -954,12 +954,12 @@ static int yaffsfs_DoChMod(yaffs_Object *obj,mode_t mode)
 int yaffs_chmod(const char *path, mode_t mode)
 {
        yaffs_Object *obj;
-       
+
        int retVal = -1;
-       
+
        yaffsfs_Lock();
        obj = yaffsfs_FindObject(NULL,path,0);
-       
+
        if(obj)
        {
                retVal = yaffsfs_DoChMod(obj,mode);
@@ -969,23 +969,23 @@ int yaffs_chmod(const char *path, mode_t mode)
                // todo error not found
                yaffsfs_SetError(-ENOENT);
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
-       
+
 }
 
 
 int yaffs_fchmod(int fd, mode_t mode)
 {
        yaffs_Object *obj;
-       
+
        int retVal = -1;
-       
+
        yaffsfs_Lock();
        obj = yaffsfs_GetHandleObject(fd);
-       
+
        if(obj)
        {
                retVal = yaffsfs_DoChMod(obj,mode);
@@ -993,11 +993,11 @@ int yaffs_fchmod(int fd, mode_t mode)
        else
        {
                // bad handle
-               yaffsfs_SetError(-EBADF);               
+               yaffsfs_SetError(-EBADF);
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
 }
 
@@ -1008,7 +1008,7 @@ int yaffs_mkdir(const char *path, mode_t mode)
        yaffs_Object *dir = NULL;
        char *name;
        int retVal= -1;
-       
+
        yaffsfs_Lock();
        parent = yaffsfs_FindDirectory(NULL,path,&name,0);
        if(parent)
@@ -1022,9 +1022,9 @@ int yaffs_mkdir(const char *path, mode_t mode)
                yaffsfs_SetError(-ENOSPC); // just assume no space for now
                retVal = -1;
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
 }
 
@@ -1034,9 +1034,9 @@ int yaffs_mount(const char *path)
        int result=YAFFS_FAIL;
        yaffs_Device *dev=NULL;
        char *dummy;
-       
+
        T(YAFFS_TRACE_ALWAYS,("yaffs: Mounting %s\n",path));
-       
+
        yaffsfs_Lock();
        dev = yaffsfs_FindDevice(path,&dummy);
        if(dev)
@@ -1050,7 +1050,7 @@ int yaffs_mount(const char *path)
                                yaffsfs_SetError(-ENOMEM);
                        }
                        retVal = result ? 0 : -1;
-                       
+
                }
                else
                {
@@ -1065,7 +1065,7 @@ int yaffs_mount(const char *path)
        }
        yaffsfs_Unlock();
        return retVal;
-       
+
 }
 
 int yaffs_unmount(const char *path)
@@ -1073,7 +1073,7 @@ int yaffs_unmount(const char *path)
        int retVal=-1;
        yaffs_Device *dev=NULL;
        char *dummy;
-       
+
        yaffsfs_Lock();
        dev = yaffsfs_FindDevice(path,&dummy);
        if(dev)
@@ -1082,10 +1082,10 @@ int yaffs_unmount(const char *path)
                {
                        int i;
                        int inUse;
-                       
+
                        yaffs_FlushEntireDeviceCache(dev);
                        yaffs_CheckpointSave(dev);
-                       
+
                        for(i = inUse = 0; i < YAFFSFS_N_HANDLES && !inUse; i++)
                        {
                                if(yaffsfs_handle[i].inUse && yaffsfs_handle[i].obj->myDev == dev)
@@ -1093,11 +1093,11 @@ int yaffs_unmount(const char *path)
                                        inUse = 1; // the device is in use, can't unmount
                                }
                        }
-                       
+
                        if(!inUse)
                        {
                                yaffs_Deinitialise(dev);
-                                       
+
                                retVal = 0;
                        }
                        else
@@ -1105,23 +1105,23 @@ int yaffs_unmount(const char *path)
                                // todo error can't unmount as files are open
                                yaffsfs_SetError(-EBUSY);
                        }
-                       
+
                }
                else
                {
                        //todo error - not mounted.
                        yaffsfs_SetError(-EINVAL);
-                       
+
                }
        }
        else
        {
                // todo error - no device
                yaffsfs_SetError(-ENODEV);
-       }       
+       }
        yaffsfs_Unlock();
        return retVal;
-       
+
 }
 
 loff_t yaffs_freespace(const char *path)
@@ -1129,37 +1129,37 @@ loff_t yaffs_freespace(const char *path)
        loff_t retVal=-1;
        yaffs_Device *dev=NULL;
        char *dummy;
-       
+
        yaffsfs_Lock();
        dev = yaffsfs_FindDevice(path,&dummy);
        if(dev  && dev->isMounted)
        {
                retVal = yaffs_GetNumberOfFreeChunks(dev);
                retVal *= dev->nDataBytesPerChunk;
-               
+
        }
        else
        {
                yaffsfs_SetError(-EINVAL);
        }
-       
+
        yaffsfs_Unlock();
-       return retVal;  
+       return retVal;
 }
 
 
 
 void yaffs_initialise(yaffsfs_DeviceConfiguration *cfgList)
 {
-       
+
        yaffsfs_DeviceConfiguration *cfg;
-       
+
        yaffsfs_configurationList = cfgList;
-       
+
        yaffsfs_InitHandles();
-       
+
        cfg = yaffsfs_configurationList;
-       
+
        while(cfg && cfg->prefix && cfg->dev)
        {
                cfg->dev->isMounted = 0;
@@ -1186,7 +1186,7 @@ typedef struct
        yaffs_Object *dirObj;           /* ptr to directory being searched */
        yaffs_Object *nextReturn;       /* obj to be returned by next readddir */
        int offset;
-       struct list_head others;        
+       struct list_head others;
 } yaffsfs_DirectorySearchContext;
 
 
@@ -1199,9 +1199,9 @@ static void yaffsfs_SetDirRewound(yaffsfs_DirectorySearchContext *dsc)
        if(dsc &&
           dsc->dirObj &&
           dsc->dirObj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){
-          
+
           dsc->offset = 0;
-          
+
           if( list_empty(&dsc->dirObj->variant.directoryVariant.children)){
                dsc->nextReturn = NULL;
           } else {
@@ -1218,16 +1218,16 @@ static void yaffsfs_DirAdvance(yaffsfs_DirectorySearchContext *dsc)
        if(dsc &&
           dsc->dirObj &&
           dsc->dirObj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){
-          
+
           if( dsc->nextReturn == NULL ||
               list_empty(&dsc->dirObj->variant.directoryVariant.children)){
                dsc->nextReturn = NULL;
           } else {
                   struct list_head *next = dsc->nextReturn->siblings.next;
-   
+
                   if( next == &dsc->dirObj->variant.directoryVariant.children)
                        dsc->nextReturn = NULL; /* end of list */
-                  else 
+                  else
                        dsc->nextReturn = list_entry(next,yaffs_Object,siblings);
           }
        } else {
@@ -1240,11 +1240,11 @@ static void yaffsfs_RemoveObjectCallback(yaffs_Object *obj)
 
        struct list_head *i;
        yaffsfs_DirectorySearchContext *dsc;
-       
+
        /* if search contexts not initilised then skip */
        if(!search_contexts.next)
                return;
-               
+
        /* Iteratethrough the directory search contexts.
         * If any are the one being removed, then advance the dsc to
         * the next one to prevent a hanging ptr.
@@ -1256,7 +1256,7 @@ static void yaffsfs_RemoveObjectCallback(yaffs_Object *obj)
                                yaffsfs_DirAdvance(dsc);
                }
        }
-                               
+
 }
 
 yaffs_DIR *yaffs_opendir(const char *dirname)
@@ -1264,14 +1264,14 @@ yaffs_DIR *yaffs_opendir(const char *dirname)
        yaffs_DIR *dir = NULL;
        yaffs_Object *obj = NULL;
        yaffsfs_DirectorySearchContext *dsc = NULL;
-       
+
        yaffsfs_Lock();
-       
+
        obj = yaffsfs_FindObject(NULL,dirname,0);
-       
+
        if(obj && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
        {
-               
+
                dsc = YMALLOC(sizeof(yaffsfs_DirectorySearchContext));
                dir = (yaffs_DIR *)dsc;
                if(dsc)
@@ -1281,17 +1281,17 @@ yaffs_DIR *yaffs_opendir(const char *dirname)
                        dsc->dirObj = obj;
                        strncpy(dsc->name,dirname,NAME_MAX);
                        INIT_LIST_HEAD(&dsc->others);
-                       
+
                        if(!search_contexts.next)
                                INIT_LIST_HEAD(&search_contexts);
-                               
-                       list_add(&dsc->others,&search_contexts);        
+
+                       list_add(&dsc->others,&search_contexts);
                        yaffsfs_SetDirRewound(dsc);             }
-       
+
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return dir;
 }
 
@@ -1299,9 +1299,9 @@ struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp)
 {
        yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
        struct yaffs_dirent *retVal = NULL;
-               
+
        yaffsfs_Lock();
-       
+
        if(dsc && dsc->magic == YAFFS_MAGIC){
                yaffsfs_SetError(0);
                if(dsc->nextReturn){
@@ -1324,20 +1324,20 @@ struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp)
        {
                yaffsfs_SetError(-EBADF);
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
-       
+
 }
 
 
 void yaffs_rewinddir(yaffs_DIR *dirp)
 {
        yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
-       
+
        yaffsfs_Lock();
-       
+
        yaffsfs_SetDirRewound(dsc);
 
        yaffsfs_Unlock();
@@ -1347,7 +1347,7 @@ void yaffs_rewinddir(yaffs_DIR *dirp)
 int yaffs_closedir(yaffs_DIR *dirp)
 {
        yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
-               
+
        yaffsfs_Lock();
        dsc->magic = 0;
        list_del(&dsc->others); /* unhook from list */
@@ -1366,7 +1366,7 @@ int yaffs_symlink(const char *oldpath, const char *newpath)
        char *name;
        int retVal= -1;
        int mode = 0; // ignore for now
-       
+
        yaffsfs_Lock();
        parent = yaffsfs_FindDirectory(NULL,newpath,&name,0);
        obj = yaffs_MknodSymLink(parent,name,mode,0,0,oldpath);
@@ -1379,11 +1379,11 @@ int yaffs_symlink(const char *oldpath, const char *newpath)
                yaffsfs_SetError(-ENOSPC); // just assume no space for now
                retVal = -1;
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
-       
+
 }
 
 int yaffs_readlink(const char *path, char *buf, int bufsiz)
@@ -1391,11 +1391,11 @@ int yaffs_readlink(const char *path, char *buf, int bufsiz)
        yaffs_Object *obj = NULL;
        int retVal;
 
-               
+
        yaffsfs_Lock();
-       
+
        obj = yaffsfs_FindObject(NULL,path,0);
-       
+
        if(!obj)
        {
                yaffsfs_SetError(-ENOENT);
@@ -1424,12 +1424,12 @@ int yaffs_link(const char *oldpath, const char *newpath)
        yaffs_Object *target = NULL;
        int retVal = 0;
 
-               
+
        yaffsfs_Lock();
-       
+
        obj = yaffsfs_FindObject(NULL,oldpath,0);
        target = yaffsfs_FindObject(NULL,newpath,0);
-       
+
        if(!obj)
        {
                yaffsfs_SetError(-ENOENT);
@@ -1440,15 +1440,15 @@ int yaffs_link(const char *oldpath, const char *newpath)
                yaffsfs_SetError(-EEXIST);
                retVal = -1;
        }
-       else    
+       else
        {
                yaffs_Object *newdir = NULL;
                yaffs_Object *link = NULL;
-               
+
                char *newname;
-               
+
                newdir = yaffsfs_FindDirectory(NULL,newpath,&newname,0);
-               
+
                if(!newdir)
                {
                        yaffsfs_SetError(-ENOTDIR);
@@ -1473,7 +1473,7 @@ int yaffs_link(const char *oldpath, const char *newpath)
                }
        }
        yaffsfs_Unlock();
-       
+
        return retVal;
 }
 
@@ -1482,13 +1482,13 @@ int yaffs_mknod(const char *pathname, mode_t mode, dev_t dev);
 int yaffs_DumpDevStruct(const char *path)
 {
        char *rest;
-       
+
        yaffs_Object *obj = yaffsfs_FindRoot(path,&rest);
-       
+
        if(obj)
        {
                yaffs_Device *dev = obj->myDev;
-               
+
                printf("\n"
                           "nPageWrites.......... %d\n"
                           "nPageReads........... %d\n"
@@ -1504,7 +1504,7 @@ int yaffs_DumpDevStruct(const char *path)
                                dev->garbageCollections,
                                dev->passiveGarbageCollections
                );
-               
+
        }
        return 0;
 }
index 9afe60a1ceb044b0a5474e2de12ff397f7eabaaa..95e7a914b375c83b899e7d2f2a13ff04e2c189a8 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
@@ -47,7 +47,7 @@
 #define O_RDWR         02
 #endif
 
-#ifndef O_CREAT                
+#ifndef O_CREAT
 #define O_CREAT        0100
 #endif
 
@@ -95,7 +95,7 @@
 #define EACCESS        13
 #endif
 
-#ifndef EXDEV  
+#ifndef EXDEV
 #define EXDEV  18
 #endif
 
 #define S_IFREG                0100000
 #endif
 
-#ifndef S_IREAD 
+#ifndef S_IREAD
 #define S_IREAD                0000400
 #endif
 
@@ -202,8 +202,8 @@ int yaffs_stat(const char *path, struct yaffs_stat *buf) ;
 int yaffs_lstat(const char *path, struct yaffs_stat *buf) ;
 int yaffs_fstat(int fd, struct yaffs_stat *buf) ;
 
-int yaffs_chmod(const char *path, mode_t mode); 
-int yaffs_fchmod(int fd, mode_t mode); 
+int yaffs_chmod(const char *path, mode_t mode);
+int yaffs_fchmod(int fd, mode_t mode);
 
 int yaffs_mkdir(const char *path, mode_t mode) ;
 int yaffs_rmdir(const char *path) ;
@@ -216,10 +216,10 @@ int yaffs_closedir(yaffs_DIR *dirp) ;
 int yaffs_mount(const char *path) ;
 int yaffs_unmount(const char *path) ;
 
-int yaffs_symlink(const char *oldpath, const char *newpath); 
-int yaffs_readlink(const char *path, char *buf, int bufsiz); 
+int yaffs_symlink(const char *oldpath, const char *newpath);
+int yaffs_readlink(const char *path, char *buf, int bufsiz);
 
-int yaffs_link(const char *oldpath, const char *newpath); 
+int yaffs_link(const char *oldpath, const char *newpath);
 int yaffs_mknod(const char *pathname, mode_t mode, dev_t dev);
 
 loff_t yaffs_freespace(const char *path);
@@ -229,5 +229,3 @@ void yaffs_initialise(yaffsfs_DeviceConfiguration *configList);
 int yaffs_StartUp(void);
 
 #endif
-
-
index 0cfdfcf6baad48214d2c8ec21028ee7b6c1602c5..810837a32d9bb3285a62abbd674ad1e36f65f4e1 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
index adcc0b546856f9954db80a153254adf6f3d9902e..b5558108441c3f50c50a03509033aa7a71a63d55 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
@@ -20,7 +20,7 @@
 #ifndef __YDIRECTENV_H__
 #define __YDIRECTENV_H__
 
-// Direct interface
+/* Direct interface */
 
 #include "devextras.h"
 
@@ -90,5 +90,3 @@
 #define yaffs_strcmp(a,b) strcmp(a,b)
 
 #endif
-
-
index b316b16d702d6cd0239a584113ff42289690c039..bbab14d503d8129abfb5eddc09a0a6b39ea6e915 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  *
  * Copyright (C) 2002-2007 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
@@ -156,7 +156,7 @@ extern unsigned int yaffs_wr_attempts;
  * Tracing flags.
  * The flags masked in YAFFS_TRACE_ALWAYS are always traced.
  */
+
 #define YAFFS_TRACE_OS                 0x00000002
 #define YAFFS_TRACE_ALLOCATE           0x00000004
 #define YAFFS_TRACE_SCAN               0x00000008
index a4c4240b651e33f8fa932565b3e4abd73ca093ae..95ba84029f16ddb67e838a3881329a640b10ac66 100644 (file)
@@ -64,7 +64,7 @@
 #define CFG_IMMR               0xE0000000
 
 #if defined(CONFIG_NAND_U_BOOT) && !defined(CONFIG_NAND_SPL)
-#define CONFIG_DEFAULT_IMMR    CFG_IMMR
+#define CONFIG_DEFAULT_IMMR    CFG_IMMR
 #endif
 
 #define CFG_MEMTEST_START      0x00001000
 #define CFG_NAND_U_BOOT_OFFS  16384
 #define CFG_NAND_U_BOOT_RELOC 0x00010000
 
-#define CFG_NAND_BR_PRELIM     ( CFG_NAND_BASE \
+#define CFG_NAND_BR_PRELIM     ( CFG_NAND_BASE \
                                | (2<<BR_DECC_SHIFT)    /* Use HW ECC */ \
                                | BR_PS_8               /* Port Size = 8 bit */ \
                                | BR_MS_FCM             /* MSEL = FCM */ \
  * Environment
  */
 #if defined(CONFIG_NAND_U_BOOT)
-       #define CFG_ENV_IS_IN_NAND      1
-       #define CFG_ENV_OFFSET          (512 * 1024)
-       #define CFG_ENV_SECT_SIZE       CFG_NAND_BLOCK_SIZE
-       #define CFG_ENV_SIZE            CFG_ENV_SECT_SIZE
-       #define CFG_ENV_SIZE_REDUND     CFG_ENV_SIZE
-       #define CFG_ENV_RANGE           (CFG_ENV_SECT_SIZE * 4)
-       #define CFG_ENV_OFFSET_REDUND   (CFG_ENV_OFFSET + CFG_ENV_RANGE)
+       #define CFG_ENV_IS_IN_NAND      1
+       #define CFG_ENV_OFFSET          (512 * 1024)
+       #define CFG_ENV_SECT_SIZE       CFG_NAND_BLOCK_SIZE
+       #define CFG_ENV_SIZE            CFG_ENV_SECT_SIZE
+       #define CFG_ENV_SIZE_REDUND     CFG_ENV_SIZE
+       #define CFG_ENV_RANGE           (CFG_ENV_SECT_SIZE * 4)
+       #define CFG_ENV_OFFSET_REDUND   (CFG_ENV_OFFSET + CFG_ENV_RANGE)
 #elif !defined(CFG_RAMBOOT)
        #define CFG_ENV_IS_IN_FLASH     1
        #define CFG_ENV_ADDR            (CFG_MONITOR_BASE + CFG_MONITOR_LEN)
 
 #ifdef CONFIG_NAND_SPL
 #define CFG_HRCW_HIGH (CFG_HRCW_HIGH_BASE |\
-                       HRCWH_FROM_0XFFF00100 |\
-                       HRCWH_ROM_LOC_NAND_SP_8BIT |\
-                       HRCWH_RL_EXT_NAND)
+                      HRCWH_FROM_0XFFF00100 |\
+                      HRCWH_ROM_LOC_NAND_SP_8BIT |\
+                      HRCWH_RL_EXT_NAND)
 #else
 #define CFG_HRCW_HIGH (CFG_HRCW_HIGH_BASE |\
-                       HRCWH_FROM_0X00000100 |\
-                       HRCWH_ROM_LOC_LOCAL_16BIT |\
-                       HRCWH_RL_EXT_LEGACY)
+                      HRCWH_FROM_0X00000100 |\
+                      HRCWH_ROM_LOC_LOCAL_16BIT |\
+                      HRCWH_RL_EXT_LEGACY)
 #endif
 
 /* System IO Config */
index 9b1e2526b45ec2be45e58768f8ad3e801dc8dcd5..45220ed76f512880c066a4c84aa991e513a742f8 100644 (file)
@@ -87,5 +87,3 @@ struct INFTLMediaHeader {
 #define        INFTL_LAST      0x80000000
 
 #endif /* __MTD_INFTL_USER_H__ */
-
-
index 0ce2099d692b8427b0fbc00649d0b991ecaa88ec..410c5dd2fb4114a339ca6a9fa70a9b5bdbcc6d52 100644 (file)
@@ -35,18 +35,18 @@ struct mtd_oob_buf {
 #define MTD_NO_ERASE           0x1000  /* No erase necessary */
 #define MTD_STUPID_LOCK                0x2000  /* Always locked after reset */
 
-// Some common devices / combinations of capabilities
+/* Some common devices / combinations of capabilities */
 #define MTD_CAP_ROM            0
 #define MTD_CAP_RAM            (MTD_WRITEABLE | MTD_BIT_WRITEABLE | MTD_NO_ERASE)
 #define MTD_CAP_NORFLASH       (MTD_WRITEABLE | MTD_BIT_WRITEABLE)
 #define MTD_CAP_NANDFLASH      (MTD_WRITEABLE)
 
 /* ECC byte placement */
-#define MTD_NANDECC_OFF                0       // Switch off ECC (Not recommended)
-#define MTD_NANDECC_PLACE      1       // Use the given placement in the structure (YAFFS1 legacy mode)
-#define MTD_NANDECC_AUTOPLACE  2       // Use the default placement scheme
-#define MTD_NANDECC_PLACEONLY  3       // Use the given placement in the structure (Do not store ecc result on read)
-#define MTD_NANDECC_AUTOPL_USR 4       // Use the given autoplacement scheme rather than using the default
+#define MTD_NANDECC_OFF                0       /* Switch off ECC (Not recommended) */
+#define MTD_NANDECC_PLACE      1       /* Use the given placement in the structure (YAFFS1 legacy mode) */
+#define MTD_NANDECC_AUTOPLACE  2       /* Use the default placement scheme */
+#define MTD_NANDECC_PLACEONLY  3       /* Use the given placement in the structure (Do not store ecc result on read) */
+#define MTD_NANDECC_AUTOPL_USR 4       /* Use the given autoplacement scheme rather than using the default */
 
 /* OTP mode selection */
 #define MTD_OTP_OFF            0
@@ -56,10 +56,10 @@ struct mtd_oob_buf {
 struct mtd_info_user {
        uint8_t type;
        uint32_t flags;
-       uint32_t size;   // Total size of the MTD
+       uint32_t size;                  /* Total size of the MTD */
        uint32_t erasesize;
        uint32_t writesize;
-       uint32_t oobsize;   // Amount of OOB data per block (e.g. 16)
+       uint32_t oobsize;               /* Amount of OOB data per block (e.g. 16) */
        /* The below two fields are obsolete and broken, do not use them
         * (TODO: remove at some point) */
        uint32_t ecctype;
index 14815c219b3daac59423eac9af0e0e84fb6785d4..55d33dd11ebaa22ec0149eb4fc01985564856c33 100644 (file)
@@ -112,7 +112,7 @@ struct mtd_oob_ops {
 struct mtd_info {
        u_char type;
        u_int32_t flags;
-       u_int32_t size;  // Total size of the MTD
+       u_int32_t size;  /* Total size of the MTD */
 
        /* "Major" erase size for the device. Naïve users may take this
         * to be the only erase size available, or may use the more detailed
@@ -128,10 +128,10 @@ struct mtd_info {
         */
        u_int32_t writesize;
 
-       u_int32_t oobsize;   // Amount of OOB data per block (e.g. 16)
-       u_int32_t oobavail;  // Available OOB bytes per block
+       u_int32_t oobsize;   /* Amount of OOB data per block (e.g. 16) */
+       u_int32_t oobavail;  /* Available OOB bytes per block */
 
-       // Kernel-only stuff starts here.
+       /* Kernel-only stuff starts here. */
        char *name;
        int index;
 
index b2bca18e7311bf1670271b3cf5988b0c933278fe..22b8b707e548165b4afeb90228d2feceef697b3b 100644 (file)
@@ -32,8 +32,8 @@ struct nftl_uci1 {
 } __attribute__((packed));
 
 struct nftl_uci2 {
-        uint16_t FoldMark;
-        uint16_t FoldMark1;
+       uint16_t FoldMark;
+       uint16_t FoldMark1;
        uint32_t unused;
 } __attribute__((packed));
 
index 04963a52e5e3c7f24cd0a4b3051ff926b4f3f08c..6731a16e7dc1cbe93f8b589b010109bed2ee787e 100644 (file)
 #include <linux/mtd/nftl-user.h>
 
 /* these info are used in ReplUnitTable */
-#define BLOCK_NIL          0xffff /* last block of a chain */
-#define BLOCK_FREE         0xfffe /* free block */
+#define BLOCK_NIL         0xffff /* last block of a chain */
+#define BLOCK_FREE        0xfffe /* free block */
 #define BLOCK_NOTEXPLORED  0xfffd /* non explored block, only used during mounting */
-#define BLOCK_RESERVED     0xfffc /* bios block or bad block */
+#define BLOCK_RESERVED    0xfffc /* bios block or bad block */
 
 struct NFTLrecord {
        struct mtd_blktrans_dev mbd;
@@ -28,15 +28,15 @@ struct NFTLrecord {
        unsigned char sectors;
        unsigned short cylinders;
        __u16 numvunits;
-       __u16 lastEUN;                  /* should be suppressed */
+       __u16 lastEUN;                  /* should be suppressed */
        __u16 numfreeEUNs;
        __u16 LastFreeEUN;              /* To speed up finding a free EUN */
        int head,sect,cyl;
        __u16 *EUNtable;                /* [numvunits]: First EUN for each virtual unit  */
        __u16 *ReplUnitTable;           /* [numEUNs]: ReplUnitNumber for each */
-        unsigned int nb_blocks;                /* number of physical blocks */
-        unsigned int nb_boot_blocks;   /* number of blocks used by the bios */
-        struct erase_info instr;
+       unsigned int nb_blocks;         /* number of physical blocks */
+       unsigned int nb_boot_blocks;    /* number of blocks used by the bios */
+       struct erase_info instr;
        struct nand_ecclayout oobinfo;
 };
 
index 4c2b76dd4b33f947e69e67a838f10124f095a9f2..3296e109e77631b5a1236d6ed3918115345f1f3e 100644 (file)
@@ -109,9 +109,9 @@ struct nand_erase_options {
 typedef struct nand_erase_options nand_erase_options_t;
 
 int nand_read_skip_bad(nand_info_t *nand, size_t offset, size_t *length,
-                       u_char *buffer);
+                      u_char *buffer);
 int nand_write_skip_bad(nand_info_t *nand, size_t offset, size_t *length,
-                        u_char *buffer);
+                       u_char *buffer);
 int nand_erase_opts(nand_info_t *meminfo, const nand_erase_options_t *opts);
 
 #define NAND_LOCK_STATUS_TIGHT 0x01
index 16d128fc836182b5b552ed28a119ac80b6c8b736..0c06e53637771e8f4d980f27db7b451ec96c5bbf 100644 (file)
@@ -95,7 +95,7 @@ static int nand_command(struct mtd_info *mtd, int block, int page, int offs, u8
        /* Set ALE and clear CLE to start address cycle */
        /* Column address */
        this->cmd_ctrl(mtd, offs & 0xff,
-                      NAND_CTRL_ALE | NAND_CTRL_CHANGE); /* A[7:0] */
+                      NAND_CTRL_ALE | NAND_CTRL_CHANGE); /* A[7:0] */
        this->cmd_ctrl(mtd, (offs >> 8) & 0xff, 0); /* A[11:9] */
        /* Row address */
        this->cmd_ctrl(mtd, (page_addr & 0xff), 0); /* A[19:12] */
@@ -106,7 +106,7 @@ static int nand_command(struct mtd_info *mtd, int block, int page, int offs, u8
 #endif
        /* Latch in address */
        this->cmd_ctrl(mtd, NAND_CMD_READSTART,
-                      NAND_CTRL_CLE | NAND_CTRL_CHANGE);
+                      NAND_CTRL_CLE | NAND_CTRL_CHANGE);
        this->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
 
        /*
@@ -185,7 +185,7 @@ static int nand_read_page(struct mtd_info *mtd, int block, int page, uchar *dst)
 }
 
 static int nand_load(struct mtd_info *mtd, unsigned int offs,
-                     unsigned int uboot_size, uchar *dst)
+                    unsigned int uboot_size, uchar *dst)
 {
        unsigned int block, lastblock;
        unsigned int page;