summaryrefslogtreecommitdiff
path: root/ubi-utils
diff options
context:
space:
mode:
authorFrank Haverkamp <haver@vnet.ibm.com>2006-06-14 11:53:59 +0200
committerFrank Haverkamp <haver@vnet.ibm.com>2006-10-31 15:06:06 +0100
commitf175083413f0f94de88def865eeb65e465ded389 (patch)
treef50ded679736272988ccce2a15d17fdeac2e09a5 /ubi-utils
parent37f40f5574e04ae050507133ade8fe0e6bae2f0d (diff)
UBI - Unsorted Block Images
UBI (Latin: "where?") manages multiple logical volumes on a single flash device, specifically supporting NAND flash devices. UBI provides a flexible partitioning concept which still allows for wear-levelling across the whole flash device. In a sense, UBI may be compared to the Logical Volume Manager (LVM). Whereas LVM maps logical sector numbers to physical HDD sector numbers, UBI maps logical eraseblocks to physical eraseblocks. More information may be found in the UBI design documentation: ubidesign.pdf. Which can be found here: http://www.linux-mtd.infradead.org/doc/ubi.html Partitioning/Re-partitioning An UBI volume occupies a certain number of erase blocks. This is limited by a configured maximum volume size, which could also be viewed as the partition size. Each individual UBI volume's size can be changed independently of the other UBI volumes, provided that the sum of all volume sizes doesn't exceed a certain limit. UBI supports dynamic volumes and static volumes. Static volumes are read-only and their contents are protected by CRC check sums. Bad eraseblocks handling UBI transparently handles bad eraseblocks. When a physical eraseblock becomes bad, it is substituted by a good physical eraseblock, and the user does not even notice this. Scrubbing On a NAND flash bit flips can occur on any write operation, sometimes also on read. If bit flips persist on the device, at first they can still be corrected by ECC, but once they accumulate, correction will become impossible. Thus it is best to actively scrub the affected eraseblock, by first copying it to a free eraseblock and then erasing the original. The UBI layer performs this type of scrubbing under the covers, transparently to the UBI volume users. Erase Counts UBI maintains an erase count header per eraseblock. This frees higher-level layers (like file systems) from doing this and allows for centralized erase count management instead. The erase counts are used by the wear-levelling algorithm in the UBI layer. The algorithm itself is exchangeable. Booting from NAND For booting directly from NAND flash the hardware must at least be capable of fetching and executing a small portion of the NAND flash. Some NAND flash controllers have this kind of support. They usually limit the window to a few kilobytes in erase block 0. This "initial program loader" (IPL) must then contain sufficient logic to load and execute the next boot phase. Due to bad eraseblocks, which may be randomly scattered over the flash device, it is problematic to store the "secondary program loader" (SPL) statically. Also, due to bit-flips it may become corrupted over time. UBI allows to solve this problem gracefully by storing the SPL in a small static UBI volume. UBI volumes vs. static partitions UBI volumes are still very similar to static MTD partitions: * both consist of eraseblocks (logical eraseblocks in case of UBI volumes, and physical eraseblocks in case of static partitions; * both support three basic operations - read, write, erase. But UBI volumes have the following advantages over traditional static MTD partitions: * there are no eraseblock wear-leveling constraints in case of UBI volumes, so the user should not care about this; * there are no bit-flips and bad eraseblocks in case of UBI volumes. So, UBI volumes may be considered as flash devices with relaxed restrictions. Where can it be found? Documentation, kernel code and applications can be found in the MTD gits. What are the applications for? The applications help to create binary flash images for two purposes: pfi files (partial flash images) for in-system update of UBI volumes, and plain binary images, with or without OOB data in case of NAND, for a manufacturing step. Furthermore some tools are/and will be created that allow flash content analysis after a system has crashed. Who did UBI? The original ideas, where UBI is based on, were developed by Andreas Arnez, Frank Haverkamp and Thomas Gleixner. Josh W. Boyer and some others were involved too. The implementation of the kernel layer was done by Artem B. Bityutskiy. The user-space applications and tools were written by Oliver Lohmann with contributions from Frank Haverkamp, Andreas Arnez, and Artem. Joern Engel contributed a patch which modifies JFFS2 so that it can be run on a UBI volume. Thomas Gleixner did modifications to the NAND layer and also some to JFFS2 to make it work. Signed-off-by: Frank Haverkamp <haver@vnet.ibm.com>
Diffstat (limited to 'ubi-utils')
-rw-r--r--ubi-utils/Makefile79
-rw-r--r--ubi-utils/Makefile.am96
-rw-r--r--ubi-utils/README236
-rw-r--r--ubi-utils/UBI.TXT108
-rwxr-xr-xubi-utils/bootstrap15
-rw-r--r--ubi-utils/configure.ac52
-rw-r--r--ubi-utils/inc/Makefile.am5
-rw-r--r--ubi-utils/inc/bootenv.h415
-rw-r--r--ubi-utils/inc/config-h.in74
-rw-r--r--ubi-utils/inc/crc32.h36
-rw-r--r--ubi-utils/inc/error.h84
-rw-r--r--ubi-utils/inc/example_ubi.h28
-rw-r--r--ubi-utils/inc/libubi.h310
-rw-r--r--ubi-utils/inc/list.h56
-rw-r--r--ubi-utils/inc/nandecc.h28
-rw-r--r--ubi-utils/inc/peb.h41
-rw-r--r--ubi-utils/inc/pfi.h244
-rw-r--r--ubi-utils/inc/pfiflash.h62
-rw-r--r--ubi-utils/inc/reader.h84
-rw-r--r--ubi-utils/inc/ubigen.h149
-rw-r--r--ubi-utils/inc/ubimirror.h66
-rw-r--r--ubi-utils/lib/Makefile.am58
-rw-r--r--ubi-utils/scripts/Makefile57
-rw-r--r--ubi-utils/scripts/README11
-rw-r--r--ubi-utils/scripts/TODO5
-rwxr-xr-xubi-utils/scripts/jffs2_test.sh91
-rw-r--r--ubi-utils/scripts/test.cfg23
-rwxr-xr-xubi-utils/scripts/ubi_test.sh318
-rwxr-xr-xubi-utils/scripts/ubi_tools_test.sh244
-rw-r--r--ubi-utils/src/bin2nand/bin2nand.c343
-rw-r--r--ubi-utils/src/bin2nand/nandecc.c159
-rw-r--r--ubi-utils/src/bin2nand/nandecc.h11
-rw-r--r--ubi-utils/src/libbootenv/bootenv.c959
-rw-r--r--ubi-utils/src/libbootenv/hashmap.c412
-rw-r--r--ubi-utils/src/libbootenv/hashmap.h49
-rw-r--r--ubi-utils/src/libcrc32/crc32.c83
-rw-r--r--ubi-utils/src/liberror/error.c177
-rw-r--r--ubi-utils/src/liblist/list.c149
-rw-r--r--ubi-utils/src/libpeb/peb.c116
-rw-r--r--ubi-utils/src/libpfi/pfi.c461
-rw-r--r--ubi-utils/src/libpfiflash/pfiflash.c617
-rw-r--r--ubi-utils/src/libreader/reader.c442
-rw-r--r--ubi-utils/src/libubi/libubi.c773
-rw-r--r--ubi-utils/src/libubi/libubi_int.h119
-rw-r--r--ubi-utils/src/libubi/libubi_sysfs.c231
-rw-r--r--ubi-utils/src/libubi/libubi_sysfs.h109
-rw-r--r--ubi-utils/src/libubigen/ubigen.c486
-rw-r--r--ubi-utils/src/libubimirror/ubimirror.c217
-rw-r--r--ubi-utils/src/mkbootenv/mkbootenv.c173
-rw-r--r--ubi-utils/src/mkpfi/f128_nand_sample.cfg38
-rw-r--r--ubi-utils/src/mkpfi/f64_nor_sample.cfg39
-rwxr-xr-xubi-utils/src/mkpfi/mkpfi723
-rw-r--r--ubi-utils/src/nand2bin/nand2bin.c327
-rw-r--r--ubi-utils/src/nand2bin/nandcorr.c85
-rw-r--r--ubi-utils/src/pddcustomize/pddcustomize.c496
-rw-r--r--ubi-utils/src/pfi2bin/pfi2bin.c678
-rw-r--r--ubi-utils/src/pfiflash/pfiflash.c243
-rw-r--r--ubi-utils/src/ubicrc32/ubicrc32.c143
-rwxr-xr-xubi-utils/src/ubicrc32/ubicrc32.pl74
-rw-r--r--ubi-utils/src/ubigen/ubigen_main.c369
-rw-r--r--ubi-utils/src/ubiinfo/ubiflash.h185
-rw-r--r--ubi-utils/src/ubiinfo/ubiinfo.c406
-rw-r--r--ubi-utils/src/ubiinfo/ubiipl.h87
-rw-r--r--ubi-utils/src/ubimirror/ubimirror.c206
-rw-r--r--ubi-utils/src/ubimkvol/ubimkvol.c252
-rw-r--r--ubi-utils/src/ubirmvol/ubirmvol.c172
-rw-r--r--ubi-utils/src/ubiwritevol/ubiwritevol.c352
-rw-r--r--ubi-utils/src/unubi/unubi.c391
-rw-r--r--ubi-utils/testcases.txt9
69 files changed, 14436 insertions, 0 deletions
diff --git a/ubi-utils/Makefile b/ubi-utils/Makefile
new file mode 100644
index 0000000..686aa60
--- /dev/null
+++ b/ubi-utils/Makefile
@@ -0,0 +1,79 @@
+#
+# This makefile simplifies the build process for a toolchain user.
+# A toolchain developer should prefer a manual build process which
+# fits to his original needs.
+#
+
+X86_PREFIX?=/usr/local
+x86_path=./build_x86
+x86_status=$(x86_path)/config.status
+
+PPC_PREFIX?=/opt/ppcnf/crossroot
+ppc_path=./build_ppc
+ppc_status=$(ppc_path)/config.status
+
+all: x86 ppc
+
+install: install_x86 install_ppc
+uninstall: uninstall_x86 uninstall_ppc
+
+install_x86: x86
+ make -C $(x86_path) install
+
+install_ppc: ppc
+ make -C $(ppc_path) install
+
+
+uninstall_x86: x86
+ make -C $(x86_path) uninstall
+
+uninstall_ppc: ppc
+ make -C $(ppc_path) uninstall
+
+
+
+x86: $(x86_status)
+ make -C $(x86_path)
+
+ppc: $(ppc_status)
+ make -C $(ppc_path)
+
+$(x86_status): $(x86_path) Makefile.in
+ cd $(x86_path) && ./config.status || ../configure \
+ --prefix=$(X86_PREFIX)
+
+$(ppc_status): $(ppc_path) Makefile.in
+ cd $(ppc_path) && ./config.status || ../configure \
+ --build=i686-pc-linux-gnu \
+ --host=ppc-linux \
+ --prefix=$(PPC_PREFIX) \
+ --exec-prefix=$(PPC_PREFIX)
+
+Makefile.in: Makefile.am
+ ./bootstrap
+
+$(x86_path):
+ mkdir -p $(x86_path)
+
+$(ppc_path):
+ mkdir -p $(ppc_path)
+
+clean:
+ rm -rf depcomp install-sh missing .deps \
+ config.log config.status \
+ inc/Makefile.in lib/Makefile.in
+ find . -type f -name "*~" -print | xargs $(RM)
+ rm -f Makefile.in
+ rm -f aclocal.m4
+ rm -rf autom4te.cache
+ rm -f config.guess
+ rm -f config.sub
+ rm -f configure
+ rm -f depcomp
+ rm -f install-sh
+ rm -f ltmain.sh
+ rm -f missing
+ rm -f lib/Makefile.in
+ rm -f inc/Makefile.in
+ rm -rf $(x86_path)
+ rm -rf $(ppc_path)
diff --git a/ubi-utils/Makefile.am b/ubi-utils/Makefile.am
new file mode 100644
index 0000000..a5c9252
--- /dev/null
+++ b/ubi-utils/Makefile.am
@@ -0,0 +1,96 @@
+AUTOMAKE_OPTIONS = foreign
+SUBDIRS=lib inc
+
+
+# -----------------------------------------------------------------------------
+# Scripts (Perl/Bash) which shall be installed.
+#
+bin_SCRIPTS = $(top_srcdir)/src/mkpfi/mkpfi
+
+# -----------------------------------------------------------------------------
+# C programs which shall be build and installed.
+#
+INCLUDES=-I$(top_srcdir)/inc -I$(top_srcdir)/../../kernel/include
+
+bin_PROGRAMS = bin/pfi2bin \
+ bin/bin2nand \
+ bin/ubicrc32 \
+ bin/mkbootenv \
+ bin/ubimirror \
+ bin/ubimkvol \
+ bin/ubirmvol \
+ bin/ubiwritevol \
+ bin/pfiflash \
+ bin/pddcustomize \
+ bin/ubiinfo \
+ bin/nand2bin \
+ bin/unubi
+
+# -----------------------------------------------------------------------------
+# C programs which shall be build and NOT installed. (FLD dependency...)
+#
+noinst_PROGRAMS = bin/ubigen
+
+bin_ubigen_SOURCES = $(top_srcdir)/src/ubigen/ubigen_main.c
+bin_ubigen_LDADD = $(top_builddir)/lib/libubigen.la \
+ $(top_builddir)/lib/libcrc32.la
+
+bin_pfiflash_SOURCES = $(top_srcdir)/src/pfiflash/pfiflash.c
+bin_pfiflash_LDADD = $(top_builddir)/lib/libpfiflash.la \
+ $(top_builddir)/lib/liberror.la
+bin_pfiflash_LDFLAGS = -static
+
+bin_pddcustomize_SOURCES= $(top_srcdir)/src/pddcustomize/pddcustomize.c
+bin_pddcustomize_LDADD = $(top_builddir)/lib/libbootenv.la \
+ $(top_builddir)/lib/liberror.la \
+ $(top_builddir)/lib/libubi.la \
+ $(top_builddir)/lib/libubimirror.la
+bin_pddcustomize_LDFLAGS= -static
+
+bin_pfi2bin_SOURCES = $(top_srcdir)/src/pfi2bin/pfi2bin.c
+bin_pfi2bin_LDADD = $(top_builddir)/lib/libubigen.la \
+ $(top_builddir)/lib/liberror.la \
+ $(top_builddir)/lib/liblist.la \
+ $(top_builddir)/lib/libreader.la
+
+bin_bin2nand_SOURCES = $(top_srcdir)/src/bin2nand/bin2nand.c \
+ $(top_srcdir)/src/bin2nand/nandecc.c
+bin_bin2nand_LDADD = $(top_builddir)/lib/liberror.la
+
+
+bin_ubicrc32_SOURCES = $(top_srcdir)/src/ubicrc32/ubicrc32.c
+bin_ubicrc32_LDADD = $(top_builddir)/lib/libcrc32.la
+
+bin_mkbootenv_SOURCES = $(top_srcdir)/src/mkbootenv/mkbootenv.c
+bin_mkbootenv_LDADD = $(top_builddir)/lib/libbootenv.la \
+ $(top_builddir)/lib/liberror.la
+
+
+bin_ubimirror_SOURCES = $(top_srcdir)/src/ubimirror/ubimirror.c
+bin_ubimirror_LDADD = $(top_builddir)/lib/liberror.la \
+ $(top_builddir)/lib/libubimirror.la
+bin_ubimirror_LDFLAGS= -static
+
+bin_ubimkvol_SOURCES = $(top_srcdir)/src/ubimkvol/ubimkvol.c
+bin_ubimkvol_LDADD = $(top_builddir)/lib/libubi.la
+bin_ubimkvol_LDFLAGS = -static
+
+bin_ubirmvol_SOURCES = $(top_srcdir)/src/ubirmvol/ubirmvol.c
+bin_ubirmvol_LDADD = $(top_builddir)/lib/libubi.la
+bin_ubirmvol_LDFLAGS = -static
+
+bin_ubiwritevol_SOURCES = $(top_srcdir)/src/ubiwritevol/ubiwritevol.c
+bin_ubiwritevol_LDADD = $(top_builddir)/lib/libubi.la
+bin_ubiwritevol_LDFLAGS = -static
+
+bin_ubiinfo_SOURCES = $(top_srcdir)/src/ubiinfo/ubiinfo.c
+
+bin_nand2bin_SOURCES = $(top_srcdir)/src/nand2bin/nand2bin.c \
+ $(top_srcdir)/src/bin2nand/nandecc.c \
+ $(top_srcdir)/src/nand2bin/nandcorr.c
+
+bin_unubi_SOURCES = $(top_srcdir)/src/unubi/unubi.c
+bin_unubi_LDADD = $(top_builddir)/lib/libcrc32.la
+
+clean-local:
+ rm -rf bin/
diff --git a/ubi-utils/README b/ubi-utils/README
new file mode 100644
index 0000000..d976a76
--- /dev/null
+++ b/ubi-utils/README
@@ -0,0 +1,236 @@
+README
+======
+
+The programs and libraries in this directory provide a tool-chain to
+generate binary data for embedded systems which can be flashed either
+by a hardware flash programmer, e.g. JTAG debugger, or on the target
+system directly using pfiflash, or ubimkvol, ubirmvol, ubiwritevol.
+
+The latter is the case when there is already Linux running which has
+build in UBI support.
+
+Authors: Oliver Lohmann
+ Frank Haverkamp
+ Andreas Arnez
+
+mkpfi - tool for flash content generation in PFI
+ format
+pfi2bin - conversion tool to transfer a PFI file into a
+ binary image
+pfiflash - tool to update the embedded systems flash using
+ pfi files created by mkpfi
+libbootenv - library for boot-parameter processing
+libpfi - library for partial flash image (PFI) creation
+ and handling
+ubigen - tool to create binary UBI images e.g. for a
+ jtag flashing tool
+nandimg - tool to add OOB data to binary images intended
+ for NAND flash systems
+ubilib - UBI library
+
+!!! NOTICE !!!
+If you execute ./configure in the top_level directory the helper Makefile
+gets overwritten. Thats actually no problem, but be aware of that.
+
+1. Build Process
+
+1.1 Build, install and forget
+ o Build all and everything
+ $make all (takes a while, builds ppc and x86 binaries/libs)
+ o Installation:
+ $make install
+ o Uninstallation:
+ $make uninstall
+
+ o x86 only would be:
+ $make x86 && make install_x86
+
+1.2 Usage for a developer
+
+ 1.2.1 The build process in detail
+
+ o If you've checked out the sources from the CVS repository you'll find a
+ directory setup like this:
+
+ flashutils/
+ -rw-r--r-- 1 olli olli 1.3K Mar 14 11:53 Makefile
+ -rw-r--r-- 1 olli olli 1.9K Mar 14 10:50 Makefile.am
+ -rwxr-xr-x 1 olli olli 265 Mar 9 00:47 bootstrap
+ -rw-r--r-- 1 olli olli 1.1K Mar 9 16:55 configure.ac
+ drwxr-xr-x 2 olli olli 4.0K Mar 9 00:28 doc
+ drwxr-xr-x 2 olli olli 4.0K Mar 14 11:56 inc
+ drwxr-xr-x 2 olli olli 4.0K Mar 14 11:56 lib
+ drwxr-xr-x 17 olli olli 4.0K Mar 13 16:50 src
+
+ o To generate the initial build templates you have to call the bootstrap
+ script:
+ $ ./bootstrap
+ o Create a directory for the target platform
+ $ mkdir build_x86
+ o Descend into the directory and call the top-level configure script
+ with the desired options.
+ $ cd build_x86
+ $ ../configure --prefix=/usr/local [...]
+ o Now you'll find a directory structure like this:
+
+ flashutils/build_x86/
+ -rw-r--r-- 1 olli olli 47K Mar 14 13:33 Makefile
+ -rw-r--r-- 1 olli olli 33K Mar 14 13:33 config.log
+ -rwxr-xr-x 1 olli olli 38K Mar 14 13:33 config.status
+ drwxr-xr-x 2 olli olli 4.0K Mar 14 13:33 inc
+ drwxr-xr-x 3 olli olli 4.0K Mar 14 13:33 lib
+ -rwxr-xr-x 1 olli olli 202K Mar 14 13:33 libtool
+
+ o The config.guess script can be used to update the Makefiles in the
+ target directory after a change of the top-level template files
+ (i.e. the Makefile.in files).
+ $ ./config.guess
+ o To compile everything for this platform just invoke make in
+ flashutils/build_x86:
+ $ make
+ or from toplevel:
+ $ make -C ./build_x86
+ o The build process creates a new directory "bin":
+ flashutils/build_x86/
+ [...]
+ drwxr-xr-x 3 olli olli 4.0K Mar 14 13:41 bin
+ [...]
+
+ This directory contains all binary files which will be installed
+ by make install, e.g.:
+
+ flashutils/build_x86/bin/
+ -rwxr-xr-x 1 olli olli 7.2K Mar 14 13:41 bin2nand
+ -rwxr-xr-x 1 olli olli 15K Mar 14 13:41 mkbootenv
+ -rwxr-xr-x 1 olli olli 16K Mar 14 13:41 pddcustomize
+ -rwxr-xr-x 1 olli olli 36K Mar 14 13:41 pfi2bin
+ -rwxr-xr-x 1 olli olli 6.8K Mar 14 13:41 pfiflash
+ -rwxr-xr-x 1 olli olli 5.0K Mar 14 13:41 ubicrc32
+ -rwxr-xr-x 1 olli olli 13K Mar 14 13:41 ubigen
+ -rwxr-xr-x 1 olli olli 6.3K Mar 14 13:41 ubimirror
+
+
+ 1.2.2 Modifying and Adding Sources
+
+ o There is a dedicated directory which contains all source code
+ of the flashutils package, e.g.:
+
+ flashutils/src/
+ drwxr-xr-x 2 olli olli 4.0K Mar 13 11:42 libbootenv
+ drwxr-xr-x 2 olli olli 4.0K Mar 13 11:42 liberror
+ drwxr-xr-x 2 olli olli 4.0K Mar 13 16:48 mkpfi
+ drwxr-xr-x 2 olli olli 4.0K Mar 13 16:12 pddcustomize
+
+
+
+ The prefix "lib" is used to mark directories as part of a convenience
+ library. Binaries have no special prefix.
+
+ o How to add sources?
+
+ Just create a new directory at flashutils/src/, e.g.:
+
+ For a binary:
+ $ mkdir rider
+ $ cd rider
+ $ vi rider.c
+ /* do sth with that file... */
+
+ For a convenience library (as well as for "normal libs")
+ $ mkdir libworld
+ $ cd libworld
+ $ vi world.c
+ /* do sth with that file... */
+
+ o How to register sources in the build process (for binaries)?
+
+ You have to register your sources at the top-level automake Makefile:
+
+ In directory flashutils/
+ $ vi Makefile.am
+
+ Binaries have to be registered at "bin_PROGRAMS", e.g.:
+ bin_PROGRAMS = bin/pddcustomize \
+ bin/rider
+
+ Add the rule how the binary is assembled, e.g.:
+ bin_pddcustomize_SOURCES = \
+ $(top_srcdir)/src/pddcustomize/pddcustomize.c
+ bin_pddcustomize_LDADD = \
+ $(top_builddir)/lib/libbootenv.la \
+ $(top_builddir)/lib/liberror.la
+
+ bin_rider_SOURCES = \
+ $(top_srcdir)/src/rider/rider.c
+
+ This example reflects a simple build process for "rider". "rider"
+ is built without any other dependencies or convenience libraries.
+ The example for pddcustomize is a bit more complicated.
+ "_LDADD" adds some convenience libraris into the link process of
+ "pddcustomize". Imagine, that your "rider" has common code
+ with "dragon_bin" which is held in a library called "libworld".
+ The build rules would like like the following:
+
+ bin_rider_SOURCES = \
+ $(top_srcdir)/src/rider/rider.c
+ bin_rider_LDADD = \
+ $(top_builddir)/lib/libworld.la
+
+ bin_dragon_SOURCES = \
+ $(top_srcdir)/src/dragon_bin/dragon_bin.c
+ bin_dragon_LDADD = \
+ $(top_builddir)/lib/libworld.la
+
+ Don't forget to add "dragon" to "bin_PROGRAMS"!
+ Don't forget to set the build rule for the "libworld" itself!
+ This is documented in the next section.
+
+
+ o How to register sources in the build process (for libraries)?
+
+ Until now we didn't care about the build process of "libworld".
+ Libraries are handled special in this build process because
+ they are handled as "modules", i.e. they are able to be built
+ without building the binaries in the same step. Additionally,
+ it is possible to assemble complex libraries out of simple ones.
+ That especially makes sense if you want to export (install) a
+ library on a system which uses some common code and makes
+ some adoptions for usability and presents a comfortable interface to
+ the user (see libpfiflash in the sources for an example).
+
+ o Registering "libworld" as convenience library.
+
+ Instead of editing the "Makefile.am" in "flashtools/", we have to
+ edit now the "Makefile.am" in "flashtools/lib/":
+
+ noinst_LTLIBRARIES = libworld.la
+
+ libworld_la_SOURCES = $(top_srcdir)/src/libworld/world.c
+
+ o Registering "libworld" as library which gets installed.
+
+ lib_LTLIBRARIES = libworld.la
+ libworld_la_SOURCES = $(top_srcdir)/src/libworld/world.c
+ libworld_la_LDFLAGS = -no-undefined -version-info 0:0:0
+
+ o Header files
+
+ All header files are stored at "flashutils/inc", regardless
+ if convenience library or not.
+
+ If you want to export headers you have to specify this in the Makefile.am
+ located at "flashutils/inc", e.g. (this should not be done
+ for convenience libraries):
+
+ nobase_include_HEADERS = world.h
+
+
+
+Appendix
+
+A.1. FAQ
+
+ Q How to call configure to setup a cross-platform build?
+ A $ ./configure --build=i686-pc-linux-gnu --host=ppc-linux \
+ --prefix=/opt/.../ppcnf/crossroot/ \
+ --exec-prefix=/opt/..../ppcnf/crossroot/usr
diff --git a/ubi-utils/UBI.TXT b/ubi-utils/UBI.TXT
new file mode 100644
index 0000000..9a1c3c7
--- /dev/null
+++ b/ubi-utils/UBI.TXT
@@ -0,0 +1,108 @@
+UBI - Unsorted Block Images
+
+UBI (Latin: "where?") manages multiple logical volumes on a single
+flash device, specifically supporting NAND flash devices. UBI provides
+a flexible partitioning concept which still allows for wear-levelling
+across the whole flash device.
+
+In a sense, UBI may be compared to the Logical Volume Manager
+(LVM). Whereas LVM maps logical sector numbers to physical HDD sector
+numbers, UBI maps logical eraseblocks to physical eraseblocks.
+
+More information may be found in the UBI design documentation:
+ubidesign.pdf. Which can be found here:
+http://www.linux-mtd.infradead.org/doc/ubi.html
+
+Partitioning/Re-partitioning
+
+ An UBI volume occupies a certain number of erase blocks. This is
+ limited by a configured maximum volume size, which could also be
+ viewed as the partition size. Each individual UBI volume's size can
+ be changed independently of the other UBI volumes, provided that the
+ sum of all volume sizes doesn't exceed a certain limit.
+
+ UBI supports dynamic volumes and static volumes. Static volumes are
+ read-only and their contents are protected by CRC check sums.
+
+Bad eraseblocks handling
+
+ UBI transparently handles bad eraseblocks. When a physical
+ eraseblock becomes bad, it is substituted by a good physical
+ eraseblock, and the user does not even notice this.
+
+Scrubbing
+
+ On a NAND flash bit flips can occur on any write operation,
+ sometimes also on read. If bit flips persist on the device, at first
+ they can still be corrected by ECC, but once they accumulate,
+ correction will become impossible. Thus it is best to actively scrub
+ the affected eraseblock, by first copying it to a free eraseblock
+ and then erasing the original. The UBI layer performs this type of
+ scrubbing under the covers, transparently to the UBI volume users.
+
+Erase Counts
+
+ UBI maintains an erase count header per eraseblock. This frees
+ higher-level layers (like file systems) from doing this and allows
+ for centralized erase count management instead. The erase counts are
+ used by the wear-levelling algorithm in the UBI layer. The algorithm
+ itself is exchangeable.
+
+Booting from NAND
+
+ For booting directly from NAND flash the hardware must at least be
+ capable of fetching and executing a small portion of the NAND
+ flash. Some NAND flash controllers have this kind of support. They
+ usually limit the window to a few kilobytes in erase block 0. This
+ "initial program loader" (IPL) must then contain sufficient logic to
+ load and execute the next boot phase.
+
+ Due to bad eraseblocks, which may be randomly scattered over the
+ flash device, it is problematic to store the "secondary program
+ loader" (SPL) statically. Also, due to bit-flips it may become
+ corrupted over time. UBI allows to solve this problem gracefully by
+ storing the SPL in a small static UBI volume.
+
+UBI volumes vs. static partitions
+
+ UBI volumes are still very similar to static MTD partitions:
+
+ * both consist of eraseblocks (logical eraseblocks in case of UBI
+ volumes, and physical eraseblocks in case of static partitions;
+ * both support three basic operations - read, write, erase.
+
+ But UBI volumes have the following advantages over traditional
+ static MTD partitions:
+
+ * there are no eraseblock wear-leveling constraints in case of UBI
+ volumes, so the user should not care about this;
+ * there are no bit-flips and bad eraseblocks in case of UBI volumes.
+
+ So, UBI volumes may be considered as flash devices with relaxed
+ restrictions.
+
+Where can it be found?
+
+ Documentation, kernel code and applications can be found in the MTD
+ gits.
+
+What are the applications for?
+
+ The applications help to create binary flash images for two
+ purposes: pfi files (partial flash images) for in-system update of
+ UBI volumes, and plain binary images, with or without OOB data in
+ case of NAND, for a manufacturing step. Furthermore some tools
+ are/and will be created that allow flash content analysis after a
+ system has crashed.
+
+Who did UBI?
+
+ The original ideas, where UBI is based on, were developed by Andreas
+ Arnez, Frank Haverkamp and Thomas Gleixner. Josh W. Boyer and
+ some others were involved too. The implementation of the kernel
+ layer was done by Artem B. Bityutskiy. The user-space applications
+ and tools were written by Oliver Lohmann with contributions from
+ Frank Haverkamp, Andreas Arnez, and Artem. Joern Engel contributed a
+ patch which modifies JFFS2 so that it can be run on a UBI
+ volume. Thomas Gleixner did modifications to the NAND layer and also
+ some to JFFS2 to make it work.
diff --git a/ubi-utils/bootstrap b/ubi-utils/bootstrap
new file mode 100755
index 0000000..f543912
--- /dev/null
+++ b/ubi-utils/bootstrap
@@ -0,0 +1,15 @@
+#!/bin/bash
+LIBTOOLM4="/usr/local/share/libtool/libltdl"
+
+if test -d "$LIBTOOLM4"; then
+ echo "+ aclocal ${LIBTOOLM4}"
+ aclocal -I ${LIBTOOLM4}
+else
+ echo "+ aclocal"
+ aclocal
+fi
+set -x
+libtoolize --force
+autoheader
+automake --foreign --add-missing --copy
+autoconf
diff --git a/ubi-utils/configure.ac b/ubi-utils/configure.ac
new file mode 100644
index 0000000..9f45176
--- /dev/null
+++ b/ubi-utils/configure.ac
@@ -0,0 +1,52 @@
+# Don't remove this check.
+AC_PREREQ(2.59)
+
+# AC_INIT: Package, Version, Bugs
+AC_INIT([flashutils],[0.1],[arnez@de.ibm.com])
+AC_CONFIG_HEADERS([inc/config.h:inc/config-h.in])
+AC_CANONICAL_SYSTEM
+AM_INIT_AUTOMAKE([1.8 foreign])
+AM_MAINTAINER_MODE
+
+# Check debug options
+AS_HELP_STRING
+AC_ARG_ENABLE([debug],
+ AS_HELP_STRING([--enable-debug],
+ [build with debug information [default=yes]]),,enable_debug="yes")
+
+# Check for programs.
+AM_PROG_LIBTOOL
+AC_PROG_CC
+AC_PROG_INSTALL
+AC_PROG_MAKE_SET
+
+# Checks for header files.
+AC_HEADER_STDC
+# FIXME: Use AC_CHECK_HEADERS for UBI stuff.
+# AC_CHECK_HEADERS([errno.h mtd/ubi-user.h])
+AC_CHECK_HEADERS([errno.h])
+
+# Set build flags
+if test "x$enable_debug" = "xyes"; then
+ CFLAGS="$CFLAGS -g -DDEBUG "
+fi
+
+AC_DEFINE_UNQUOTED(HOST_OS, "${host}", [Host OS])
+AC_DEFINE_UNQUOTED(HOST_CPU, "${host_os}", [Host CPU])
+AC_DEFINE_UNQUOTED(BUILD_OS, "${build_os}", [Build OS])
+AC_DEFINE_UNQUOTED(BUILD_CPU, "${build_cpu}", [Build CPU])
+
+# Additional Config
+AC_C_BIGENDIAN
+
+# CFLAGS
+CFLAGS="-std=gnu99 -Wundef -Wall $CFLAGS"
+
+# Init output.
+AC_CONFIG_FILES([
+ Makefile
+ lib/Makefile
+ inc/Makefile
+])
+
+AC_OUTPUT
diff --git a/ubi-utils/inc/Makefile.am b/ubi-utils/inc/Makefile.am
new file mode 100644
index 0000000..ca22c37
--- /dev/null
+++ b/ubi-utils/inc/Makefile.am
@@ -0,0 +1,5 @@
+AUTOMAKE_OPTIONS = foreign
+
+# You can export headers if necessary:
+nobase_include_HEADERS = pfiflash.h \
+ libubi.h
diff --git a/ubi-utils/inc/bootenv.h b/ubi-utils/inc/bootenv.h
new file mode 100644
index 0000000..86743ed
--- /dev/null
+++ b/ubi-utils/inc/bootenv.h
@@ -0,0 +1,415 @@
+#ifndef __BOOTENV_H__
+#define __BOOTENV_H__
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <stdio.h> /* FILE */
+#include <stdint.h>
+#include <pfiflash.h>
+
+/* DOXYGEN DOCUMENTATION */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file bootenv.h
+ * @author oliloh@de.ibm.com
+ * @version 1.3
+ *
+ * 1.3 Some renaming
+ */
+
+/**
+ * @mainpage Usage
+ *
+ * @section intro Introduction
+ * This library provides all functionality to handle with the so-called
+ * platform description data (PDD) and the bootparameters defined in
+ * U-Boot. It is able to apply the defined PDD operations in PDD update
+ * scenarios. For more information about the PDD and bootparameter
+ * environment "bootenv" confer the PDD documentation.
+ *
+ * @section ret Return codes
+ * This library defines some return codes which will be delivered classified
+ * as warnings or errors. See the "Defines" section for details and numeric
+ * values.
+ *
+ * @section benv Bootenv format description
+ * There are two different input formats:
+ * - text files
+ * - binary files
+ *
+ * @subsection txt Text Files
+ * Text files have to be specified like:
+ * @verbatim key1=value1,value2,value7\n key2=value55,value1\n key4=value1\n@endverbatim
+ *
+ * @subsection bin Binary files
+ * Binary files have to be specified like:
+ * @verbatim<CRC32-bit>key1=value1,value2,value7\0key2=value55,value1\0... @endverbatim
+ * You can confer the U-Boot documentation for more details.
+ *
+ * @section benvlists Bootenv lists format description.
+ * Values referenced in the preceeding subsection can be
+ * defined like lists:
+ * @verbatim value1,value2,value3 @endverbatim
+ * There are some situation where a conversion of a comma
+ * seperated list can be useful, e.g. to get a list
+ * of defined PDD entries.
+ */
+
+#define BOOTENV_MAXSIZE (1024 * 100) /* max 100kiB space for bootenv */
+
+/**
+ * @def BOOTENV_ECRC
+ * @brief Given binary file is to large.
+ * @def BOOTENV_EFMT
+ * @brief Given bootenv section has an invalid format
+ * @def BOOTENV_EBADENTRY
+ * @brief Bad entry in the bootenv section.
+ * @def BOOTENV_EINVAL
+ * @brief Invalid bootenv defintion.
+ * @def BOOTENV_ENOPDD
+ * @brief Given bootenv sectoin has no PDD defintion string (pdd=...).
+ * @def BOOTENV_EPDDINVAL
+ * @brief Given bootenv section has an invalid PDD defintion.
+ * @def BOOTENV_ENOTIMPL
+ * @brief Functionality not implemented.
+ * @def BOOTENV_ECOPY
+ * @brief Bootenv memory copy error
+ * @def BOOTENV_ENOTFOUND
+ * @brief Given key has has no value.
+ * @def BOOTENV_EMAX
+ * @brief Highest error value.
+ */
+#define BOOTENV_ETOOBIG 1
+#define BOOTENV_EFMT 2
+#define BOOTENV_EBADENTRY 3
+#define BOOTENV_EINVAL 4
+#define BOOTENV_ENOPDD 5
+#define BOOTENV_EPDDINVAL 6
+#define BOOTENV_ENOTIMPL 7
+#define BOOTENV_ECOPY 8
+#define BOOTENV_ENOTFOUND 9
+#define BOOTENV_EMAX 10
+
+/**
+ * @def BOOTENV_W
+ * @brief A warning which is handled internally as an error
+ * but can be recovered by manual effort.
+ * @def BOOTENV_WPDD_STRING_DIFFERS
+ * @brief The PDD strings of old and new PDD differ and
+ * can cause update problems, because new PDD values
+ * are removed from the bootenv section completely.
+ */
+#define BOOTENV_W 20
+#define BOOTENV_WPDD_STRING_DIFFERS 21
+#define BOOTENV_WMAX 22 /* highest warning value */
+
+
+typedef struct bootenv *bootenv_t;
+ /**< A bootenv library handle. */
+
+typedef struct bootenv_list *bootenv_list_t;
+ /**< A handle for a value list. */
+
+typedef int(*pdd_func_t)(bootenv_t, bootenv_t, bootenv_t*,
+ int*, char*, size_t);
+
+
+/**
+ * @brief Get a new handle.
+ * @return 0
+ * @return or error
+ * */
+int bootenv_create(bootenv_t *env);
+
+/**
+ * @brief Cleanup structure.
+ * @param env Bootenv structure which shall be destroyed.
+ * @return 0
+ * @return or error
+ */
+int bootenv_destroy(bootenv_t *env);
+
+/**
+ * @brief Copy a bootenv handle.
+ * @param in The input bootenv.
+ * @param out The copied output bootenv. Discards old data.
+ * @return 0
+ * @return or error
+ */
+int bootenv_copy_bootenv(bootenv_t in, bootenv_t *out);
+
+/**
+ * @brief Looks for a value inside the bootenv data.
+ * @param env Handle to a bootenv structure.
+ * @param key The key.
+ * @return NULL key not found
+ * @return !NULL ptr to value
+ */
+int bootenv_get(bootenv_t env, const char *key, const char **value);
+
+
+/**
+ * @brief Looks for a value inside the bootenv data and converts it to num.
+ * @param env Handle to a bootenv structure.
+ * @param key The key.
+ * @param value A pointer to the resulting numerical value
+ * @return NULL key not found
+ * @return !NULL ptr to value
+ */
+int bootenv_get_num(bootenv_t env, const char *key, uint32_t *value);
+
+/**
+ * @brief Set a bootenv value by key.
+ * @param env Handle to a bootenv structure.
+ * @param key Key.
+ * @param value Value to set.
+ * @return 0
+ * @return or error
+ */
+int bootenv_set(bootenv_t env, const char *key, const char *value);
+
+/**
+ * @brief Remove the given key (and its value) from a bootenv structure.
+ * @param env Handle to a bootenv structure.
+ * @param key Key.
+ * @return 0
+ * @return or error
+ */
+int bootenv_unset(bootenv_t env, const char *key);
+
+
+/**
+ * @brief Get a vector of all keys which are currently set
+ * within a bootenv handle.
+ * @param env Handle to a bootenv structure.
+ * @param size The size of the allocated array structure.
+ * @param sort Flag, if set the vector is sorted ascending.
+ * @return NULL on error.
+ * @return !NULL a pointer to the first element the allocated vector.
+ * @warning Free the allocate memory yourself!
+ */
+int bootenv_get_key_vector(bootenv_t env, size_t *size, int sort,
+ const char ***vector);
+
+/**
+ * @brief Calculate the size in bytes which are necessary to write the
+ * current bootenv section in a *binary file.
+ * @param env bootenv handle.
+ * @param size The size in bytes of the bootenv handle.
+ * @return 0
+ * @return or ERROR.
+ */
+int bootenv_size(bootenv_t env, size_t *size);
+
+/**
+ * @brief Read a binary bootenv file.
+ * @param fp File pointer to input stream.
+ * @param env bootenv handle.
+ * @param size maximum data size.
+ * @return 0
+ * @return or ERROR.
+ */
+int bootenv_read(FILE* fp, bootenv_t env, size_t size);
+
+
+/**
+ * @brief Read bootenv data from an text/ascii file.
+ * @param fp File pointer to ascii PDD file.
+ * @param env bootenv handle
+ * @return 0
+ * @return or ERROR.
+ */
+int bootenv_read_txt(FILE* fp, bootenv_t env);
+
+/**
+ * @brief Write a bootenv structure to the given location (binary).
+ * @param fp Filepointer to binary file.
+ * @param env Bootenv structure which shall be written.
+ * @return 0
+ * @return or error
+ */
+int bootenv_write(FILE* fp, bootenv_t env);
+
+/**
+ * @brief Write a bootenv structure to the given location (text).
+ * @param fp Filepointer to text file.
+ * @param env Bootenv structure which shall be written.
+ * @return 0
+ * @return or error
+ */
+int bootenv_write_txt(FILE* fp, bootenv_t env);
+
+/**
+ * @brief Prototype for a PDD handling funtion
+ */
+
+/**
+ * @brief The PDD keep operation.
+ * @param env_old The old bootenv structure.
+ * @param env_new The new bootenv structure.
+ * @param env_res The result of PDD keep.
+ * @param warnings A flag which marks any warnings.
+ * @return 0
+ * @return or error
+ * @note For a complete documentation about the algorithm confer the
+ * PDD documentation.
+ */
+int bootenv_pdd_keep(bootenv_t env_old, bootenv_t env_new,
+ bootenv_t *env_res, int *warnings,
+ char *err_buf, size_t err_buf_size);
+
+
+/**
+ * @brief The PDD merge operation.
+ * @param env_old The old bootenv structure.
+ * @param env_new The new bootenv structure.
+ * @param env_res The result of merge-pdd.
+ * @param warnings A flag which marks any warnings.
+ * @return 0
+ * @return or error
+ * @note For a complete documentation about the algorithm confer the
+ * PDD documentation.
+ */
+int bootenv_pdd_merge(bootenv_t env_old, bootenv_t env_new,
+ bootenv_t *env_res, int *warnings,
+ char *err_buf, size_t err_buf_size);
+
+/**
+ * @brief The PDD overwrite operation.
+ * @param env_old The old bootenv structure.
+ * @param env_new The new bootenv structure.
+ * @param env_res The result of overwrite-pdd.
+ * @param warnings A flag which marks any warnings.
+ * @return 0
+ * @return or error
+ * @note For a complete documentation about the algorithm confer the
+ * PDD documentation.
+ */
+int bootenv_pdd_overwrite(bootenv_t env_new,
+ bootenv_t env_old, bootenv_t *env_res, int *warnings,
+ char *err_buf, size_t err_buf_size);
+
+/**
+ * @brief Dump a bootenv structure to stdout. (Debug)
+ * @param env Handle to a bootenv structure.
+ * @return 0
+ * @return or error
+ */
+int bootenv_dump(bootenv_t env);
+
+/**
+ * @brief Validate a bootenv structure.
+ * @param env Handle to a bootenv structure.
+ * @return 0
+ * @return or error
+ */
+int bootenv_valid(bootenv_t env);
+
+/**
+ * @brief Create a new bootenv list structure.
+ * @return NULL on error
+ * @return or a new list handle.
+ * @note This structure is used to store values in a list.
+ * A useful addition when handling PDD strings.
+ */
+int bootenv_list_create(bootenv_list_t *list);
+
+/**
+ * @brief Destroy a bootenv list structure
+ * @param list Handle to a bootenv list structure.
+ * @return 0
+ * @return or error
+ */
+int bootenv_list_destroy(bootenv_list_t *list);
+
+/**
+ * @brief Import a list from a comma seperated string
+ * @param list Handle to a bootenv list structure.
+ * @param str Comma seperated string list.
+ * @return 0
+ * @return or error
+ */
+int bootenv_list_import(bootenv_list_t list, const char *str);
+
+/**
+ * @brief Export a list to a string of comma seperated values.
+ * @param list Handle to a bootenv list structure.
+ * @return NULL one error
+ * @return or pointer to a newly allocated string.
+ * @warning Free the allocated memory by yourself!
+ */
+int bootenv_list_export(bootenv_list_t list, char **string);
+
+/**
+ * @brief Add an item to the list.
+ * @param list A handle of a list structure.
+ * @param item An item.
+ * @return 0
+ * @return or error
+ */
+int bootenv_list_add(bootenv_list_t list, const char *item);
+
+/**
+ * @brief Remove an item from the list.
+ * @param list A handle of a list structure.
+ * @param item An item.
+ * @return 0
+ * @return or error
+ */
+int bootenv_list_remove(bootenv_list_t list, const char *item);
+
+/**
+ * @brief Check if a given item is in a given list.
+ * @param list A handle of a list structure.
+ * @param item An item.
+ * @return 1 Item is in list.
+ * @return 0 Item is not in list.
+ */
+int bootenv_list_is_in(bootenv_list_t list, const char *item);
+
+
+/**
+ * @brief Convert a list into a vector of all values inside the list.
+ * @param list Handle to a bootenv structure.
+ * @param size The size of the allocated vector structure.
+ * @return 0
+ * @return or error
+ * @warning Free the allocate memory yourself!
+ */
+int bootenv_list_to_vector(bootenv_list_t list, size_t *size,
+ const char ***vector);
+
+/**
+ * @brief Convert a list into a vector of all values inside the list.
+ * @param list Handle to a bootenv structure.
+ * @param size The size of the allocated vector structure.
+ * @return 0
+ * @return or error
+ * @warning Free the allocate memory yourself!
+ */
+int bootenv_list_to_num_vector(bootenv_list_t list, size_t *size,
+ uint32_t **vector);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /*__BOOTENV_H__ */
diff --git a/ubi-utils/inc/config-h.in b/ubi-utils/inc/config-h.in
new file mode 100644
index 0000000..ce4998b
--- /dev/null
+++ b/ubi-utils/inc/config-h.in
@@ -0,0 +1,74 @@
+/* inc/config-h.in. Generated from configure.ac by autoheader. */
+
+/* Build CPU */
+#undef BUILD_CPU
+
+/* Build OS */
+#undef BUILD_OS
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#undef HAVE_DLFCN_H
+
+/* Define to 1 if you have the <errno.h> header file. */
+#undef HAVE_ERRNO_H
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#undef HAVE_INTTYPES_H
+
+/* Define to 1 if you have the <memory.h> header file. */
+#undef HAVE_MEMORY_H
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#undef HAVE_STDINT_H
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#undef HAVE_STDLIB_H
+
+/* Define to 1 if you have the <strings.h> header file. */
+#undef HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#undef HAVE_STRING_H
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#undef HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#undef HAVE_SYS_TYPES_H
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#undef HAVE_UNISTD_H
+
+/* Host CPU */
+#undef HOST_CPU
+
+/* Host OS */
+#undef HOST_OS
+
+/* Name of package */
+#undef PACKAGE
+
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* Define to 1 if you have the ANSI C header files. */
+#undef STDC_HEADERS
+
+/* Version number of package */
+#undef VERSION
+
+/* Define to 1 if your processor stores words with the most significant byte
+ first (like Motorola and SPARC, unlike Intel and VAX). */
+#undef WORDS_BIGENDIAN
diff --git a/ubi-utils/inc/crc32.h b/ubi-utils/inc/crc32.h
new file mode 100644
index 0000000..31362b0
--- /dev/null
+++ b/ubi-utils/inc/crc32.h
@@ -0,0 +1,36 @@
+#ifndef __CRC32_H__
+#define __CRC32_H__
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * Author: Thomas Gleixner
+ *
+ * CRC32 functions
+ *
+ * Can be compiled as seperate object, but is included into the ipl source
+ * so gcc can inline the functions. We optimize for size so the omission of
+ * the function frame is helpful.
+ *
+ */
+#include <stdint.h>
+
+void init_crc32_table(uint32_t *table);
+uint32_t clc_crc32(uint32_t *table, uint32_t crc, void *buf, int len);
+
+#endif /* __CRC32_H__ */
diff --git a/ubi-utils/inc/error.h b/ubi-utils/inc/error.h
new file mode 100644
index 0000000..25a1cee
--- /dev/null
+++ b/ubi-utils/inc/error.h
@@ -0,0 +1,84 @@
+#ifndef __ERROR_H__
+#define __ERROR_H__
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <stdio.h>
+
+void error_initlog(const char *logfile);
+int read_procfile(FILE *fp_out, const char *procfile);
+
+void __err_ret(const char *fmt, ...);
+void __err_sys(const char *fmt, ...);
+void __err_msg(const char *fmt, ...);
+void __err_quit(const char *fmt, ...);
+void __err_dump(const char *fmt, ...);
+
+void info_msg(const char *fmt, ...);
+
+#ifdef DEBUG
+#define __loc_msg(str) do { \
+ __err_msg("[%s. FILE: %s FUNC: %s LINE: %d]\n", \
+ str, __FILE__, __FUNCTION__, __LINE__); \
+} while (0)
+#elif
+#define __loc_msg(str)
+#endif
+
+
+#define err_dump(fmt, ...) do { \
+ __loc_msg("ErrDump"); \
+ __err_dump(fmt, ##__VA_ARGS__); \
+} while (0)
+
+#define err_quit(fmt, ...) do { \
+ __loc_msg("ErrQuit"); \
+ __err_quit(fmt, ##__VA_ARGS__); \
+} while (0)
+
+
+#define err_ret(fmt, ...) do { \
+ __loc_msg("ErrRet"); \
+ __err_ret(fmt, ##__VA_ARGS__); \
+} while (0)
+
+#define err_sys(fmt, ...) do { \
+ __loc_msg("ErrSys"); \
+ __err_sys(fmt, ##__VA_ARGS__); \
+} while (0)
+
+#define err_msg(fmt, ...) do { \
+ __loc_msg("ErrMsg"); \
+ __err_msg(fmt, ##__VA_ARGS__); \
+} while (0)
+
+#define log_msg(fmt, ...) do { \
+ /* __loc_msg("LogMsg"); */ \
+ __err_msg(fmt, ##__VA_ARGS__); \
+} while (0)
+
+#ifdef DEBUG
+#define dbg_msg(fmt, ...) do { \
+ __loc_msg("DbgMsg"); \
+ __err_msg(fmt, ##__VA_ARGS__); \
+} while (0)
+#elif
+#define dbg_msg(fmt, ...)
+#endif
+
+#endif /* __ERROR_H__ */
diff --git a/ubi-utils/inc/example_ubi.h b/ubi-utils/inc/example_ubi.h
new file mode 100644
index 0000000..23c7b54
--- /dev/null
+++ b/ubi-utils/inc/example_ubi.h
@@ -0,0 +1,28 @@
+#ifndef __EXAMPLE_UBI_H__
+#define __EXAMPLE_UBI_H__
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/**
+ * Defaults for our cards.
+ */
+#define EXAMPLE_UBI_DEVICE 0
+#define EXAMPLE_BOOTENV_VOL_ID_1 4
+#define EXAMPLE_BOOTENV_VOL_ID_2 5
+
+#endif /* __EXAMPLE_UBI_H__ */
diff --git a/ubi-utils/inc/libubi.h b/ubi-utils/inc/libubi.h
new file mode 100644
index 0000000..f13d812
--- /dev/null
+++ b/ubi-utils/inc/libubi.h
@@ -0,0 +1,310 @@
+#ifndef __UBI_H__
+#define __UBI_H__
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * UBI (Unsorted Block Images) library.
+ * @file libubi.h
+ * @author Artem B. Bityutskiy
+ * @author Additions: Oliver Lohmann
+ * @version 1.0
+ */
+
+#include <stdint.h>
+#include <mtd/ubi-user.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @section eh Error Handling
+ * The following error indication policy is used: in case of success, all
+ * library functions return 0, in case of failure they either return UBI error
+ * codes, or -1 if a system error occured; in the latter case the exact error
+ * code has to be in the errno variable.
+ *
+ * @def UBI_ENOTFOUND
+ * @brief UBI was not found in the system.
+ * @def UBI_EBUG
+ * @brief An error due to bug in kernel part of UBI in UBI library.
+ * @def UBI_EINVAL
+ * @brief Invalid argument.
+ * @def UBI_EMACS
+ * @brief Highest error value.
+ */
+#define UBI_ENOTFOUND 1
+#define UBI_EBUG 2
+#define UBI_EINVAL 3
+#define UBI_EMAX 4
+
+
+/**
+ * UBI library descriptor, vague for library users.
+ */
+typedef struct ubi_lib *ubi_lib_t;
+
+/**
+ * struct ubi_info - general information about UBI.
+ *
+ * @version UBI version
+ * @nlen_max maximum length of names of volumes
+ * @dev_count count UBI devices in the system
+ */
+struct ubi_info
+{
+ unsigned int version;
+ unsigned int nlen_max;
+ unsigned int dev_count;
+};
+
+/**
+ * struct ubi_dev_info - information about an UBI device
+ *
+ * @wear average number of erasures of flash erasable blocks
+ * @major major number of the corresponding character device
+ * @minor minor number of the corresponding character device
+ * @eb_size size of eraseblocks
+ * @total_ebs total count of eraseblocks
+ * @avail_ebs count of unused eraseblock available for new volumes
+ * @vol_count total count of volumes in this UBI device
+ */
+struct ubi_dev_info
+{
+ unsigned long long wear;
+ unsigned int major;
+ unsigned int minor;
+ unsigned int eb_size;
+ unsigned int total_ebs;
+ unsigned int avail_ebs;
+ unsigned int vol_count;
+};
+
+/**
+ * struct ubi_vol_info - information about an UBI volume
+ *
+ * @bytes volume size in bytes
+ * @eraseblocks volume size in eraseblocks
+ * @major major number of the corresponding character device
+ * @minor minor number of the corresponding character device
+ * @type volume type (%UBI_DYNAMIC_VOLUME or %UBI_STATIC_VOLUME)
+ * @dev_path device path to volume
+ * @name volume name
+ */
+struct ubi_vol_info
+{
+ unsigned long long bytes;
+ unsigned int eraseblocks;
+ unsigned int major;
+ unsigned int minor;
+ int type;
+ char *dev_path;
+ char *name;
+};
+
+/**
+ * ubi_mkvol - create a dynamic UBI volume.
+ *
+ * @desc UBI library descriptor
+ * @devn Number of UBI device to create new volume on
+ * @vol_id volume ID to assign to the new volume
+ * @vol_type volume type (%UBI_DYNAMIC_VOLUME or %UBI_STATIC_VOLUME)
+ * @bytes volume size in bytes
+ * @alignment volume alignment
+ * @name volume name
+ *
+ * This function creates new UBI volume. If @vol_id is %UBI_VOLN_AUTO, then
+ * volume number is assigned automatically. This function returns positive
+ * volume number of the new volume in case of success or %-1 in case of
+ * failure.
+ */
+int ubi_mkvol(ubi_lib_t desc, int devn, int vol_id, int vol_type,
+ long long bytes, int alignment, const char *name);
+
+/**
+ * ubi_rmvol - remove a volume.
+ *
+ * @desc UBI library descriptor
+ * @devn Number of UBI device to remove volume from
+ * @vol_id volume ID to remove
+ *
+ * This function returns zero in case of success or %-1 in case of failure.
+ */
+int ubi_rmvol(ubi_lib_t desc, int devn, int vol_id);
+
+/**
+ * ubi_get_info - get UBI information.
+ *
+ * @desc UBI library descriptor
+ * @ubi UBI information is returned here
+ *
+ * This function retrieves information about UBI and puts it to @ubi. Returns
+ * zero in case of success and %-1 in case of failure.
+ */
+int ubi_get_info(ubi_lib_t desc, struct ubi_info *ubi);
+
+/**
+ * ubi_vol_open - open a UBI volume
+ *
+ * @desc UBI library descriptor
+ * @devn Number of UBI device on which to open the volume
+ * @vol_id Number of UBI device on which to open the volume
+ * @flags Flags to pass to open()
+ *
+ * This function opens a UBI volume on a given UBI device. It returns
+ * the file descriptor of the opened volume device. In case of an
+ * error %-1 is returned and errno is set appropriately.
+ */
+int ubi_vol_open(ubi_lib_t desc, int devn, int vol_id, int flags);
+
+/**
+ * ubi_vol_close - close a UBI volume
+ *
+ * @vol_fd file descriptor of UBI volume to close
+ *
+ * This function closes the given UBI device.
+ */
+int ubi_vol_close(int vol_fd);
+
+/**
+ * ubi_vol_update - initiate volume update on a UBI volume
+ * @vol_fd File descriptor of UBI volume to update
+ * @bytes No. of bytes which shall be written.
+ *
+ * Initiates a volume update on a given volume. The caller must then
+ * actually write the appropriate number of bytes to the volume by
+ * calling write(). Returns 0 on success, else error.
+ */
+int ubi_vol_update(int vol_fd, unsigned long long bytes);
+
+/**
+ * ubi_vol_fopen_read - open a volume for reading, returning a FILE *
+ * @desc UBI library descriptor
+ * @devn UBI device number
+ * @vol_id volume ID to read
+ *
+ * Opens a volume for reading. Reading itself can then be performed
+ * with fread(). The stream can be closed with fclose(). Returns a
+ * stream on success, else NULL.
+ */
+FILE *
+ubi_vol_fopen_read(ubi_lib_t desc, int devn, uint32_t vol_id);
+
+/**
+ * ubi_vol_fopen_update - open a volume for writing, returning a FILE *
+ * @desc UBI library descriptor
+ * @devn UBI device number
+ * @vol_id volume ID to update
+ * @bytes No. of bytes which shall be written.
+ *
+ * Initiates a volume update on a given volume. The caller must then
+ * actually write the appropriate number of bytes to the volume by
+ * calling fwrite(). The file can be closed with fclose(). Returns a
+ * stream on success, else NULL.
+ */
+FILE *
+ubi_vol_fopen_update(ubi_lib_t desc, int devn, uint32_t vol_id,
+ unsigned long long bytes);
+
+/**
+ * ubi_vol_get_used_bytes - determine used bytes in a UBI volume
+ * @vol_fd File descriptor of UBI volume
+ * @bytes Pointer to result
+ *
+ * Returns 0 on success, else error.
+ */
+int ubi_vol_get_used_bytes(int vol_fd, unsigned long long *bytes);
+
+/**
+ * ubi_open - open UBI library.
+ *
+ * @desc A pointer to an UBI library descriptor
+ *
+ * Returns zero in case of success.
+ */
+int ubi_open(ubi_lib_t *desc);
+
+/**
+ * ubi_close - close UBI library.
+ *
+ * @desc A pointer to an UBI library descriptor
+ */
+int ubi_close(ubi_lib_t *desc);
+
+
+/**
+ * ubi_perror - print UBI error.
+ *
+ * @prefix a prefix string to prepend to the error message
+ * @code error code
+ *
+ * If @code is %-1, this function calls 'perror()'
+ */
+void ubi_perror(const char *prefix, int code);
+
+/**
+ * ubi_set_cdev_pattern - set 'sprintf()'-like pattern of paths to UBI
+ * character devices.
+ *
+ * @desc UBI library descriptor
+ * @pattern the pattern to set
+ *
+ * The default UBI character device path is "/dev/ubi%u".
+ */
+int ubi_set_cdev_pattern(ubi_lib_t desc, const char *pattern);
+
+/**
+ * ubi_get_dev_info get information about an UBI device.
+ *
+ * @desc UBI library descriptor
+ * @devn UBI device number
+ * @di the requested information is returned here
+ */
+int ubi_get_dev_info(ubi_lib_t desc, unsigned int devn,
+ struct ubi_dev_info *di);
+
+/**
+ * ubi_set_vol_cdev_pattern - set 'sprintf()'-like pattµern ofpaths to UBI
+ * volume character devices.
+ *
+ * @desc UBI library descriptor
+ * @pattern the pattern to set
+ *
+ * The default UBI character device path is "/dev/ubi%u_%u".
+ */
+int ubi_set_vol_cdev_pattern(ubi_lib_t desc, const char *pattern);
+
+/**
+ * ubi_get_vol_info - get information about an UBI volume
+ *
+ * @desc UBI library descriptor
+ * @devn UBI device number the volume belongs to
+ * @vol_id the requested volume number
+ * @vi volume information is returned here
+ *
+ * Users must free the volume name string @vi->name.
+ */
+int ubi_get_vol_info(ubi_lib_t desc, unsigned int devn, unsigned int vol_id,
+ struct ubi_vol_info *vi);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !__UBI_H__ */
diff --git a/ubi-utils/inc/list.h b/ubi-utils/inc/list.h
new file mode 100644
index 0000000..e8452a2
--- /dev/null
+++ b/ubi-utils/inc/list.h
@@ -0,0 +1,56 @@
+#ifndef __LIST_H__
+#define __LIST_H__
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Oliver Lohmann
+ */
+
+#include <stdint.h>
+
+#define foreach(elem, ptr, list) \
+ for (elem = list != NULL ? (typeof(elem)) head(list) \
+ : NULL, ptr = list; \
+ ptr != NULL; \
+ ptr = tail(ptr), \
+ elem = (typeof(elem)) ptr ? head(ptr) : NULL)
+
+typedef struct node* list_t;
+typedef void* info_t;
+typedef int (*free_func_t)(info_t*);
+typedef int (*cmp_func_t)(info_t, info_t);
+typedef void (*process_func_t)(info_t);
+
+struct node {
+ list_t next;
+ info_t info;
+};
+
+list_t mk_empty(void);
+int is_empty(list_t l);
+info_t is_in(cmp_func_t cmp, info_t e, list_t l);
+info_t head(list_t l);
+list_t tail(list_t l);
+list_t remove_head(list_t l);
+list_t cons(info_t e, list_t l);
+list_t prepend_elem(info_t e, list_t);
+list_t append_elem(info_t e, list_t);
+list_t remove_all(free_func_t free_func, list_t l);
+list_t insert_sorted(cmp_func_t cmp_func, info_t e, list_t l);
+void apply(process_func_t process_func, list_t l);
+
+#endif /* __LIST_H__ */
diff --git a/ubi-utils/inc/nandecc.h b/ubi-utils/inc/nandecc.h
new file mode 100644
index 0000000..fb5d529
--- /dev/null
+++ b/ubi-utils/inc/nandecc.h
@@ -0,0 +1,28 @@
+#ifndef _NAND_ECC_H
+#define _NAND_ECC_H
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * NAND ecc functions
+ */
+
+#include <stdint.h>
+
+extern int nand_calculate_ecc(const uint8_t *dat, uint8_t *ecc_code);
+extern int nand_correct_data(uint8_t *dat, const uint8_t *fail_ecc);
+
+#endif
diff --git a/ubi-utils/inc/peb.h b/ubi-utils/inc/peb.h
new file mode 100644
index 0000000..246bce8
--- /dev/null
+++ b/ubi-utils/inc/peb.h
@@ -0,0 +1,41 @@
+#ifndef __RAW_BLOCK_H__
+#define __RAW_BLOCK_H__
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Oliver Lohmann
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+
+typedef struct peb *peb_t;
+struct peb {
+ uint32_t num; /* Physical eraseblock number
+ * in the RAW file. */
+ uint32_t size; /* Data Size (equals physical
+ * erase block size) */
+ uint8_t* data; /* Data buffer */
+};
+
+int peb_new(uint32_t peb_num, uint32_t peb_size, peb_t* peb);
+int peb_free(peb_t* peb);
+int peb_cmp(peb_t peb_1, peb_t peb_2);
+int peb_write(FILE* fp_out, peb_t peb);
+void peb_dump(FILE* fp_out, peb_t peb);
+
+#endif /* __RAW_BLOCK_H__ */
diff --git a/ubi-utils/inc/pfi.h b/ubi-utils/inc/pfi.h
new file mode 100644
index 0000000..8c5cc07
--- /dev/null
+++ b/ubi-utils/inc/pfi.h
@@ -0,0 +1,244 @@
+#ifndef __pfi_h
+#define __pfi_h
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/**
+ * @file pfi.h
+ *
+ * @author Oliver Lohmann <oliloh@de.ibm.com>
+ * Andreas Arnez <arnez@de.ibm.com>
+ * Joern Engel <engeljoe@de.ibm.com>
+ * Frank Haverkamp <haverkam@de.ibm.com>
+ *
+ * @brief libpfi will hold all code to create and process pfi
+ * images. Definitions made in this file are equaly usable for the
+ * development host and the target system.
+ *
+ * @note This header additionally holds the official definitions for
+ * the pfi headers.
+ */
+
+#include <stdio.h> /* FILE */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Definitions. */
+
+#define PFI_HDRVERSION 1 /* current header version */
+
+#define PFI_ENOVERSION 1 /* unknown version */
+#define PFI_ENOHEADER 2 /* not a pfi header */
+#define PFI_EINSUFF 3 /* insufficient information */
+#define PFI_EUNDEF 4 /* key not defined */
+#define PFI_ENOMEM 5 /* out of memory */
+#define PFI_EBADTYPE 6 /* bad data type */
+#define PFI_EFILE 7 /* file I/O error: see errno */
+#define PFI_EFILEINVAL 8 /* file format not valid */
+#define PFI_EINVAL 9 /* invalid parameter */
+#define PFI_ERANGE 10 /* invalid range */
+#define PFI_EMODE 11 /* expecting other mode in this header */
+#define PFI_DATA_START 12 /* data section starts */
+#define PFI_EMAX 13 /* should be always larger as the largest
+ error code */
+
+#define PFI_LABEL_LEN 64 /* This is the maximum length for a
+ PFI header label */
+#define PFI_KEYWORD_LEN 32 /* This is the maximum length for an
+ entry in the mode and type fields */
+
+#define PFI_UBI_MAX_VOLUMES 128
+#define PFI_UBI_VOL_NAME_LEN 127
+
+/**
+ * @brief The pfi header allows to set flags which influence the flashing
+ * behaviour.
+ */
+#define PFI_FLAG_PROTECTED 0x00000001
+
+
+/**
+ * @brief Handle to pfi header. Used in most of the functions associated
+ * with pfi file handling.
+ */
+typedef struct pfi_header *pfi_header;
+
+
+/**
+ * @brief Initialize a pfi header object.
+ *
+ * @param head Pointer to handle. This function allocates memory
+ * for this data structure.
+ * @return 0 on success, otherwise:
+ * PFI_ENOMEM : no memory available for the handle.
+ */
+int pfi_header_init (pfi_header *head);
+
+
+/**
+ * @brief Destroy a pfi header object.
+ *
+ * @param head handle. head is invalid after calling this function.
+ * @return 0 always.
+ */
+int pfi_header_destroy (pfi_header *head);
+
+
+/**
+ * @brief Add a key/value pair to a pfi header object.
+ *
+ * @param head handle.
+ * @param key pointer to key string. Must be 0 terminated.
+ * @param value pointer to value string. Must be 0 terminated.
+ * @return 0 on success, otherwise:
+ * PFI_EUNDEF : key was not found.
+ * PFI_ENOMEM : no memory available for the handle.
+ * PFI_EBADTYPE : value is not an hex string. This happens
+ * when the key stores an integer and the
+ * new value is not convertable e.g. not in
+ * 0xXXXXXXXX format.
+ */
+int pfi_header_setvalue (pfi_header head,
+ const char *key, const char *value);
+
+
+/**
+ * @brief Add a key/value pair to a pfi header object. Provide the
+ * value as a number.
+ *
+ * @param head handle.
+ * @param key pointer to key string. Must be 0 terminated.
+ * @param value value to set.
+ * @return 0 on success, otherwise:
+ * PFI_EUNDEF : key was not found.
+ * PFI_EBADTYPE : value is not a string. This happens
+ * when the key stores a string.
+ */
+int pfi_header_setnumber (pfi_header head,
+ const char *key, uint32_t value);
+
+
+/**
+ * @brief For a given key, return the numerical value stored in a
+ * pfi header object.
+ *
+ * @param head handle.
+ * @param key pointer to key string. Must be 0 terminated.
+ * @param value pointer to value.
+ * @return 0 on success, otherwise:
+ * PFI_EUNDEF : key was not found.
+ * PFI_EBADTYPE : stored value is not an integer but a string.
+ */
+int pfi_header_getnumber (pfi_header head,
+ const char *key, uint32_t *value);
+
+
+static inline uint32_t
+pfi_getnumber(pfi_header head, const char *key)
+{
+ uint32_t value;
+ pfi_header_getnumber(head, key, &value);
+ return value;
+}
+
+/**
+ * @brief For a given key, return the string value stored in a pfi
+ * header object.
+ *
+ * @param head handle.
+ * @param key pointer to key string. Must be 0 terminated.
+ * @param value pointer to value string. Memory must be allocated by the user.
+ * @return 0 on success, otherwise:
+ * PFI_EUNDEF : key was not found.
+ * PFI_EBADTYPE : stored value is not a string but an integer.
+ */
+int pfi_header_getstring (pfi_header head,
+ const char *key, char *value, size_t size);
+
+
+/**
+ * @brief Write a pfi header object into a given file.
+ *
+ * @param out output stream.
+ * @param head handle.
+ * @return 0 on success, error values otherwise:
+ * PFI_EINSUFF : not all mandatory fields are filled.
+ * PFI_ENOHEADER : wrong header version or magic number.
+ * -E* : see <asm/errno.h>.
+ */
+int pfi_header_write (FILE *out, pfi_header head);
+
+
+/**
+ * @brief Read a pfi header object from a given file.
+ *
+ * @param in input stream.
+ * @param head handle.
+ * @return 0 on success, error values otherwise:
+ * PFI_ENOVERSION: unknown header version.
+ * PFI_EFILE : cannot read enough data.
+ * PFI_ENOHEADER : wrong header version or magic number.
+ * -E* : see <asm/errno.h>.
+ *
+ * If the header verification returned success the user can assume that
+ * all mandatory fields for a particular version are accessible. Checking
+ * the return code when calling the get-function for those keys is not
+ * required in those cases. For optional fields the checking must still be
+ * done.
+ */
+int pfi_header_read (FILE *in, pfi_header head);
+
+
+/**
+ * @brief Display a pfi header in human-readable form.
+ *
+ * @param out output stream.
+ * @param head handle.
+ * @return always 0.
+ *
+ * @note Prints out that it is not implemented and whom you should
+ * contact if you need it urgently!.
+ */
+int pfi_header_dump (FILE *out, pfi_header head);
+
+
+/*
+ * @brief Iterates over a stream of pfi files. The iterator function
+ * must advance the file pointer in FILE *in to the next pfi
+ * header. Function exists on feof(in).
+ *
+ * @param in input file descriptor, must be open and valid.
+ * @param func iterator function called when pfi header could be
+ * read and was validated. The function must return 0 on
+ * success.
+ * @return See pfi_header_init and pfi_header_read.
+ * PFI_EINVAL : func is not valid
+ * 0 ok.
+ */
+typedef int (* pfi_read_func)(FILE *in, pfi_header hdr, void *priv_data);
+
+int pfi_read (FILE *in, pfi_read_func func, void *priv_data);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __pfi_h */
diff --git a/ubi-utils/inc/pfiflash.h b/ubi-utils/inc/pfiflash.h
new file mode 100644
index 0000000..fc2eede
--- /dev/null
+++ b/ubi-utils/inc/pfiflash.h
@@ -0,0 +1,62 @@
+#ifndef __PFIFLASH_H__
+#define __PFIFLASH_H__
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/**
+ *
+ * @file pfi.h
+ *
+ * @author Oliver Lohmann <oliloh@de.ibm.com>
+ *
+ * @brief The pfiflash library offers an interface for using the
+ * pfiflash * utility.
+ */
+
+#include <stdio.h> /* FILE */
+
+#define PFIFLASH_MAX_ERR_BUF_SIZE 1024
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum pdd_handling_t
+{
+ PDD_KEEP = 0,
+ PDD_MERGE,
+ PDD_OVERWRITE,
+ PDD_HANDLING_NUM, /* always the last item */
+} pdd_handling_t; /**< Possible PDD handle algorithms. */
+
+/**
+ * @brief Flashes a PFI file to UBI Device 0.
+ * @param complete [0|1] Do a complete system update.
+ * @param seqnum Index in a redundant group.
+ * @param pdd_handling The PDD handling algorithm.
+ * @param err_buf An error buffer.
+ * @param err_buf_size Size of the error buffer.
+ */
+int pfiflash(FILE* pfi, int complete, int seqnum, pdd_handling_t pdd_handling,
+ char *err_buf, size_t err_buf_size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __PFIFLASH_H__ */
diff --git a/ubi-utils/inc/reader.h b/ubi-utils/inc/reader.h
new file mode 100644
index 0000000..93c15e3
--- /dev/null
+++ b/ubi-utils/inc/reader.h
@@ -0,0 +1,84 @@
+#ifndef __READER_H__
+#define __READER_H__
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Oliver Lohmann
+ *
+ * Read Platform Description Data (PDD).
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+
+#include "pfi.h"
+#include "bootenv.h"
+#include "list.h"
+
+typedef enum flash_type_t {
+ NAND_FLASH = 0,
+ NOR_FLASH,
+} flash_type_t;
+
+typedef struct pdd_data *pdd_data_t;
+typedef struct pfi_raw *pfi_raw_t;
+typedef struct pfi_ubi *pfi_ubi_t;
+
+struct pdd_data {
+ uint32_t flash_size;
+ uint32_t eb_size;
+ uint32_t vid_hdr_offset;
+ flash_type_t flash_type;
+};
+
+struct pfi_raw {
+ uint32_t data_size;
+ uint32_t *starts;
+ uint32_t starts_size;
+};
+
+struct pfi_ubi {
+ uint32_t data_size;
+ uint32_t alignment;
+ uint32_t *ids;
+ uint32_t ids_size;
+ char **names;
+ uint32_t names_size;
+ uint32_t size;
+ enum { pfi_ubi_dynamic, pfi_ubi_static } type;
+ int curr_seqnum; /* specifies the seqnum taken in an update,
+ default: 0 (used by pfiflash, ubimirror) */
+};
+
+int read_pdd_data(FILE* fp_pdd, pdd_data_t *pdd_data,
+ char *err_buf, size_t err_buf_size);
+int read_pfi_raw(pfi_header pfi_hd, FILE* fp_pfi, pfi_raw_t *pfi_raw,
+ const char *label, char *err_buf, size_t err_buf_size);
+int read_pfi_ubi(pfi_header pfi_hd, FILE* fp_pfi, pfi_ubi_t *pfi_ubi,
+ const char *label, char *err_buf, size_t err_buf_size);
+
+/**
+ * @brief Reads all pfi headers into list structures, separated by
+ * RAW and UBI sections.
+ */
+int read_pfi_headers(list_t *pfi_raws, list_t *pfi_ubis, FILE* fp_pfi,
+ char* err_buf, size_t err_buf_size);
+int free_pdd_data(pdd_data_t *pdd_data);
+int free_pfi_raw(pfi_raw_t *raw_pfi);
+int free_pfi_ubi(pfi_ubi_t *pfi_ubi);
+
+#endif /* __READER_H__ */
diff --git a/ubi-utils/inc/ubigen.h b/ubi-utils/inc/ubigen.h
new file mode 100644
index 0000000..9e9e8ec
--- /dev/null
+++ b/ubi-utils/inc/ubigen.h
@@ -0,0 +1,149 @@
+#ifndef __UBIGEN_H__
+#define __UBIGEN_H__
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Frank Haverkamp
+ *
+ * An utility to update UBI volumes.
+ */
+
+#include <stdio.h> /* FILE */
+#include <stdint.h>
+#include <mtd/ubi-header.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define DEFAULT_BLOCKSIZE (128 * 1024)
+#define DEFAULT_PAGESIZE (2*1024)
+
+#define EUBIGEN_INVALID_TYPE 1
+#define EUBIGEN_INVALID_HDR_OFFSET 2
+#define EUBIGEN_INVALID_ALIGNMENT 3
+#define EUBIGEN_TOO_SMALL_EB 4
+#define EUBIGEN_MAX_ERROR 5
+
+
+typedef enum action {
+ NO_ERROR = 0x00000000,
+ BROKEN_HDR_CRC = 0x00000001,
+ BROKEN_DATA_CRC = 0x00000002,
+ BROKEN_DATA_SIZE = 0x00000004,
+ BROKEN_OMIT_BLK = 0x00000008,
+ MARK_AS_UPDATE = 0x00000010,
+} ubigen_action_t;
+
+typedef struct ubi_info *ubi_info_t;
+
+/**
+ * @brief Initialize the internal CRC32 table.
+ * @note Necessary because of the used crc32 function in UBI.
+ * A usage of CRC32, from e.g. zlib will fail.
+ */
+void ubigen_init(void);
+
+/**
+ * @brief Create an ubigen handle.
+ * @param ...
+ * @return 0 On sucess.
+ * else Error.
+ * @note This parameterlist is ugly. But we have to use
+ * two big structs and meta information internally,
+ * filling them would be even uglier.
+ */
+int ubigen_create(ubi_info_t *u, uint32_t vol_id, uint8_t vol_type,
+ uint32_t eb_size, uint64_t ec, uint32_t alignment,
+ uint8_t version, uint32_t vid_hdr_offset,
+ uint8_t compat_flag, size_t data_size,
+ FILE* fp_in, FILE* fp_out);
+
+/**
+ * @brief Destroy an ubigen handle.
+ * @param u Handle to free.
+ * @return 0 On success.
+ * else Error.
+ */
+int ubigen_destroy(ubi_info_t *u);
+
+/**
+ * @brief Get number of total logical EBs, necessary for the
+ * complete storage of data in the handle.
+ * @param u The handle.
+ * @return 0 On success.
+ * else Error.
+ */
+int ubigen_get_leb_total(ubi_info_t u, size_t* total);
+
+/**
+ * @brief Get the size in bytes of one logical EB in the handle.
+ * @param u The handle.
+ * @return 0 On success.
+ * else Error.
+ */
+int ubigen_get_leb_size(ubi_info_t u, size_t* size);
+
+
+/**
+ * @brief Write a logical EB (fits exactly into 1 physical EB).
+ * @param u Handle which holds all necessary data.
+ * @param action Additional operations which shall be applied on this
+ * logical eraseblock. Mostly injecting artifical errors.
+ * @return 0 On success.
+ * else Error.
+ */
+int ubigen_write_leb(ubi_info_t u, ubigen_action_t action);
+
+/**
+ * @brief Write a complete array of logical eraseblocks at once.
+ * @param u Handle which holds all necessary data.
+ * @return 0 On success.
+ * else Error.
+ */
+int ubigen_write_complete(ubi_info_t u);
+
+/**
+ * @brief Write a single block which is extracted from the
+ * binary input data.
+ * @param u Handle which holds all necessary data.
+ * @param blk Logical eraseblock which shall hold a inc. copy entry
+ * and a bad data crc.
+ * @return 0 On success.
+ * else Error.
+ */
+int ubigen_write_broken_update(ubi_info_t u, uint32_t blk);
+
+/**
+ * @brief Use the current ubi_info data and some additional data
+ * to set an UBI volume table entry from it.
+ * @param u Handle which holds some of the necessary data.
+ * @param res_bytes Number of reserved bytes which is stored in the volume
+ * table entry.
+ * @param name A string which shall be used as a volume label.
+ * @param lvol_r A pointer to a volume table entry.
+ * @return 0 On success.
+ * else Error.
+ */
+int ubigen_set_lvol_rec(ubi_info_t u, size_t reserved_bytes,
+ const char* name, struct ubi_vol_tbl_record *lvol_rec);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __UBIGEN_H__ */
diff --git a/ubi-utils/inc/ubimirror.h b/ubi-utils/inc/ubimirror.h
new file mode 100644
index 0000000..893f5ce
--- /dev/null
+++ b/ubi-utils/inc/ubimirror.h
@@ -0,0 +1,66 @@
+#ifndef __UBIMIRROR_H__
+#define __UBIMIRROR_H__
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Oliver Lohmann
+ *
+ * An utility to mirror UBI volumes.
+ */
+
+#include <stdint.h>
+
+/**
+ * @def EUBIMIRROR_SRC_EQ_DST
+ * @brief Given source volume is also in the set of destination volumes.
+ */
+#define EUBIMIRROR_SRC_EQ_DST 20
+
+/**
+ * @def EUBIMIRROR_NO_SRC
+ * @brief The given source volume does not exist.
+ */
+#define EUBIMIRROR_NO_SRC 21
+
+/**
+ * @def EUBIMIRROR_NO_DST
+ * @brief One of the given destination volumes does not exist.
+ */
+#define EUBIMIRROR_NO_DST 22
+
+/**
+ * @brief Mirrors UBI devices from a source device (specified by seqnum)
+ * to n target devices.
+ * @param devno Device number used by the UBI operations.
+ * @param seqnum An index into ids (defines the src_id).
+ * @param ids An array of ids.
+ * @param ids_size The number of entries in the ids array.
+ * @param err_buf A buffer to store verbose error messages.
+ * @param err_buf_size The size of the error buffer.
+ *
+ * @note A seqnum of value < 0 defaults to a seqnum of 0.
+ * @note A seqnum exceeding the range of ids_size defaults to 0.
+ * @note An empty ids list results in a empty stmt.
+ * @pre The UBI volume which shall be used as source volume exists.
+ * @pre The UBI volumes which are defined as destination volumes exist.
+ * @post The content of the UBI volume which was defined as source volume
+ * equals the content of the volumes which were defined as destination.
+ */
+int ubimirror(uint32_t devno, int seqnum, uint32_t* ids, size_t ids_size,
+ char *err_buf, size_t err_buf_size);
+
+#endif /* __UBIMIRROR_H__ */
diff --git a/ubi-utils/lib/Makefile.am b/ubi-utils/lib/Makefile.am
new file mode 100644
index 0000000..1b0dc01
--- /dev/null
+++ b/ubi-utils/lib/Makefile.am
@@ -0,0 +1,58 @@
+AUTOMAKE_OPTIONS = foreign
+INCLUDES=-I$(top_srcdir)/inc -I$(top_srcdir)/../../kernel/include
+
+# -----------------------------------------------------------------------------
+# all export libs which shall be generated
+lib_LTLIBRARIES = libubi.la \
+ libpfiflash.la
+
+# -----------------------------------------------------------------------------
+# all convinence libs which shall be generated
+noinst_LTLIBRARIES = libcrc32.la \
+ libubigen.la \
+ liberror.la \
+ liblist.la \
+ libbootenv.la \
+ libpfi.la \
+ libpeb.la \
+ libreader.la \
+ libubimirror.la
+
+# -----------------------------------------------------------------------------
+# exported libs
+libpfiflash_la_SOURCES = $(top_srcdir)/src/libpfiflash/pfiflash.c
+libpfiflash_la_LDFLAGS = -no-undefined -version-info 1:0:0
+libpfiflash_la_LIBADD = libreader.la \
+ libubimirror.la \
+ libubi.la
+
+libubi_la_SOURCES = $(top_srcdir)/src/libubi/libubi.c \
+ $(top_srcdir)/src/libubi/libubi_sysfs.c
+libubi_la_LDFLAGS = -no-undefined -version-info 1:0:0
+
+# -----------------------------------------------------------------------------
+# complex convinence libs, beware for double includes.
+libreader_la_SOURCES = $(top_srcdir)/src/libreader/reader.c
+libreader_la_LIBADD = libpfi.la \
+ liblist.la \
+ libpeb.la \
+ libbootenv.la
+
+libubigen_la_SOURCES = $(top_srcdir)/src/libubigen/ubigen.c
+libubigen_la_LIBADD = libcrc32.la
+
+libbootenv_la_SOURCES = $(top_srcdir)/src/libbootenv/bootenv.c \
+ $(top_srcdir)/src/libbootenv/hashmap.c
+libbootenv_la_LIBADD = libcrc32.la
+
+libubimirror_la_SOURCES = $(top_srcdir)/src/libubimirror/ubimirror.c
+libubimirror_la_LIBADD = libubi.la
+
+
+# -----------------------------------------------------------------------------
+# simple convinence libs
+libcrc32_la_SOURCES = $(top_srcdir)/src/libcrc32/crc32.c
+liberror_la_SOURCES = $(top_srcdir)/src/liberror/error.c
+liblist_la_SOURCES = $(top_srcdir)/src/liblist/list.c
+libpeb_la_SOURCES = $(top_srcdir)/src/libpeb/peb.c
+libpfi_la_SOURCES = $(top_srcdir)/src/libpfi/pfi.c
diff --git a/ubi-utils/scripts/Makefile b/ubi-utils/scripts/Makefile
new file mode 100644
index 0000000..6d014ea
--- /dev/null
+++ b/ubi-utils/scripts/Makefile
@@ -0,0 +1,57 @@
+#
+# Makefile
+#
+# Testcase for UBI pfi update.
+#
+# Author: Frank Haverkamp <haverkam@de.ibm.com>
+#
+
+card = test
+mkpfi_cfg = test.cfg
+
+#
+# Some default values you might want to overwrite. Try it if you need
+# it and add more if needed. Note that no real sanity checking is done
+# on those values. If you do it wrong your card has no valid PDD data.
+#
+
+PATH := $(PATH):/opt/ppc/usr/bin
+
+dd = dd
+sed = sed
+bin2nand = bin2nand
+ubigen = ubigen
+mkpfi = mkpfi
+pfi2bin = pfi2bin
+
+vmlinux_bin ?= test_vmlinux.bin
+rootfs_bin ?= test_rootfs.bin
+spl_bin ?= test_u-boot.bin
+
+compl ?= $(card)_complete
+compl_pfi ?= $(compl).pfi
+
+all: $(compl_pfi)
+
+$(compl_pfi): $(vmlinux_bin) $(rootfs_bin) $(spl_bin)
+ $(mkpfi) -c $(mkpfi_cfg)
+
+#
+# Default data
+#
+# If the binary data is not available in the current working directory
+# we try to create symlinks to our test data.
+#
+$(vmlinux_bin) $(rootfs_bin) $(spl_bin):
+ @echo
+ @echo "No $@ found, will use defaults !"
+ @echo
+ @echo "OR press CTRL-C to provide your own $@" && \
+ sleep 1 && \
+ $(dd) if=/dev/urandom of=$@ bs=1M count=1
+
+clean:
+ $(RM) *.pfi *~
+
+distclean: clean
+ $(RM) *.bin
diff --git a/ubi-utils/scripts/README b/ubi-utils/scripts/README
new file mode 100644
index 0000000..899b4a1
--- /dev/null
+++ b/ubi-utils/scripts/README
@@ -0,0 +1,11 @@
+README
+======
+
+This procedure creates a test pfi which should be flashed to our
+system with pfiflash. The testcase should read the data back and
+compare with the original.
+
+We should try not forget to run these tests before we release
+a new version of UBI.
+
+Frank
diff --git a/ubi-utils/scripts/TODO b/ubi-utils/scripts/TODO
new file mode 100644
index 0000000..f093e77
--- /dev/null
+++ b/ubi-utils/scripts/TODO
@@ -0,0 +1,5 @@
+TODO
+====
+
+ * Range checking is broken, reserving 2M and offering 3M binary data
+ ... works!? No!
diff --git a/ubi-utils/scripts/jffs2_test.sh b/ubi-utils/scripts/jffs2_test.sh
new file mode 100755
index 0000000..0cc9f0c
--- /dev/null
+++ b/ubi-utils/scripts/jffs2_test.sh
@@ -0,0 +1,91 @@
+#!/bin/sh
+#
+# Testcase for JFFS2 verification. We do not want to see any
+# kernel errors occuring when this is executed.
+#
+#
+# To have a standardized output I define the following function to be
+# used when a test was ok or when it failed.
+#
+failed ()
+{
+ echo "FAILED"
+}
+
+passed ()
+{
+ echo "PASSED"
+}
+
+#
+# Print sucess message. Consider to exit with zero as return code.
+#
+exit_success ()
+{
+ echo "SUCCESS"
+ exit 0
+}
+
+#
+# Print failure message. Consider to exit with non zero return code.
+#
+exit_failure ()
+{
+ echo "FAILED"
+ exit 1
+}
+
+echo "***********************************************************************"
+echo "* jffs2 testing ... *"
+echo "***********************************************************************"
+
+ulimit -c unlimited
+
+for i in `seq 5000`; do
+ echo "Testing $i byte (dd if=/dev/urandom of=foo bs=$i count=1) ... "
+ dd if=/dev/urandom of=test.bin bs=$i count=1;
+ if [ $? -ne "0" ] ; then
+ exit_failure
+ fi
+ passed
+
+ echo "Copy to different file ... "
+ dd if=test.bin of=new.bin bs=$i count=1;
+ if [ $? -ne "0" ] ; then
+ exit_failure
+ fi
+ passed
+
+ echo "Comparing files ... "
+ cmp test.bin new.bin
+ dd if=test.bin of=new.bin bs=$i count=1;
+ if [ $? -ne "0" ] ; then
+ exit_failure
+ fi
+ passed
+done
+
+for i in `seq 5000`; do
+ echo "Testing $i byte (dd if=/dev/urandom of=foo bs=$i count=1) ... "
+ dd if=/dev/urandom of=foo bs=$i count=1;
+ if [ $? -ne "0" ] ; then
+ exit_failure
+ fi
+ passed
+done
+
+for i in `seq 5000`; do
+ echo "Testing $i byte (dd if=/dev/zero of=foo bs=$i count=1) ... "
+ dd if=/dev/zero of=foo bs=$i count=1;
+ if [ $? -ne "0" ] ; then
+ exit_failure
+ fi
+ passed
+done
+
+echo "***********************************************************************"
+echo "* Congratulations, no errors found! *"
+echo "* Have fun with your cool JFFS2 using system! *"
+echo "***********************************************************************"
+
+exit_success
diff --git a/ubi-utils/scripts/test.cfg b/ubi-utils/scripts/test.cfg
new file mode 100644
index 0000000..0b5ec48
--- /dev/null
+++ b/ubi-utils/scripts/test.cfg
@@ -0,0 +1,23 @@
+[targets]
+test_complete=spl,kernel,rootfs
+
+[spl]
+image=test_u-boot.bin
+ubi_ids=10,11
+ubi_size=1MiB
+ubi_type=static
+ubi_names=test_spl_0,test_spl_1
+
+[kernel]
+image=test_vmlinux.bin
+ubi_ids=12,13
+ubi_size=2MiB
+ubi_type=static
+ubi_names=test_kernel_0,test_kernel_1
+
+[rootfs]
+image=test_rootfs.bin
+ubi_ids=14,15
+ubi_size=2MiB
+ubi_type=dynamic
+ubi_names=test_rootfs_0,test_rootfs_1
diff --git a/ubi-utils/scripts/ubi_test.sh b/ubi-utils/scripts/ubi_test.sh
new file mode 100755
index 0000000..9017148
--- /dev/null
+++ b/ubi-utils/scripts/ubi_test.sh
@@ -0,0 +1,318 @@
+#!/bin/sh
+#
+# UBI Volume creation/deletion/write/read test script
+#
+# Written in shell language to reduce dependencies to more sophisticated
+# interpreters, which may not be available on some stupid platforms.
+#
+
+export PATH=$PATH:~/bin:/usr/local/bin:/home/dedekind/work/prj/ubi/tools/flashutils/bin/
+
+UBIMKVOL=ubimkvol
+UBIRMVOL=ubirmvol
+UBIWRITEVOL=ubiwritevol
+
+# 128 KiB 131072
+# 256 KiB 262144
+# 512 KiB 524288
+
+SIZE_512K=524288
+SIZE_1M=1310720
+
+SELF=$0
+MINVOL=10
+MAXVOL=12
+
+#
+# To have a standardized output I define the following function to be
+# used when a test was ok or when it failed.
+#
+failed ()
+{
+ echo "FAILED"
+}
+
+passed ()
+{
+ echo "PASSED"
+}
+
+#
+# Print sucess message. Consider to exit with zero as return code.
+#
+exit_success ()
+{
+ echo "SUCCESS"
+ exit 0
+}
+
+#
+# Print failure message. Consider to exit with non zero return code.
+#
+exit_failure ()
+{
+ echo "FAILED"
+ exit 1
+}
+
+###############################################################################
+#
+# START
+#
+###############################################################################
+
+fix_sysfs_issue ()
+{
+ echo -n "*** Fixing the sysfs issue with the /dev nodes ... "
+
+ minor=0
+ major=`grep ubi0 /proc/devices | sed -e 's/\(.*\) ubi0/\1/'`
+
+ rm -rf /dev/ubi0
+ mknod /dev/ubi0 c $major 0
+
+ for minor in `seq 0 $MAXVOL`; do
+ ### echo " mknod /dev/ubi0_$minor c $major $(($minor + 1))"
+ rm -rf /dev/ubi0_$minor
+ mknod /dev/ubi0_$minor c $major $(($minor + 1))
+ done
+ passed
+}
+
+# delete_volume - Delete a volume. If it does not exist, do not try
+# to delete it.
+# @id: volume id
+#
+delete_volume ()
+{
+ volume=$1
+
+ ### FIXME broken sysfs!!!!
+ if [ -e /sys/class/ubi/$volume -o -e /sys/class/ubi/ubi0/$volume ]; then
+
+ echo -n "*** Truncate volume if it exists ... "
+ $UBIWRITEVOL -d0 -n$volume -t
+ if [ $? -ne "0" ] ; then
+ exit_failure
+ fi
+ passed
+
+ echo -n "*** Delete volume if it exists ... "
+ $UBIRMVOL -d0 -n$volume
+ if [ $? -ne "0" ] ; then
+ exit_failure
+ fi
+ passed
+ fi
+}
+
+mkvol_rmvol_test ()
+{
+ type=$1
+
+### Test if volume delete on non-existing volumes fails nicely
+
+ for i in `seq $MINVOL $MAXVOL`; do
+ echo "*** Delete if exist or not $i ... "
+
+ delete_volume $i
+ passed
+ done
+
+### Now deleting volumes must fail
+
+ for i in `seq $MINVOL $MAXVOL`; do
+ echo "*** Trying to delete non existing UBI Volume $i ... "
+
+ $UBIRMVOL -d0 -n$i
+ if [ $? -eq "0" ] ; then
+ exit_failure
+ fi
+ passed
+ done
+
+### Test if volume creation works ok
+
+ for i in `seq $MINVOL $MAXVOL`; do
+ echo "*** Creating UBI Volume $i ... "
+
+ $UBIMKVOL -d0 -n$i -t$type -N"NEW$i" -s $SIZE_512K
+ if [ $? -ne "0" ] ; then
+ exit_failure
+ fi
+ passed
+ done
+
+### Now deleting volumes must be ok
+
+ for i in `seq $MINVOL $MAXVOL`; do
+ echo "*** Trying to delete UBI Volume $i ... "
+
+ $UBIRMVOL -d0 -n$i
+ if [ $? -ne "0" ] ; then
+ exit_failure
+ fi
+ passed
+ done
+
+### Now allocate too large volume
+
+ echo -n "*** Try to create too large volume"
+ $UBIMKVOL -d0 -n$MINVOL -t$type -N"NEW$MINVOL" -s 800000000
+ if [ $? -eq "0" ] ; then
+ exit_failure
+ fi
+ passed
+}
+
+# writevol_test - Tests volume creation and writing data to it.
+#
+# @size: Size of random data to write
+# @type: Volume type static or dynamic
+#
+writevol_test ()
+{
+ size=$1
+ type=$2
+
+ echo "*** Write volume test with size $size"
+
+### Make sure that volume exist, delete existing volume, create new
+
+ delete_volume $MINVOL
+
+ echo -n "*** Try to create volume ... "
+ $UBIMKVOL -d0 -n$MINVOL -t$type -N"NEW$MINVOL" -s $SIZE_1M
+ if [ $? -ne "0" ] ; then
+ exit_failure
+ fi
+ passed
+
+### Try to create same volume again
+ echo -n "*** Try to create some volume again, this must fail ... "
+ $UBIMKVOL -d0 -n$MINVOL -t$type -N"NEW$MINVOL" -s $SIZE_1M
+ if [ $? -eq "0" ] ; then
+ exit_failure
+ fi
+ passed
+
+### Now create test data, write it, read it, compare it
+ echo -n "*** Create test data ... "
+ dd if=/dev/urandom of=testdata.bin bs=$size count=1
+ if [ $? -ne "0" ] ; then
+ exit_failure
+ fi
+ passed
+
+ echo -n "*** Now writing data to volume ... "
+ ls -l testdata.bin
+ $UBIWRITEVOL -d0 -n$MINVOL testdata.bin
+ if [ $? -ne "0" ] ; then
+ exit_failure
+ fi
+ passed
+
+ if [ $type = "static" ] ; then
+ echo "*** Download data with cat ... "
+ cat /dev/ubi0_$MINVOL > readdata.bin
+ if [ $? -ne "0" ] ; then
+ exit_failure
+ fi
+ passed
+ else
+ echo "*** Download data with dd bs=1 ... "
+ dd if=/dev/ubi0_$MINVOL of=readdata.bin bs=$size count=1
+ if [ $? -ne "0" ] ; then
+ exit_failure
+ fi
+ passed
+
+ # Size 1 does not work with this test ...
+ #
+ #echo "*** Download data with dd bs=$size ... "
+ #dd if=/dev/ubi0_$MINVOL of=readdata2.bin bs=$size count=1
+ #if [ $? -ne "0" ] ; then
+ # exit_failure
+ #fi
+ #passed
+
+ #echo -n "*** Comparing data (1) ... "
+ #cmp readdata.bin readdata2.bin
+ #if [ $? -ne "0" ] ; then
+ # exit_failure
+ #fi
+ #passed
+ fi
+
+ echo -n "*** Comparing data ... "
+ cmp readdata.bin testdata.bin
+ if [ $? -ne "0" ] ; then
+ exit_failure
+ fi
+ passed
+}
+
+echo "***********************************************************************"
+echo "* UBI Testing starts now ... *"
+echo "* Good luck! *"
+echo "***********************************************************************"
+
+# Set to zero if not running on example hardware
+grep ubi /proc/devices > /dev/null
+if [ $? -ne "0" ]; then
+ echo "No UBI found in /proc/devices! I am broken!"
+ exit_failure
+fi
+
+# Set to zero if not running on example hardware
+grep 114218D /proc/cpuinfo > /dev/null
+if [ $? -eq "0" ]; then
+ echo "Running on example hardware"
+ mount -o remount,rw / /
+ sleep 1
+ fix_sysfs_issue
+else
+ echo "Running on Artems hardware"
+fi
+
+echo "***********************************************************************"
+echo "* mkvol/rmvol testing for static volumes ... *"
+echo "***********************************************************************"
+
+mkvol_rmvol_test static
+
+echo "***********************************************************************"
+echo "* mkvol/rmvol testing for dynamic volumes ... *"
+echo "***********************************************************************"
+
+mkvol_rmvol_test dynamic
+
+echo "***********************************************************************"
+echo "* write to static volumes ... *"
+echo "***********************************************************************"
+
+# 10 Erase blocks = (128 KiB - 64 * 2) * 10
+# = 1309440 bytes
+# 128 KiB 131072
+# 256 KiB 262144
+# 512 KiB 524288
+
+for size in 262144 131073 131072 2048 1 4096 12800 31313 ; do
+ writevol_test $size static
+done
+
+echo "***********************************************************************"
+echo "* write to dynamic volumes ... *"
+echo "***********************************************************************"
+
+#for size in 31313 ; do
+for size in 131073 131072 2048 1 4096 12800 31313 262144 ; do
+ writevol_test $size dynamic
+done
+
+echo "***********************************************************************"
+echo "* Congratulations, no errors found! *"
+echo "* Have fun with your cool UBI system! *"
+echo "***********************************************************************"
+
+exit_success \ No newline at end of file
diff --git a/ubi-utils/scripts/ubi_tools_test.sh b/ubi-utils/scripts/ubi_tools_test.sh
new file mode 100755
index 0000000..43fc2bb
--- /dev/null
+++ b/ubi-utils/scripts/ubi_tools_test.sh
@@ -0,0 +1,244 @@
+#!/bin/sh
+#
+# UBI Volume creation/deletion/write/read test script.
+# Uses our flash update tools and the associated toolchain for flash
+# image creation.
+#
+# Written in shell language to reduce dependencies to more sophisticated
+# interpreters, which may not be available on some stupid platforms.
+#
+
+export PATH=$PATH:~/bin:/usr/local/bin:/home/dedekind/work/prj/ubi/tools/flashutils/bin/
+
+UBIMKVOL=ubimkvol
+UBIRMVOL=ubirmvol
+UBIWRITEVOL=ubiwritevol
+PFIFLASH=pfiflash
+CMP=cmp
+
+MAXVOL=32
+
+test_pfi=test_complete.pfi
+real_pfi=example_complete.pfi
+
+# 128 KiB 131072
+# 256 KiB 262144
+# 512 KiB 524288
+
+#
+# To have a standardized output I define the following function to be
+# used when a test was ok or when it failed.
+#
+failed ()
+{
+ echo "FAILED"
+}
+
+passed ()
+{
+ echo "PASSED"
+}
+
+#
+# Print sucess message. Consider to exit with zero as return code.
+#
+exit_success ()
+{
+ echo "SUCCESS"
+ exit 0
+}
+
+#
+# Print failure message. Consider to exit with non zero return code.
+#
+exit_failure ()
+{
+ echo "FAILED"
+ exit 1
+}
+
+###############################################################################
+#
+# START
+#
+###############################################################################
+
+fix_sysfs_issue ()
+{
+ echo -n "*** Fixing the sysfs issue with the /dev nodes ... "
+
+ minor=0
+ major=`grep ubi0 /proc/devices | sed -e 's/\(.*\) ubi0/\1/'`
+
+ rm -rf /dev/ubi0
+ mknod /dev/ubi0 c $major 0
+
+ for minor in `seq 0 $MAXVOL`; do
+ ### echo " mknod /dev/ubi0_$minor c $major $(($minor + 1))"
+ rm -rf /dev/ubi0_$minor
+ mknod /dev/ubi0_$minor c $major $(($minor + 1))
+ done
+ passed
+}
+
+# delete_volume - Delete a volume. If it does not exist, do not try
+# to delete it.
+# @id: volume id
+#
+delete_volume ()
+{
+ volume=$1
+
+ ### FIXME broken sysfs!!!!
+ if [ -e /sys/class/ubi/$volume -o -e /sys/class/ubi/ubi0/$volume ]; then
+
+ echo -n "*** Truncate volume if it exists ... "
+ $UBIWRITEVOL -d0 -n$volume -t
+ if [ $? -ne "0" ] ; then
+ exit_failure
+ fi
+ passed
+
+ echo -n "*** Delete volume if it exists ... "
+ $UBIRMVOL -d0 -n$volume
+ if [ $? -ne "0" ] ; then
+ exit_failure
+ fi
+ passed
+ fi
+}
+
+echo "***********************************************************************"
+echo "* UBI Tools Testing starts now ... *"
+echo "* Good luck! *"
+echo "***********************************************************************"
+
+# Set to zero if not running on example hardware
+grep ubi /proc/devices > /dev/null
+if [ $? -ne "0" ]; then
+ echo "No UBI found in /proc/devices! I am broken!"
+ exit_failure
+fi
+
+# Set to zero if not running on example hardware
+grep 114218D /proc/cpuinfo > /dev/null
+if [ $? -eq "0" ]; then
+ echo "Running on example hardware"
+ mount -o remount,rw / /
+ sleep 1
+ fix_sysfs_issue
+else
+ echo "Running on other hardware"
+fi
+
+### Test basic stuff
+pfiflash_basic ()
+{
+ echo "Calling pfiflash with test-data ... "
+ $PFIFLASH $test_pfi
+ if [ $? -ne "0" ]; then
+ echo "Uhhh something went wrong!"
+ exit_failure
+ fi
+ passed
+
+ echo "Testing if data is correct 10 and 11 ... "
+ $CMP /dev/ubi0_10 /dev/ubi0_11
+ if [ $? -ne "0" ]; then
+ echo "Mirrored volumes not equal!"
+ exit_failure
+ fi
+ passed
+
+ echo "Comparing against original data ... "
+ $CMP /dev/ubi0_10 test_u-boot.bin
+ if [ $? -ne "0" ]; then
+ echo "Compared volume not equal!"
+ exit_failure
+ fi
+ passed
+
+ echo "Testing if data is correct 12 and 13 ... "
+ $CMP /dev/ubi0_12 /dev/ubi0_13
+ if [ $? -ne "0" ]; then
+ echo "Mirrored volumes not equal!"
+ exit_failure
+ fi
+ passed
+
+ echo "Comparing against original data ... "
+ $CMP /dev/ubi0_12 test_vmlinux.bin
+ if [ $? -ne "0" ]; then
+ echo "Compared volume not equal!"
+ exit_failure
+ fi
+ passed
+
+ echo "Testing if data is correct 14 and 15 ... "
+ $CMP /dev/ubi0_14 /dev/ubi0_15
+ if [ $? -ne "0" ]; then
+ echo "Mirrored volumes not equal!"
+ exit_failure
+ fi
+ passed
+}
+
+### Test each and everything
+pfiflash_advanced ()
+{
+ if [ -e example_complete.pfi ]; then
+ echo "Calling pfiflash with real data ... "
+ $PFIFLASH -p overwrite --complete example_complete.pfi
+ if [ $? -ne "0" ]; then
+ echo "Uhhh something went wrong!"
+ exit_failure
+ fi
+ passed
+
+ echo "Testing if data is correct 2 and 3 ... "
+ $CMP /dev/ubi0_2 /dev/ubi0_3
+ if [ $? -ne "0" ]; then
+ echo "Mirrored volumes not equal!"
+ exit_failure
+ fi
+ passed
+
+ echo "Comparing against original data ... "
+ $CMP /dev/ubi0_2 u-boot.bin
+ if [ $? -ne "0" ]; then
+ echo "Compared volume not equal!"
+ exit_failure
+ fi
+ passed
+
+ echo "Testing if data is correct 6 and 7 ... "
+ $CMP /dev/ubi0_6 /dev/ubi0_7
+ if [ $? -ne "0" ]; then
+ echo "Mirrored volumes not equal!"
+ exit_failure
+ fi
+ passed
+
+ echo "Comparing against original data ... "
+ $CMP /dev/ubi0_6 vmlinux.bin
+ if [ $? -ne "0" ]; then
+ echo "Compared volume not equal!"
+ exit_failure
+ fi
+ passed
+ fi
+}
+
+echo "***********************************************************************"
+echo "* Testing pfiflash ... *"
+echo "***********************************************************************"
+
+pfiflash_basic
+pfiflash_advanced
+
+echo "***********************************************************************"
+echo "* Congratulations, no errors found! *"
+echo "* Have fun with your cool UBI system! *"
+echo "***********************************************************************"
+
+exit_success \ No newline at end of file
diff --git a/ubi-utils/src/bin2nand/bin2nand.c b/ubi-utils/src/bin2nand/bin2nand.c
new file mode 100644
index 0000000..5224e3b
--- /dev/null
+++ b/ubi-utils/src/bin2nand/bin2nand.c
@@ -0,0 +1,343 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Oliver Lohmann
+ */
+
+/*
+ * Create a flashable NAND image from a binary image
+ *
+ * History:
+ * 1.0: Initial release (tglx)
+ *
+ * 1.1: Understands hex and dec input parameters (tglx)
+ * 1.2: Generates separated OOB data, if needed. (oloh)
+ * 1.3: Padds data/oob to a given size. (oloh)
+ *
+ */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <argp.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+#include "error.h"
+#include "config.h"
+#include "nandecc.h"
+
+#define CHECK_ENDP(option, endp) do { \
+ if (*endp) { \
+ fprintf(stderr, \
+ "Parse error option \'%s\'. " \
+ "No correct numeric value.\n" \
+ , option); \
+ exit(EXIT_FAILURE); \
+ } \
+} while(0)
+
+typedef enum action_t {
+ ACT_NORMAL = 0x00000001,
+} action_t;
+
+#define PAGESIZE 2048
+#define PADDING 0 /* 0 means, do not adjust anything */
+#define BUFSIZE 4096
+
+const char *argp_program_version = PACKAGE_VERSION;
+const char *argp_program_bug_address = PACKAGE_BUGREPORT;
+static char doc[] = "\nVersion: " PACKAGE_VERSION "\n\tBuilt on "
+ BUILD_CPU" "BUILD_OS" at "__DATE__" "__TIME__"\n"
+ "\n"
+ "bin2nand - a tool for adding OOB information to a "
+ "binary input file.\n";
+
+static const char copyright [] __attribute__((unused)) =
+ "FIXME: insert license type."; /* FIXME */
+
+static struct argp_option options[] = {
+ { name: "copyright", key: 'c', arg: NULL, flags: 0,
+ doc: "Print copyright information.",
+ group: 1 },
+
+ { name: "pagesize", key: 'p', arg: "<num>", flags: 0,
+ doc: "Pagesize in Byte/Mi/ki. Default: 2048",
+ group: 1 },
+
+ { name: "padding", key: 'j', arg: "<num>", flags: 0,
+ doc: "Padding in Byte/Mi/ki. Default: no padding",
+ group: 1 },
+
+ /* Output options */
+ { name: NULL, key: 0, arg: NULL, flags: 0,
+ doc: "Output settings:",
+ group: 2 },
+
+ { name: "output", key: 'o', arg: "<fname>", flags: 0,
+ doc: "Output filename. Interleaved Data/OOB if output-oob not "
+ "specified.",
+ group: 2 },
+
+ { name: "output-oob", key: 'q', arg: "<fname>", flags: 0,
+ doc: "Write OOB data in separate file.",
+ group: 2 },
+
+ { name: NULL, key: 0, arg: NULL, flags: 0, doc: NULL, group: 0 },
+};
+
+typedef struct myargs {
+ action_t action;
+
+ size_t pagesize;
+ size_t padding;
+
+ FILE* fp_in;
+ char *file_out_data; /* Either: Data and OOB interleaved
+ or plain data */
+ char *file_out_oob; /* OOB Data only. */
+
+ /* special stuff needed to get additional arguments */
+ char *arg1;
+ char **options; /* [STRING...] */
+} myargs;
+
+
+static int ustrtoull(const char *cp, char **endp, unsigned int base)
+{
+ unsigned long long res = strtoull(cp, endp, base);
+
+ switch (**endp) {
+ case 'G':
+ res *= 1024;
+ case 'M':
+ res *= 1024;
+ case 'k':
+ case 'K':
+ res *= 1024;
+ /* "Ki", "ki", "Mi" or "Gi" are to be used. */
+ if ((*endp)[1] == 'i')
+ (*endp) += 2;
+ }
+ return res;
+}
+
+static error_t
+parse_opt(int key, char *arg, struct argp_state *state)
+{
+ int err = 0;
+ char* endp;
+
+ myargs *args = state->input;
+
+ switch (key) {
+ case 'p': /* pagesize */
+ args->pagesize = (size_t) ustrtoull(arg, &endp, 0);
+ CHECK_ENDP("p", endp);
+ break;
+ case 'j': /* padding */
+ args->padding = (size_t) ustrtoull(arg, &endp, 0);
+ CHECK_ENDP("j", endp);
+ break;
+ case 'o': /* output */
+ args->file_out_data = arg;
+ break;
+ case 'q': /* output oob */
+ args->file_out_oob = arg;
+ break;
+ case ARGP_KEY_ARG: /* input file */
+ args->fp_in = fopen(arg, "rb");
+ if ((args->fp_in) == NULL) {
+ err_quit("Cannot open file %s for input\n", arg);
+ }
+ args->arg1 = arg;
+ args->options = &state->argv[state->next];
+ state->next = state->argc;
+ break;
+ case ARGP_KEY_END:
+ if (err) {
+ err_msg("\n");
+ argp_usage(state);
+ exit(EXIT_FAILURE);
+ }
+ break;
+ default:
+ return(ARGP_ERR_UNKNOWN);
+ }
+
+ return 0;
+}
+
+static struct argp argp = {
+ options: options,
+ parser: parse_opt,
+ args_doc: 0,
+ doc: doc,
+ children: NULL,
+ help_filter: NULL,
+ argp_domain: NULL,
+};
+
+static int
+process_page(uint8_t* buf, size_t pagesize,
+ FILE *fp_data, FILE* fp_oob, size_t* written)
+{
+ int eccpoi, oobsize;
+ size_t i;
+ uint8_t oobbuf[64];
+
+ memset(oobbuf, 0xff, sizeof(oobbuf));
+
+ switch(pagesize) {
+ case 2048: oobsize = 64; eccpoi = 64 / 2; break;
+ case 512: oobsize = 16; eccpoi = 16 / 2; break;
+ default:
+ err_msg("Unsupported page size: %d\n", pagesize);
+ return -EINVAL;
+ }
+
+ for (i = 0; i < pagesize; i += 256, eccpoi += 3) {
+ oobbuf[eccpoi++] = 0x0;
+ /* Calculate ECC */
+ nand_calculate_ecc(&buf[i], &oobbuf[eccpoi]);
+ }
+
+ /* write data */
+ *written += fwrite(buf, 1, pagesize, fp_data);
+
+ /* either separate oob or interleave with data */
+ if (fp_oob) {
+ fwrite(oobbuf, 1, oobsize, fp_oob);
+ if (ferror(fp_oob)) {
+ err_msg("IO error\n");
+ return -EIO;
+ }
+ }
+ else {
+ fwrite(oobbuf, 1, oobsize, fp_data);
+ if (ferror(fp_data)) {
+ err_msg("IO error\n");
+ return -EIO;
+ }
+ }
+
+ return 0;
+}
+
+int main (int argc, char** argv)
+{
+ int rc = -1;
+ int res = 0;
+ size_t written, read;
+ myargs args = {
+ .action = ACT_NORMAL,
+ .pagesize = PAGESIZE,
+ .padding = PADDING,
+ .fp_in = NULL,
+ .file_out_data = "",
+ .file_out_oob = "",
+ };
+
+ FILE* fp_out_data = stdout;
+ FILE* fp_out_oob = NULL;
+
+ argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, &args);
+
+ uint8_t* buf = calloc(1, BUFSIZE);
+ if (!buf) {
+ err_quit("Cannot allocate page buffer.\n");
+ }
+
+ if (!args.fp_in) {
+ err_msg("No input image specified!\n");
+ goto err;
+ }
+
+ if (strcmp(args.file_out_data, "") != 0) {
+ fp_out_data = fopen(args.file_out_data, "wb");
+ if (fp_out_data == NULL) {
+ err_sys("Cannot open file %s for output\n",
+ args.file_out_data);
+ goto err;
+ }
+ }
+
+ if (strcmp(args.file_out_oob, "") != 0) {
+ fp_out_oob = fopen(args.file_out_oob, "wb");
+ if (fp_out_oob == NULL) {
+ err_sys("Cannot open file %s for output\n",
+ args.file_out_oob);
+ goto err;
+ }
+ }
+
+
+ while(1) {
+ read = fread(buf, 1, args.pagesize, args.fp_in);
+ if (feof(args.fp_in) && read == 0)
+ break;
+
+ if (read < args.pagesize) {
+ err_msg("Image not page aligned\n");
+ goto err;
+ }
+
+ if (ferror(args.fp_in)) {
+ err_msg("Read error\n");
+ goto err;
+ }
+
+ res = process_page(buf, args.pagesize, fp_out_data,
+ fp_out_oob, &written);
+ if (res != 0)
+ goto err;
+ }
+
+ while (written < args.padding) {
+ memset(buf, 0xff, args.pagesize);
+ res = process_page(buf, args.pagesize, fp_out_data,
+ fp_out_oob, &written);
+ if (res != 0)
+ goto err;
+ }
+
+ rc = 0;
+err:
+ free(buf);
+
+ if (args.fp_in)
+ fclose(args.fp_in);
+
+ if (fp_out_oob)
+ fclose(fp_out_oob);
+
+ if (fp_out_data && fp_out_data != stdout)
+ fclose(fp_out_data);
+
+ if (rc != 0) {
+ err_msg("Error during conversion. rc: %d\n", rc);
+ remove(args.file_out_data);
+ remove(args.file_out_oob);
+ }
+ return rc;
+}
diff --git a/ubi-utils/src/bin2nand/nandecc.c b/ubi-utils/src/bin2nand/nandecc.c
new file mode 100644
index 0000000..71660ef
--- /dev/null
+++ b/ubi-utils/src/bin2nand/nandecc.c
@@ -0,0 +1,159 @@
+/*
+ * This file contains an ECC algorithm from Toshiba that detects and
+ * corrects 1 bit errors in a 256 byte block of data.
+ *
+ * drivers/mtd/nand/nand_ecc.c
+ *
+ * Copyright (C) 2000-2004 Steven J. Hill (sjhill@realitydiluted.com)
+ * Toshiba America Electronics Components, Inc.
+ *
+ * This file is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 or (at your option) any
+ * later version.
+ *
+ * This file is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this file; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * As a special exception, if other files instantiate templates or use
+ * macros or inline functions from these files, or you compile these
+ * files and link them with other works to produce a work based on these
+ * files, these files do not by themselves cause the resulting work to be
+ * covered by the GNU General Public License. However the source code for
+ * these files must still be made available in accordance with section (3)
+ * of the GNU General Public License.
+ *
+ * This exception does not invalidate any other reasons why a work based on
+ * this file might be covered by the GNU General Public License.
+ */
+
+#include "nandecc.h"
+
+/*
+ * Pre-calculated 256-way 1 byte column parity
+ */
+static const uint8_t nand_ecc_precalc_table[] = {
+ 0x00, 0x55, 0x56, 0x03, 0x59, 0x0c, 0x0f, 0x5a,
+ 0x5a, 0x0f, 0x0c, 0x59, 0x03, 0x56, 0x55, 0x00,
+ 0x65, 0x30, 0x33, 0x66, 0x3c, 0x69, 0x6a, 0x3f,
+ 0x3f, 0x6a, 0x69, 0x3c, 0x66, 0x33, 0x30, 0x65,
+ 0x66, 0x33, 0x30, 0x65, 0x3f, 0x6a, 0x69, 0x3c,
+ 0x3c, 0x69, 0x6a, 0x3f, 0x65, 0x30, 0x33, 0x66,
+ 0x03, 0x56, 0x55, 0x00, 0x5a, 0x0f, 0x0c, 0x59,
+ 0x59, 0x0c, 0x0f, 0x5a, 0x00, 0x55, 0x56, 0x03,
+ 0x69, 0x3c, 0x3f, 0x6a, 0x30, 0x65, 0x66, 0x33,
+ 0x33, 0x66, 0x65, 0x30, 0x6a, 0x3f, 0x3c, 0x69,
+ 0x0c, 0x59, 0x5a, 0x0f, 0x55, 0x00, 0x03, 0x56,
+ 0x56, 0x03, 0x00, 0x55, 0x0f, 0x5a, 0x59, 0x0c,
+ 0x0f, 0x5a, 0x59, 0x0c, 0x56, 0x03, 0x00, 0x55,
+ 0x55, 0x00, 0x03, 0x56, 0x0c, 0x59, 0x5a, 0x0f,
+ 0x6a, 0x3f, 0x3c, 0x69, 0x33, 0x66, 0x65, 0x30,
+ 0x30, 0x65, 0x66, 0x33, 0x69, 0x3c, 0x3f, 0x6a,
+ 0x6a, 0x3f, 0x3c, 0x69, 0x33, 0x66, 0x65, 0x30,
+ 0x30, 0x65, 0x66, 0x33, 0x69, 0x3c, 0x3f, 0x6a,
+ 0x0f, 0x5a, 0x59, 0x0c, 0x56, 0x03, 0x00, 0x55,
+ 0x55, 0x00, 0x03, 0x56, 0x0c, 0x59, 0x5a, 0x0f,
+ 0x0c, 0x59, 0x5a, 0x0f, 0x55, 0x00, 0x03, 0x56,
+ 0x56, 0x03, 0x00, 0x55, 0x0f, 0x5a, 0x59, 0x0c,
+ 0x69, 0x3c, 0x3f, 0x6a, 0x30, 0x65, 0x66, 0x33,
+ 0x33, 0x66, 0x65, 0x30, 0x6a, 0x3f, 0x3c, 0x69,
+ 0x03, 0x56, 0x55, 0x00, 0x5a, 0x0f, 0x0c, 0x59,
+ 0x59, 0x0c, 0x0f, 0x5a, 0x00, 0x55, 0x56, 0x03,
+ 0x66, 0x33, 0x30, 0x65, 0x3f, 0x6a, 0x69, 0x3c,
+ 0x3c, 0x69, 0x6a, 0x3f, 0x65, 0x30, 0x33, 0x66,
+ 0x65, 0x30, 0x33, 0x66, 0x3c, 0x69, 0x6a, 0x3f,
+ 0x3f, 0x6a, 0x69, 0x3c, 0x66, 0x33, 0x30, 0x65,
+ 0x00, 0x55, 0x56, 0x03, 0x59, 0x0c, 0x0f, 0x5a,
+ 0x5a, 0x0f, 0x0c, 0x59, 0x03, 0x56, 0x55, 0x00
+};
+
+/**
+ * nand_trans_result - [GENERIC] create non-inverted ECC
+ * @reg2: line parity reg 2
+ * @reg3: line parity reg 3
+ * @ecc_code: ecc
+ *
+ * Creates non-inverted ECC code from line parity
+ */
+static void nand_trans_result(uint8_t reg2, uint8_t reg3,
+ uint8_t *ecc_code)
+{
+ uint8_t a, b, i, tmp1, tmp2;
+
+ /* Initialize variables */
+ a = b = 0x80;
+ tmp1 = tmp2 = 0;
+
+ /* Calculate first ECC byte */
+ for (i = 0; i < 4; i++) {
+ if (reg3 & a) /* LP15,13,11,9 --> ecc_code[0] */
+ tmp1 |= b;
+ b >>= 1;
+ if (reg2 & a) /* LP14,12,10,8 --> ecc_code[0] */
+ tmp1 |= b;
+ b >>= 1;
+ a >>= 1;
+ }
+
+ /* Calculate second ECC byte */
+ b = 0x80;
+ for (i = 0; i < 4; i++) {
+ if (reg3 & a) /* LP7,5,3,1 --> ecc_code[1] */
+ tmp2 |= b;
+ b >>= 1;
+ if (reg2 & a) /* LP6,4,2,0 --> ecc_code[1] */
+ tmp2 |= b;
+ b >>= 1;
+ a >>= 1;
+ }
+
+ /* Store two of the ECC bytes */
+ ecc_code[1] = tmp1;
+ ecc_code[0] = tmp2;
+}
+
+/**
+ * nand_calculate_ecc - [NAND Interface] Calculate 3 byte ECC code for
+ * 256 byte block
+ *
+ * @dat: raw data
+ * @ecc_code: buffer for ECC
+ */
+int nand_calculate_ecc(const uint8_t *dat, uint8_t *ecc_code)
+{
+ uint8_t idx, reg1, reg2, reg3;
+ int j;
+
+ /* Initialize variables */
+ reg1 = reg2 = reg3 = 0;
+ ecc_code[0] = ecc_code[1] = ecc_code[2] = 0;
+
+ /* Build up column parity */
+ for(j = 0; j < 256; j++) {
+
+ /* Get CP0 - CP5 from table */
+ idx = nand_ecc_precalc_table[dat[j]];
+ reg1 ^= (idx & 0x3f);
+
+ /* All bit XOR = 1 ? */
+ if (idx & 0x40) {
+ reg3 ^= (uint8_t) j;
+ reg2 ^= ~((uint8_t) j);
+ }
+ }
+
+ /* Create non-inverted ECC code from line parity */
+ nand_trans_result(reg2, reg3, ecc_code);
+
+ /* Calculate final ECC code */
+ ecc_code[0] = ~ecc_code[0];
+ ecc_code[1] = ~ecc_code[1];
+ ecc_code[2] = ((~reg1) << 2) | 0x03;
+ return 0;
+}
diff --git a/ubi-utils/src/bin2nand/nandecc.h b/ubi-utils/src/bin2nand/nandecc.h
new file mode 100644
index 0000000..8ae8a66
--- /dev/null
+++ b/ubi-utils/src/bin2nand/nandecc.h
@@ -0,0 +1,11 @@
+/*
+ * NAND ecc functions
+ */
+#ifndef _NAND_ECC_H
+#define _NAND_ECC_H
+
+#include <stdint.h>
+
+extern int nand_calculate_ecc(const uint8_t *dat, uint8_t *ecc_code);
+
+#endif
diff --git a/ubi-utils/src/libbootenv/bootenv.c b/ubi-utils/src/libbootenv/bootenv.c
new file mode 100644
index 0000000..b6a1191
--- /dev/null
+++ b/ubi-utils/src/libbootenv/bootenv.c
@@ -0,0 +1,959 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Oliver Lohmann
+ */
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <netinet/in.h>
+#include <sys/stat.h>
+#include <bootenv.h>
+
+#include "hashmap.h"
+#include "error.h"
+
+#define BOOTENV_MAXLINE 512 /* max line size of a bootenv.txt file */
+
+/* Structures */
+struct bootenv {
+ hashmap_t map; ///< Pointer to hashmap which holds data structure.
+};
+
+struct bootenv_list {
+ hashmap_t head; ///< Pointer to list which holds the data structure.
+};
+
+/**
+ * @brief Remove the '\n' from a given line.
+ * @param line Input/Output line.
+ * @param size Size of the line.
+ * @param fp File Pointer.
+ * @return 0
+ * @return or error
+ */
+static int
+remove_lf(char *line, size_t size, FILE* fp)
+{
+ size_t i;
+
+ for (i = 0; i < size; i++) {
+ if (line[i] == '\n') {
+ line[i] = '\0';
+ return 0;
+ }
+ }
+
+ if (!feof(fp)) {
+ return BOOTENV_EINVAL;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Determine if a line contains only WS.
+ * @param line The line to process.
+ * @param size Size of input line.
+ * @return 1 Yes, only WS.
+ * @return 0 No, contains data.
+ */
+static int
+is_ws(const char *line, size_t size)
+{
+ size_t i = 0;
+
+ while (i < size) {
+ switch (line[i]) {
+ case '\n':
+ return 1;
+ case '#':
+ return 1;
+ case ' ':
+ i++;
+ continue;
+ case '\t':
+ i++;
+ continue;
+ default: /* any other char -> no cmnt */
+ return 0;
+ }
+ }
+
+ return 0;
+}
+
+
+/* ------------------------------------------------------------------------- */
+
+/**
+ * @brief Build a list from a comma seperated value string.
+ * @param list Pointer to hashmap structure which shall store
+ * the list.
+ * @param value Comma seperated value string.
+ * @return 0
+ * @return or error.
+ */
+static int
+build_list_definition(hashmap_t list, const char *value)
+{
+ int rc = 0;
+ char *str = NULL;
+ char *ptr = NULL;
+ size_t len, i, j;
+
+ /* str: val1,val2 , val4,...,valN */
+ len = strlen(value);
+ str = (char*) malloc((len+1) * sizeof(char));
+
+ /* 1. reformat string: remove spaces */
+ for (i = 0, j = 0; i < len; i++) {
+ if (value[i] == ' ')
+ continue;
+
+ str[j] = value[i];
+ j++;
+ }
+ str[j] = '\0';
+
+ /* str: val1,val2,val4,...,valN\0*/
+ /* 2. replace ',' seperator with '\0' */
+ len = strlen(str);
+ for (i = 0; i < len; i++) {
+ if (str[i] == ',') {
+ str[i] = '\0';
+ }
+ }
+
+ /* str: val1\0val2\0val4\0...\0valN\0*/
+ /* 3. insert definitions into a hash map, using it like a list */
+ i = j = 0;
+ ptr = str;
+ while (((i = strlen(ptr)) > 0) && (j < len)) {
+ rc = hashmap_add(list, ptr, "");
+ if (rc != 0) {
+ free(str);
+ return rc;
+ }
+ j += i+1;
+ if (j < len)
+ ptr += i+1;
+ }
+
+ free(str);
+ return rc;
+}
+
+/**
+ * @brief Extract a key value pair and add it to a hashmap
+ * @param str Input string which contains a key value pair.
+ * @param env The updated handle which contains the new pair.
+ * @return 0
+ * @return or error
+ * @note The input string format is: "key=value"
+ */
+static int
+extract_pair(const char *str, bootenv_t env)
+{
+ int rc = 0;
+ char *key = NULL;
+ char *val = NULL;
+
+ key = strdup(str);
+ if (key == NULL)
+ return -ENOMEM;
+
+ val = strstr(key, "=");
+ if (val == NULL) {
+ rc = BOOTENV_EBADENTRY;
+ goto err;
+ }
+
+ *val = '\0'; /* split strings */
+ val++;
+ rc = bootenv_set(env, key, val);
+
+err:
+ free(key);
+ return rc;
+}
+
+int
+bootenv_destroy(bootenv_t* env)
+{
+ int rc = 0;
+
+ if (env == NULL || *env == NULL)
+ return -EINVAL;
+
+ bootenv_t tmp = *env;
+
+ rc = hashmap_free(tmp->map);
+ if (rc != 0)
+ return rc;
+
+ free(tmp);
+ return rc;
+}
+
+int
+bootenv_create(bootenv_t* env)
+{
+ bootenv_t res;
+ res = (bootenv_t) calloc(1, sizeof(struct bootenv));
+
+ if (res == NULL)
+ return -ENOMEM;
+
+ res->map = hashmap_new();
+
+ if (res->map == NULL) {
+ free(res);
+ return -ENOMEM;
+ }
+
+ *env = res;
+
+ return 0;
+}
+
+
+/**
+ * @brief Read a formatted buffer and scan it for valid bootenv
+ * key/value pairs. Add those pairs into a hashmap.
+ * @param env Hashmap which shall be used to hold the data.
+ * @param buf Formatted buffer.
+ * @param size Size of the buffer.
+ * @return 0
+ * @return or error
+ */
+static int
+rd_buffer(bootenv_t env, const char *buf, size_t size)
+{
+ const char *curr = buf; /* ptr to current key/value pair */
+ uint32_t i = 0; /* current length */
+ uint32_t j = 0; /* processed chars */
+ uint32_t items = 0; /* processed items */
+ int rc = 0;
+
+ if (buf[size-1] != '\0') {
+ return BOOTENV_EFMT;
+ }
+
+ while ((i = strlen(curr)) != 0) {
+ /* there is a key value pair remaining */
+ rc = extract_pair(curr, env);
+ if (rc != 0) {
+ rc = BOOTENV_EINVAL;
+ return rc;
+ }
+ items++;
+
+ j += i;
+ if (j >= size)
+ return 0; /* finished, end of buffer */
+ curr += i + 1;
+ }
+
+ return 0;
+}
+
+/**
+ * If we have a single file containing the boot-parameter size should
+ * be specified either as the size of the file or as BOOTENV_MAXSIZE.
+ * If the bootparameter are in the middle of a file we need the exact
+ * length of the data.
+ */
+int
+bootenv_read(FILE* fp, bootenv_t env, size_t size)
+{
+ int rc;
+ char *buf = NULL;
+ size_t i = 0;
+
+ if ((fp == NULL) || (env == NULL))
+ return -EINVAL;
+
+ /* allocate temp buffer */
+ buf = (char*) calloc(1, size * sizeof(char));
+ if (buf == NULL)
+ return -ENOMEM;
+
+ /* FIXME Andreas, please review this I removed size-1 and
+ * replaced it by just size, I saw the kernel image starting
+ * with a 0x0060.... and not with the 0x60.... what it should
+ * be. Is this a tools problem or is it a problem here where
+ * fp is moved not to the right place due to the former size-1
+ * here.
+ */
+ while((i < size) && (!feof(fp))) {
+ int c = fgetc(fp);
+
+ if (c == EOF) {
+ buf[i++] = '\0';
+ break; /* we have enough */
+ }
+
+ /* log_msg("%c", c); */ /* FIXME DBG */
+
+ buf[i++] = c;
+ if (ferror(fp)) {
+ rc = -EIO;
+ goto err;
+ }
+ }
+
+ /* transfer to hashmap */
+ rc = rd_buffer(env, buf, size);
+
+ /* FIXME DBG */
+ /* log_msg("\n%s:%d rc=%d\n", __func__, __LINE__, rc); */
+
+err:
+ free(buf);
+ return rc;
+}
+
+
+
+int
+bootenv_read_txt(FILE* fp, bootenv_t env)
+{
+ int rc = 0;
+ char *buf = NULL;
+ char *line = NULL;
+ char *lstart = NULL;
+ char *curr = NULL;
+ size_t len;
+ size_t size;
+
+ if ((fp == NULL) || (env == NULL))
+ return -EINVAL;
+
+ size = BOOTENV_MAXSIZE;
+
+ /* allocate temp buffers */
+ buf = (char*) calloc(1, size * sizeof(char));
+ lstart = line = (char*) calloc(1, size * sizeof(char));
+ if ((buf == NULL) || (line == NULL)) {
+ rc = -ENOMEM;
+ goto err;
+ }
+
+ curr = buf;
+ while ((line = fgets(line, size, fp)) != NULL) {
+ if (is_ws(line, size)) {
+ continue;
+ }
+ rc = remove_lf(line, BOOTENV_MAXSIZE, fp);
+ if (rc != 0) {
+ goto err;
+ }
+
+ /* copy new line to binary buffer */
+ len = strlen(line);
+ if (len > size) {
+ rc = -EFBIG;
+ goto err;
+ }
+ size -= len; /* track remaining space */
+
+ memcpy(curr, line, len);
+ curr += len + 1; /* for \0 seperator */
+ }
+
+ rc = rd_buffer(env, buf, BOOTENV_MAXSIZE);
+err:
+ if (buf != NULL)
+ free(buf);
+ if (lstart != NULL)
+ free(lstart);
+ return rc;
+}
+
+static int
+fill_output_buffer(bootenv_t env, char *buf, size_t buf_size_max,
+ size_t *written)
+{
+ int rc = 0;
+ size_t keys_size, i;
+ size_t wr = 0;
+ const char **keys = NULL;
+ const char *val = NULL;
+
+ rc = bootenv_get_key_vector(env, &keys_size, 1, &keys);
+ if (rc != 0)
+ goto err;
+
+ for (i = 0; i < keys_size; i++) {
+ if (wr > BOOTENV_MAXSIZE) {
+ rc = -ENOSPC;
+ goto err;
+ }
+
+ rc = bootenv_get(env, keys[i], &val);
+ if (rc != 0)
+ goto err;
+
+ wr += snprintf(buf + wr, BOOTENV_MAXSIZE - wr,
+ "%s=%s", keys[i], val);
+ wr++; /* for \0 */
+ }
+
+ *written = wr;
+
+err:
+ if (keys != NULL)
+ free(keys);
+
+ return rc;
+}
+
+int
+bootenv_write(FILE* fp, bootenv_t env)
+{
+ int rc = 0;
+ size_t size = 0;
+ char *buf = NULL;
+
+ if ((fp == NULL) || (env == NULL))
+ return -EINVAL;
+
+ buf = (char*) calloc(1, BOOTENV_MAXSIZE * sizeof(char));
+ if (buf == NULL)
+ return -ENOMEM;
+
+ rc = fill_output_buffer(env, buf, BOOTENV_MAXSIZE, &size);
+ if (rc != 0)
+ goto err;
+
+ if (fwrite(buf, size, 1, fp) != 1) {
+ rc = -EIO;
+ goto err;
+ }
+
+err:
+ if (buf != NULL)
+ free(buf);
+ return rc;
+}
+
+int
+bootenv_size(bootenv_t env, size_t *size)
+{
+ int rc = 0;
+ char *buf = NULL;
+
+ if (env == NULL)
+ return -EINVAL;
+
+ buf = (char*) calloc(1, BOOTENV_MAXSIZE * sizeof(char));
+ if (buf == NULL)
+ return -ENOMEM;
+
+ rc = fill_output_buffer(env, buf, BOOTENV_MAXSIZE, size);
+ if (rc != 0)
+ goto err;
+
+err:
+ if (buf != NULL)
+ free(buf);
+ return rc;
+}
+
+int
+bootenv_write_txt(FILE* fp, bootenv_t env)
+{
+ int rc = 0;
+ size_t size, wr, i;
+ const char **keys = NULL;
+ const char *key = NULL;
+ const char *val = NULL;
+
+ if ((fp == NULL) || (env == NULL))
+ return -EINVAL;
+
+ rc = bootenv_get_key_vector(env, &size, 1, &keys);
+ if (rc != 0)
+ goto err;
+
+ for (i = 0; i < size; i++) {
+ key = keys[i];
+ rc = bootenv_get(env, key, &val);
+ if (rc != 0)
+ goto err;
+
+ wr = fprintf(fp, "%s=%s\n", key, val);
+ if (wr != strlen(key) + strlen(val) + 2) {
+ rc = -EIO;
+ goto err;
+ }
+ }
+
+err:
+ if (keys != NULL)
+ free(keys);
+ return rc;
+}
+
+int
+bootenv_valid(bootenv_t env)
+{
+ /* @FIXME No sanity check implemented. */
+ return 0;
+}
+
+int
+bootenv_copy_bootenv(bootenv_t in, bootenv_t *out)
+{
+ int rc = 0;
+ const char *tmp = NULL;
+ const char **keys = NULL;
+ size_t vec_size, i;
+
+ if ((in == NULL) || (out == NULL))
+ return -EINVAL;
+
+ /* purge output var for sure... */
+ rc = bootenv_destroy(out);
+ if (rc != 0)
+ return rc;
+
+ /* create the new map */
+ rc = bootenv_create(out);
+ if (rc != 0)
+ goto err;
+
+ /* get the key list from the input map */
+ rc = bootenv_get_key_vector(in, &vec_size, 0, &keys);
+ if (rc != 0)
+ goto err;
+
+ if (vec_size != hashmap_size(in->map)) {
+ rc = BOOTENV_ECOPY;
+ goto err;
+ }
+
+ /* make a deep copy of the hashmap */
+ for (i = 0; i < vec_size; i++) {
+ rc = bootenv_get(in, keys[i], &tmp);
+ if (rc != 0)
+ goto err;
+
+ rc = bootenv_set(*out, keys[i], tmp);
+ if (rc != 0)
+ goto err;
+ }
+
+err:
+ if (keys != NULL)
+ free(keys);
+
+ return rc;
+}
+
+/* ------------------------------------------------------------------------- */
+
+
+int
+bootenv_pdd_keep(bootenv_t env_old, bootenv_t env_new, bootenv_t *env_res,
+ int *warnings, char *err_buf, size_t err_buf_size)
+{
+ bootenv_list_t l_old = NULL;
+ bootenv_list_t l_new = NULL;
+ const char *pdd_old = NULL;
+ const char *pdd_new = NULL;
+ const char *tmp = NULL;
+ const char **vec_old = NULL;
+ const char **vec_new = NULL;
+ const char **pdd_up_vec = NULL;
+ size_t vec_old_size, vec_new_size, pdd_up_vec_size, i;
+ int rc = 0;
+
+ if ((env_old == NULL) || (env_new == NULL) || (env_res == NULL))
+ return -EINVAL;
+
+ /* get the pdd strings, e.g.:
+ * pdd_old=a,b,c
+ * pdd_new=a,c,d,e */
+ rc = bootenv_get(env_old, "pdd", &pdd_old);
+ if (rc != 0)
+ goto err;
+ rc = bootenv_get(env_new, "pdd", &pdd_new);
+ if (rc != 0)
+ goto err;
+
+ /* put it into a list and then convert it to an vector */
+ rc = bootenv_list_create(&l_old);
+ if (rc != 0)
+ goto err;
+ rc = bootenv_list_create(&l_new);
+ if (rc != 0)
+ goto err;
+
+ rc = bootenv_list_import(l_old, pdd_old);
+ if (rc != 0)
+ goto err;
+
+ rc = bootenv_list_import(l_new, pdd_new);
+ if (rc != 0)
+ goto err;
+
+ rc = bootenv_list_to_vector(l_old, &vec_old_size, &vec_old);
+ if (rc != 0)
+ goto err;
+
+ rc = bootenv_list_to_vector(l_new, &vec_new_size, &vec_new);
+ if (rc != 0)
+ goto err;
+
+ rc = bootenv_copy_bootenv(env_new, env_res);
+ if (rc != 0)
+ goto err;
+
+ /* calculate the update vector between the old and new pdd */
+ pdd_up_vec = hashmap_get_update_key_vector(vec_old, vec_old_size,
+ vec_new, vec_new_size, &pdd_up_vec_size);
+
+ if (pdd_up_vec == NULL) {
+ rc = -ENOMEM;
+ goto err;
+ }
+
+ if (pdd_up_vec_size != 0) {
+ /* need to warn the user about the unset of
+ * some pdd/bootenv values */
+ *warnings = BOOTENV_WPDD_STRING_DIFFERS;
+
+ /* remove all entries in the new bootenv load */
+ for (i = 0; i < pdd_up_vec_size; i++) {
+ bootenv_unset(*env_res, pdd_up_vec[i]);
+ }
+ }
+
+ /* generate the keep array and copy old pdd values to new bootenv */
+ for (i = 0; i < vec_old_size; i++) {
+ rc = bootenv_get(env_old, vec_old[i], &tmp);
+ if (rc != 0) {
+ rc = BOOTENV_EPDDINVAL;
+ goto err;
+ }
+ rc = bootenv_set(*env_res, vec_old[i], tmp);
+ if (rc != 0) {
+ goto err;
+ }
+ }
+ /* put the old pdd string into the result map */
+ rc = bootenv_set(*env_res, "pdd", pdd_old);
+ if (rc != 0) {
+ goto err;
+ }
+
+
+err:
+ if (vec_old != NULL)
+ free(vec_old);
+ if (vec_new != NULL)
+ free(vec_new);
+ if (pdd_up_vec != NULL)
+ free(pdd_up_vec);
+
+ bootenv_list_destroy(&l_old);
+ bootenv_list_destroy(&l_new);
+ return rc;
+}
+
+
+int
+bootenv_pdd_overwrite(bootenv_t env_old, bootenv_t env_new,
+ bootenv_t *env_res, int *warnings,
+ char *err_buf, size_t err_buf_size)
+{
+ if ((env_old == NULL) || (env_new == NULL) || (env_res == NULL))
+ return -EINVAL;
+
+ return bootenv_copy_bootenv(env_new, env_res);
+}
+
+int
+bootenv_pdd_merge(bootenv_t env_old, bootenv_t env_new, bootenv_t *env_res,
+ int *warnings, char *err_buf, size_t err_buf_size)
+{
+ if ((env_old == NULL) || (env_new == NULL) || (env_res == NULL))
+ return -EINVAL;
+
+ snprintf(err_buf, err_buf_size, "The PDD merge operation is not "
+ "implemented. Contact: <oliloh@de.ibm.com>");
+
+ return BOOTENV_ENOTIMPL;
+}
+
+/* ------------------------------------------------------------------------- */
+
+int
+bootenv_get(bootenv_t env, const char *key, const char **value)
+{
+ if (env == NULL)
+ return -EINVAL;
+
+ *value = hashmap_lookup(env->map, key);
+ if (*value == NULL)
+ return BOOTENV_ENOTFOUND;
+
+ return 0;
+}
+
+int
+bootenv_get_num(bootenv_t env, const char *key, uint32_t *value)
+{
+ char *endptr = NULL;
+ const char *str;
+
+ if (env == NULL)
+ return 0;
+
+ str = hashmap_lookup(env->map, key);
+ if (!str)
+ return -EINVAL;
+
+ *value = strtoul(str, &endptr, 0);
+
+ if (*endptr == '\0') {
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+int
+bootenv_set(bootenv_t env, const char *key, const char *value)
+{
+ if (env == NULL)
+ return -EINVAL;
+
+ return hashmap_add(env->map, key, value);
+}
+
+int
+bootenv_unset(bootenv_t env, const char *key)
+{
+ if (env == NULL)
+ return -EINVAL;
+
+ return hashmap_remove(env->map, key);
+}
+
+int
+bootenv_get_key_vector(bootenv_t env, size_t* size, int sort,
+ const char ***vector)
+{
+ if ((env == NULL) || (size == NULL))
+ return -EINVAL;
+
+ *vector = hashmap_get_key_vector(env->map, size, sort);
+
+ if (*vector == NULL)
+ return -EINVAL;
+
+ return 0;
+}
+
+int
+bootenv_dump(bootenv_t env)
+{
+ if (env == NULL)
+ return -EINVAL;
+
+ return hashmap_dump(env->map);
+}
+
+int
+bootenv_list_create(bootenv_list_t *list)
+{
+ bootenv_list_t res;
+ res = (bootenv_list_t) calloc(1, sizeof(struct bootenv_list));
+
+ if (res == NULL)
+ return -ENOMEM;
+
+ res->head = hashmap_new();
+
+ if (res->head == NULL) {
+ free(res);
+ return -ENOMEM;
+ }
+
+ *list = res;
+ return 0;
+}
+
+int
+bootenv_list_destroy(bootenv_list_t *list)
+{
+ int rc = 0;
+
+ if (list == NULL)
+ return -EINVAL;
+
+ bootenv_list_t tmp = *list;
+ if (tmp == 0)
+ return 0;
+
+ rc = hashmap_free(tmp->head);
+ if (rc != 0)
+ return rc;
+
+ free(tmp);
+ *list = NULL;
+ return 0;
+}
+
+int
+bootenv_list_import(bootenv_list_t list, const char *str)
+{
+ if (list == NULL)
+ return -EINVAL;
+
+ return build_list_definition(list->head, str);
+}
+
+int
+bootenv_list_export(bootenv_list_t list, char **string)
+{
+ size_t size, i, j, bufsize, tmp, rc = 0;
+ const char **items;
+
+ if (list == NULL)
+ return -EINVAL;
+
+ bufsize = BOOTENV_MAXLINE;
+ char *res = (char*) malloc(bufsize * sizeof(char));
+ if (res == NULL)
+ return -ENOMEM;
+
+ rc = bootenv_list_to_vector(list, &size, &items);
+ if (rc != 0) {
+ goto err;
+ }
+
+ j = 0;
+ for (i = 0; i < size; i++) {
+ tmp = strlen(items[i]);
+ if (j >= bufsize) {
+ bufsize += BOOTENV_MAXLINE;
+ res = (char*) realloc(res, bufsize * sizeof(char));
+ if (res == NULL) {
+ rc = -ENOMEM;
+ goto err;
+ }
+ }
+ memcpy(res + j, items[i], tmp);
+ j += tmp;
+ if (i < (size - 1)) {
+ res[j] = ',';
+ j++;
+ }
+ }
+ j++;
+ res[j] = '\0';
+ free(items);
+ *string = res;
+ return 0;
+err:
+ free(items);
+ return rc;
+}
+
+int
+bootenv_list_add(bootenv_list_t list, const char *item)
+{
+ if ((list == NULL) || (item == NULL))
+ return -EINVAL;
+
+ return hashmap_add(list->head, item, "");
+}
+
+int
+bootenv_list_remove(bootenv_list_t list, const char *item)
+{
+ if ((list == NULL) || (item == NULL))
+ return -EINVAL;
+
+ return hashmap_remove(list->head, item);
+}
+
+int
+bootenv_list_is_in(bootenv_list_t list, const char *item)
+{
+ if ((list == NULL) || (item == NULL))
+ return -EINVAL;
+
+ return hashmap_lookup(list->head, item) != NULL ? 1 : 0;
+}
+
+int
+bootenv_list_to_vector(bootenv_list_t list, size_t *size, const char ***vector)
+{
+ if ((list == NULL) || (size == NULL))
+ return -EINVAL;
+
+ *vector = hashmap_get_key_vector(list->head, size, 1);
+ if (*vector == NULL)
+ return -ENOMEM;
+
+ return 0;
+}
+
+int
+bootenv_list_to_num_vector(bootenv_list_t list, size_t *size,
+ uint32_t **vector)
+{
+ int rc = 0;
+ size_t i;
+ uint32_t* res = NULL;
+ char *endptr = NULL;
+ const char **a = NULL;
+
+ rc = bootenv_list_to_vector(list, size, &a);
+ if (rc != 0)
+ goto err;
+
+ res = (uint32_t*) malloc (*size * sizeof(uint32_t));
+ if (!res)
+ goto err;
+
+ for (i = 0; i < *size; i++) {
+ res[i] = strtoul(a[i], &endptr, 0);
+ if (*endptr != '\0')
+ goto err;
+ }
+
+ if (a)
+ free(a);
+ *vector = res;
+ return 0;
+
+err:
+ if (a)
+ free(a);
+ if (res)
+ free(res);
+ return rc;
+}
diff --git a/ubi-utils/src/libbootenv/hashmap.c b/ubi-utils/src/libbootenv/hashmap.c
new file mode 100644
index 0000000..250f71f
--- /dev/null
+++ b/ubi-utils/src/libbootenv/hashmap.c
@@ -0,0 +1,412 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Oliver Lohmann
+ */
+
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "error.h"
+#include "hashmap.h"
+#define DEFAULT_BUCKETS 4096
+
+#if 0
+#define INFO_MSG(fmt...) do { \
+ info_msg(fmt); \
+} while (0)
+#else
+#define INFO_MSG(fmt...)
+#endif
+
+struct hashentry {
+ char* key; /* key '0' term. str */
+ char* value; /* payload '0' term. str */
+
+ hashentry_t next;
+};
+
+struct hashmap {
+ size_t entries; /* current #entries */
+ size_t maxsize; /* no. of hash buckets */
+ hashentry_t* data; /* array of buckets */
+};
+
+static int
+is_empty(hashentry_t l)
+{
+ return l == NULL ? 1 : 0;
+}
+
+hashmap_t
+hashmap_new(void)
+{
+ hashmap_t res;
+ res = (hashmap_t) calloc(1, sizeof(struct hashmap));
+
+ if (res == NULL)
+ return NULL;
+
+ res->maxsize = DEFAULT_BUCKETS;
+ res->entries = 0;
+
+ res->data = (hashentry_t*)
+ calloc(1, res->maxsize * sizeof(struct hashentry));
+
+ if (res->data == NULL)
+ return NULL;
+
+ return res;
+}
+
+static hashentry_t
+new_entry(const char* key, const char* value)
+{
+ hashentry_t res;
+
+ res = (hashentry_t) calloc(1, sizeof(struct hashentry));
+
+ if (res == NULL)
+ return NULL;
+
+ /* allocate key and value and copy them */
+ res->key = strdup(key);
+ if (res->key == NULL) {
+ free(res);
+ return NULL;
+ }
+
+ res->value = strdup(value);
+ if (res->value == NULL) {
+ free(res->key);
+ free(res);
+ return NULL;
+ }
+
+ res->next = NULL;
+
+ return res;
+}
+
+static hashentry_t
+free_entry(hashentry_t e)
+{
+ if (!is_empty(e)) {
+ if(e->key != NULL) {
+ free(e->key);
+ }
+ if(e->value != NULL)
+ free(e->value);
+ free(e);
+ }
+
+ return NULL;
+}
+
+static hashentry_t
+remove_entry(hashentry_t l, const char* key, size_t* entries)
+{
+ hashentry_t lnext;
+ if (is_empty(l))
+ return NULL;
+
+ if(strcmp(l->key,key) == 0) {
+ lnext = l->next;
+ l = free_entry(l);
+ (*entries)--;
+ return lnext;
+ }
+
+ l->next = remove_entry(l->next, key, entries);
+
+ return l;
+}
+
+static hashentry_t
+insert_entry(hashentry_t l, hashentry_t e, size_t* entries)
+{
+ if (is_empty(l)) {
+ (*entries)++;
+ return e;
+ }
+
+ /* check for update */
+ if (strcmp(l->key, e->key) == 0) {
+ e->next = l->next;
+ l = free_entry(l);
+ return e;
+ }
+
+ l->next = insert_entry(l->next, e, entries);
+ return l;
+}
+
+static hashentry_t
+remove_all(hashentry_t l, size_t* entries)
+{
+ hashentry_t lnext;
+ if (is_empty(l))
+ return NULL;
+
+ lnext = l->next;
+ free_entry(l);
+ (*entries)--;
+
+ return remove_all(lnext, entries);
+}
+
+static const char*
+value_lookup(hashentry_t l, const char* key)
+{
+ if (is_empty(l))
+ return NULL;
+
+ if (strcmp(l->key, key) == 0)
+ return l->value;
+
+ return value_lookup(l->next, key);
+}
+
+static void
+print_all(hashentry_t l)
+{
+ if (is_empty(l)) {
+ printf("\n");
+ return;
+ }
+
+ printf("%s=%s", l->key, l->value);
+ if (!is_empty(l->next)) {
+ printf(",");
+ }
+
+ print_all(l->next);
+}
+
+static void
+keys_to_array(hashentry_t l, const char** a, size_t* i)
+{
+ if (is_empty(l))
+ return;
+
+ a[*i] = l->key;
+ (*i)++;
+
+ keys_to_array(l->next, a, i);
+}
+
+uint32_t
+hash_str(const char* str, uint32_t mapsize)
+{
+ uint32_t hash = 0;
+ uint32_t x = 0;
+ uint32_t i = 0;
+ size_t len = strlen(str);
+
+ for(i = 0; i < len; str++, i++) {
+ hash = (hash << 4) + (*str);
+ if((x = hash & 0xF0000000L) != 0) {
+ hash ^= (x >> 24);
+ hash &= ~x;
+ }
+ }
+
+ return (hash & 0x7FFFFFFF) % mapsize;
+}
+
+
+int
+hashmap_is_empty(hashmap_t map)
+{
+ if (map == NULL)
+ return -EINVAL;
+
+ return map->entries > 0 ? 1 : 0;
+}
+
+const char*
+hashmap_lookup(hashmap_t map, const char* key)
+{
+ uint32_t i;
+
+ if ((map == NULL) || (key == NULL))
+ return NULL;
+
+ i = hash_str(key, map->maxsize);
+
+ return value_lookup(map->data[i], key);
+}
+
+int
+hashmap_add(hashmap_t map, const char* key, const char* value)
+{
+ uint32_t i;
+ hashentry_t entry;
+
+ if ((map == NULL) || (key == NULL) || (value == NULL))
+ return -EINVAL;
+
+ i = hash_str(key, map->maxsize);
+ entry = new_entry(key, value);
+ if (entry == NULL)
+ return -ENOMEM;
+
+ map->data[i] = insert_entry(map->data[i],
+ entry, &map->entries);
+
+ INFO_MSG("HASH_ADD: chain[%d] key:%s val:%s",i, key, value);
+ return 0;
+}
+
+int
+hashmap_remove(hashmap_t map, const char* key)
+{
+ uint32_t i;
+
+ if ((map == NULL) || (key == NULL))
+ return -EINVAL;
+
+ i = hash_str(key, map->maxsize);
+ map->data[i] = remove_entry(map->data[i], key, &map->entries);
+
+ return 0;
+}
+
+size_t
+hashmap_size(hashmap_t map)
+{
+ if (map != NULL)
+ return map->entries;
+ else
+ return 0;
+}
+
+int
+hashmap_free(hashmap_t map)
+{
+ size_t i;
+
+ if (map == NULL)
+ return -EINVAL;
+
+ /* "children" first */
+ for(i = 0; i < map->maxsize; i++) {
+ map->data[i] = remove_all(map->data[i], &map->entries);
+ }
+ free(map->data);
+ free(map);
+
+ return 0;
+}
+
+int
+hashmap_dump(hashmap_t map)
+{
+ size_t i;
+ if (map == NULL)
+ return -EINVAL;
+
+ for(i = 0; i < map->maxsize; i++) {
+ if (map->data[i] != NULL) {
+ printf("[%d]: ", i);
+ print_all(map->data[i]);
+ }
+ }
+
+ return 0;
+}
+
+static const char**
+sort_key_vector(const char** a, size_t size)
+{
+ /* uses bubblesort */
+ size_t i, j;
+ const char* tmp;
+
+ if (size <= 0)
+ return a;
+
+ for (i = size - 1; i > 0; i--) {
+ for (j = 0; j < i; j++) {
+ if (strcmp(a[j], a[j+1]) > 0) {
+ tmp = a[j];
+ a[j] = a[j+1];
+ a[j+1] = tmp;
+ }
+ }
+ }
+ return a;
+}
+
+const char**
+hashmap_get_key_vector(hashmap_t map, size_t* size, int sort)
+{
+ const char** res;
+ size_t i, j;
+ *size = map->entries;
+
+ res = (const char**) malloc(*size * sizeof(char*));
+ if (res == NULL)
+ return NULL;
+
+ j = 0;
+ for(i=0; i < map->maxsize; i++) {
+ keys_to_array(map->data[i], res, &j);
+ }
+
+ if (sort)
+ res = sort_key_vector(res, *size);
+
+ return res;
+}
+
+int
+hashmap_key_is_in_vector(const char** vec, size_t size, const char* key)
+{
+ size_t i;
+ for (i = 0; i < size; i++) {
+ if (strcmp(vec[i], key) == 0) /* found */
+ return 1;
+ }
+
+ return 0;
+}
+
+const char**
+hashmap_get_update_key_vector(const char** vec1, size_t vec1_size,
+ const char** vec2, size_t vec2_size, size_t* res_size)
+{
+ const char** res;
+ size_t i, j;
+
+ *res_size = vec2_size;
+
+ res = (const char**) malloc(*res_size * sizeof(char*));
+ if (res == NULL)
+ return NULL;
+
+ /* get all keys from vec2 which are not set in vec1 */
+ j = 0;
+ for (i = 0; i < vec2_size; i++) {
+ if (!hashmap_key_is_in_vector(vec1, vec1_size, vec2[i]))
+ res[j++] = vec2[i];
+ }
+
+ *res_size = j;
+ return res;
+}
diff --git a/ubi-utils/src/libbootenv/hashmap.h b/ubi-utils/src/libbootenv/hashmap.h
new file mode 100644
index 0000000..1b13e95
--- /dev/null
+++ b/ubi-utils/src/libbootenv/hashmap.h
@@ -0,0 +1,49 @@
+#ifndef __HASHMAP_H__
+#define __HASHMAP_H__
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Oliver Lohmann
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+
+typedef struct hashentry *hashentry_t;
+typedef struct hashmap *hashmap_t;
+
+hashmap_t hashmap_new(void);
+int hashmap_free(hashmap_t map);
+
+int hashmap_add(hashmap_t map, const char* key, const char* value);
+int hashmap_update(hashmap_t map, const char* key, const char* value);
+int hashmap_remove(hashmap_t map, const char* key);
+const char* hashmap_lookup(hashmap_t map, const char* key);
+
+const char** hashmap_get_key_vector(hashmap_t map, size_t* size, int sort);
+int hashmap_key_is_in_vector(const char** vec, size_t size, const char* key);
+const char** hashmap_get_update_key_vector(const char** vec1, size_t vec1_size,
+ const char** vec2, size_t vec2_size, size_t* res_size);
+
+int hashmap_dump(hashmap_t map);
+
+int hashmap_is_empty(hashmap_t map);
+size_t hashmap_size(hashmap_t map);
+
+uint32_t hash_str(const char* str, uint32_t mapsize);
+
+#endif /* __HASHMAP_H__ */
diff --git a/ubi-utils/src/libcrc32/crc32.c b/ubi-utils/src/libcrc32/crc32.c
new file mode 100644
index 0000000..666e217
--- /dev/null
+++ b/ubi-utils/src/libcrc32/crc32.c
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Thomas Gleixner
+ */
+
+/*
+ * CRC32 functions
+ *
+ * Can be compiled as seperate object, but is included into the ipl source
+ * so gcc can inline the functions. We optimize for size so the omission of
+ * the function frame is helpful.
+ *
+ */
+
+#include <stdint.h>
+#include <crc32.h>
+
+/* CRC polynomial */
+#define CRC_POLY 0xEDB88320
+
+/**
+ * init_crc32_table - Initialize crc table
+ *
+ * @table: pointer to the CRC table which must be initialized
+ *
+ * Create CRC32 table for given polynomial. The table is created with
+ * the lowest order term in the highest order bit. So the x^32 term
+ * has to implied in the crc calculation function.
+ */
+void init_crc32_table(uint32_t *table)
+{
+ uint32_t crc;
+ int i, j;
+
+ for (i = 0; i < 256; i++) {
+ crc = i;
+ for (j = 8; j > 0; j--) {
+ if (crc & 1)
+ crc = (crc >> 1) ^ CRC_POLY;
+ else
+ crc >>= 1;
+ }
+ table[i] = crc;
+ }
+}
+
+/**
+ * clc_crc32 - Calculate CRC32 over a buffer
+ *
+ * @table: pointer to the CRC table
+ * @crc: initial crc value
+ * @buf: pointer to the buffer
+ * @len: number of bytes to calc
+ *
+ * Returns the updated crc value.
+ *
+ * The algorithm resembles a hardware shift register, but calculates 8
+ * bit at once.
+ */
+uint32_t clc_crc32(uint32_t *table, uint32_t crc, void *buf,
+ int len)
+{
+ const unsigned char *p = buf;
+
+ while(--len >= 0)
+ crc = table[(crc ^ *p++) & 0xff] ^ (crc >> 8);
+ return crc;
+}
diff --git a/ubi-utils/src/liberror/error.c b/ubi-utils/src/liberror/error.c
new file mode 100644
index 0000000..c8c623c
--- /dev/null
+++ b/ubi-utils/src/liberror/error.c
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <syslog.h>
+#include <stdlib.h>
+#include <sys/errno.h>
+#include <string.h>
+#include "error.h"
+
+#define MAXLINE 4096
+
+static FILE *logfp = NULL;
+
+static void err_doit(int, int, const char *, va_list);
+
+int
+read_procfile(FILE *fp_out, const char *procfile)
+{
+ FILE *fp;
+
+ fp = fopen(procfile, "r");
+ if (!fp)
+ return -ENOENT;
+
+ while(!feof(fp)) {
+ int c = fgetc(fp);
+
+ if (c == EOF)
+ return 0;
+
+ if (putc(c, fp_out) == EOF)
+ return -EIO;
+
+ if (ferror(fp))
+ return -EIO;
+ }
+ return fclose(fp);
+}
+
+void
+error_initlog(const char *logfile)
+{
+ logfp = fopen(logfile, "a+");
+ read_procfile(logfp, "/proc/cpuinfo");
+}
+
+void
+info_msg(const char *fmt, ...)
+{
+ FILE* fpout;
+ char buf[MAXLINE + 1];
+ va_list ap;
+ int n;
+
+ fpout = stdout;
+
+ va_start(ap, fmt);
+ vsnprintf(buf, MAXLINE, fmt, ap);
+ n = strlen(buf);
+ strcat(buf, "\n");
+
+ fputs(buf, fpout);
+ fflush(fpout);
+ if (fpout != stdout)
+ fclose(fpout);
+
+ va_end(ap);
+ return;
+}
+
+void
+__err_ret(const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ err_doit(1, LOG_INFO, fmt, ap);
+ va_end(ap);
+ return;
+}
+
+void
+__err_sys(const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ err_doit(1, LOG_ERR, fmt, ap);
+ va_end(ap);
+ exit(EXIT_FAILURE);
+}
+
+
+void
+__err_msg(const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ err_doit(0, LOG_INFO, fmt, ap);
+ va_end(ap);
+
+ return;
+}
+
+void
+__err_quit(const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ err_doit(0, LOG_ERR, fmt, ap);
+ va_end(ap);
+ exit(EXIT_FAILURE);
+}
+
+void
+__err_dump(const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ err_doit(1, LOG_ERR, fmt, ap);
+ va_end(ap);
+ abort(); /* dump core and terminate */
+ exit(EXIT_FAILURE); /* shouldn't get here */
+}
+
+
+static void
+err_doit(int errnoflag, int level __attribute__((unused)),
+ const char *fmt, va_list ap)
+{
+ FILE* fpout;
+ int errno_save, n;
+ char buf[MAXLINE + 1];
+ fpout = stderr;
+
+ errno_save = errno; /* value caller might want printed */
+
+ vsnprintf(buf, MAXLINE, fmt, ap); /* safe */
+
+ n = strlen(buf);
+
+ if (errnoflag)
+ snprintf(buf + n, MAXLINE - n, ": %s", strerror(errno_save));
+ strcat(buf, "\n");
+
+ if (logfp) {
+ fputs(buf, logfp);
+ fflush(logfp);
+ }
+
+ fputs(buf, fpout);
+ fflush(fpout);
+ if (fpout != stderr)
+ fclose(fpout);
+
+ return;
+}
diff --git a/ubi-utils/src/liblist/list.c b/ubi-utils/src/liblist/list.c
new file mode 100644
index 0000000..6eb716b
--- /dev/null
+++ b/ubi-utils/src/liblist/list.c
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Oliver Lohmann
+ */
+
+#include <stdlib.h>
+#include <assert.h>
+#include <stdio.h>
+
+#include "list.h"
+
+list_t
+mk_empty(void)
+{
+ return (list_t) NULL;
+}
+
+int
+is_empty(list_t l)
+{
+ return l == NULL;
+}
+
+info_t
+head(list_t l)
+{
+ assert(!is_empty(l));
+ return l->info;
+}
+
+list_t
+tail(list_t l)
+{
+ assert(!is_empty(l));
+ return l->next;
+}
+
+list_t
+remove_head(list_t l)
+{
+ list_t res;
+ assert(!is_empty(l));
+
+ res = l->next;
+ free(l);
+ return res;
+}
+
+list_t
+cons(info_t e, list_t l)
+{
+ list_t res = malloc(sizeof(*l));
+ if (!res)
+ return NULL;
+ res->info = e;
+ res->next = l;
+
+ return res;
+}
+
+list_t
+prepend_elem(info_t e, list_t l)
+{
+ return cons(e,l);
+}
+
+list_t
+append_elem(info_t e, list_t l)
+{
+ if (is_empty(l)) {
+ return cons(e,l);
+ }
+ l->next = append_elem(e, l->next);
+
+ return l;
+}
+
+list_t
+insert_sorted(cmp_func_t cmp, info_t e, list_t l)
+{
+ if (is_empty(l))
+ return cons(e, l);
+
+ switch (cmp(e, l->info)) {
+ case -1:
+ case 0:
+ return l;
+ break;
+ case 1:
+ l->next = insert_sorted(cmp, e, l);
+ break;
+ default:
+ break;
+ }
+
+ /* never reached */
+ return NULL;
+}
+
+list_t
+remove_all(free_func_t free_func, list_t l)
+{
+ if (is_empty(l))
+ return l;
+ list_t lnext = l->next;
+
+ if (free_func && l->info) {
+ free_func(&(l->info));
+ }
+ free(l);
+
+ return remove_all(free_func, lnext);
+}
+
+
+info_t
+is_in(cmp_func_t cmp, info_t e, list_t l)
+{
+ return
+ (is_empty(l))
+ ? NULL
+ : (cmp(e, l->info)) == 0 ? l->info : is_in(cmp, e, l->next);
+}
+
+
+void
+apply(process_func_t process_func, list_t l)
+{
+ list_t ptr;
+ void *i;
+ foreach(i, ptr, l) {
+ process_func(i);
+ }
+}
diff --git a/ubi-utils/src/libpeb/peb.c b/ubi-utils/src/libpeb/peb.c
new file mode 100644
index 0000000..08b770f
--- /dev/null
+++ b/ubi-utils/src/libpeb/peb.c
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+
+#include "peb.h"
+
+int
+peb_cmp(peb_t eb_1, peb_t eb_2)
+{
+ assert(eb_1);
+ assert(eb_2);
+
+ return eb_1->num == eb_2->num ? 0
+ : eb_1->num > eb_2->num ? 1 : -1;
+}
+
+int
+peb_new(uint32_t eb_num, uint32_t eb_size, peb_t *peb)
+{
+ int rc = 0;
+
+ peb_t res = (peb_t) malloc(sizeof(struct peb));
+ if (!res) {
+ rc = -ENOMEM;
+ goto err;
+ }
+
+ res->num = eb_num;
+ res->size = eb_size;
+ res->data = (uint8_t*) malloc(res->size * sizeof(uint8_t));
+ if (!res->data) {
+ rc = -ENOMEM;
+ goto err;
+ }
+ memset(res->data, 0xff, res->size);
+
+ *peb = res;
+ return 0;
+err:
+ if (res) {
+ if (res->data)
+ free(res->data);
+ free(res);
+ }
+ *peb = NULL;
+ return rc;
+}
+
+int
+peb_fill(peb_t peb, uint8_t* buf, size_t buf_size)
+{
+ if (!peb)
+ return -EINVAL;
+
+ if (buf_size > peb->size)
+ return -EINVAL;
+
+ memcpy(peb->data, buf, buf_size);
+ return 0;
+}
+
+int
+peb_write(FILE* fp_out, peb_t peb)
+{
+ size_t written = 0;
+
+ if (peb == NULL)
+ return -EINVAL;
+
+ written = fwrite(peb->data, 1, peb->size, fp_out);
+
+ if (written != peb->size)
+ return -EIO;
+
+ return 0;
+}
+
+int
+peb_free(peb_t* peb)
+{
+ peb_t tmp = *peb;
+ if (tmp) {
+ if (tmp->data)
+ free(tmp->data);
+ free(tmp);
+ }
+ *peb = NULL;
+
+ return 0;
+}
+
+void peb_dump(FILE* fp_out, peb_t peb)
+{
+ fprintf(fp_out, "num: %08d\tsize: 0x%08x\n", peb->num, peb->size);
+}
diff --git a/ubi-utils/src/libpfi/pfi.c b/ubi-utils/src/libpfi/pfi.c
new file mode 100644
index 0000000..c8d5ee4
--- /dev/null
+++ b/ubi-utils/src/libpfi/pfi.c
@@ -0,0 +1,461 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * @file pfi.c
+ *
+ * @author Oliver Lohmann
+ * Andreas Arnez
+ * Joern Engel
+ * Frank Haverkamp
+ *
+ * @brief libpfi holds all code to create and process pfi files.
+ *
+ * <oliloh@de.ibm.com> Wed Feb 8 11:38:22 CET 2006: Initial creation.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <syslog.h>
+#include <stdarg.h>
+#include <errno.h>
+
+#include "pfi.h"
+
+#define PFI_MAGIC "PFI!\n"
+#define PFI_DATA "DATA\n" /* The same size as PFI_MAGIC */
+#define PFI_MAGIC_LEN 5
+
+static const char copyright [] __attribute__((unused)) =
+ "Copyright (c) International Business Machines Corp., 2006";
+
+enum key_id {
+ /* version 1 */
+ key_version, /* must be index position 0! */
+ key_mode,
+ key_size,
+ key_crc,
+ key_label,
+ key_flags,
+ key_ubi_ids,
+ key_ubi_size,
+ key_ubi_type,
+ key_ubi_names,
+ key_ubi_alignment,
+ key_raw_starts,
+ key_raw_total_size,
+ num_keys,
+};
+
+struct pfi_header {
+ char defined[num_keys]; /* reserve all possible keys even if
+ version does not require this. */
+ int mode_no; /* current mode no. -> can only increase */
+ union {
+ char *str;
+ uint32_t num;
+ } value[num_keys];
+};
+
+
+#define PFI_MANDATORY 0x0001
+#define PFI_STRING 0x0002
+#define PFI_LISTVALUE 0x0004 /* comma seperated list of nums */
+#define PFI_MANDATORY_UBI 0x0008
+#define PFI_MANDATORY_RAW 0x0010
+
+struct key_descriptor {
+ enum key_id id;
+ const char *name;
+ uint32_t flags;
+};
+
+static const struct key_descriptor key_desc_v1[] = {
+ { key_version, "version", PFI_MANDATORY },
+ { key_mode, "mode", PFI_MANDATORY | PFI_STRING },
+ { key_size, "size", PFI_MANDATORY },
+ { key_crc, "crc", PFI_MANDATORY },
+ { key_label, "label", PFI_MANDATORY | PFI_STRING },
+ { key_flags, "flags", PFI_MANDATORY },
+ { key_ubi_ids, "ubi_ids", PFI_MANDATORY_UBI | PFI_STRING },
+ { key_ubi_size, "ubi_size", PFI_MANDATORY_UBI },
+ { key_ubi_type, "ubi_type", PFI_MANDATORY_UBI | PFI_STRING },
+ { key_ubi_names, "ubi_names", PFI_MANDATORY_UBI | PFI_STRING },
+ { key_ubi_alignment, "ubi_alignment", PFI_MANDATORY_UBI },
+ { key_raw_starts, "raw_starts", PFI_MANDATORY_RAW | PFI_STRING },
+ { key_raw_total_size, "raw_total_size", PFI_MANDATORY_RAW },
+};
+
+static const struct key_descriptor *key_descriptors[] = {
+ NULL,
+ key_desc_v1, /* version 1 */
+};
+
+static const int key_descriptors_max[] = {
+ 0, /* version 0 */
+ sizeof(key_desc_v1)/sizeof(struct key_descriptor), /* version 1 */
+};
+
+static const char* modes[] = {"raw", "ubi", NULL}; /* order isn't arbitrary! */
+
+/* latest version contains all possible keys */
+static const struct key_descriptor *key_desc = key_desc_v1;
+
+#define PFI_IS_UBI(mode) \
+ (((mode) != NULL) && (strcmp("ubi", (mode)) == 0))
+
+#define PFI_IS_RAW(mode) \
+ (((mode) != NULL) && (strcmp("raw", (mode)) == 0))
+
+/**
+ * @return <0 On Error.
+ * >=0 Mode no.
+ */
+static int
+get_mode_no(const char* mode)
+{
+ const char* ptr = modes[0];
+ int i = 0;
+ while (ptr != NULL) {
+ if(strcmp(ptr, mode) == 0) {
+ return i;
+ }
+ ptr++;
+ i++;
+ }
+
+ return -1;
+}
+
+static int
+find_key_by_name (const char *name)
+{
+ int i;
+
+ for (i = 0; i < num_keys; i++) {
+ if (strcmp(name, key_desc[i].name) == 0)
+ return i;
+ }
+ return -1;
+}
+
+static int
+check_valid (pfi_header head)
+{
+ int i;
+ int max_keys;
+ uint32_t version;
+ const char *mode;
+ const struct key_descriptor *desc;
+ uint32_t to_check = PFI_MANDATORY;
+
+ /*
+ * For the validity check the list of possible keys depends on
+ * the version of the PFI file used.
+ */
+ version = head->value[key_version].num;
+ if (version > PFI_HDRVERSION)
+ return PFI_ENOHEADER;
+
+ max_keys = key_descriptors_max[version];
+ desc = key_descriptors[version];
+
+ if (!desc)
+ return PFI_ENOVERSION;
+
+ mode = head->value[key_mode].str;
+ if (PFI_IS_UBI(mode)) {
+ to_check |= PFI_MANDATORY_UBI;
+ }
+ else if (PFI_IS_RAW(mode)) {
+ to_check |= PFI_MANDATORY_RAW;
+ }
+ else { /* neither UBI nor RAW == ERR */
+ return PFI_EINSUFF;
+ }
+
+ for (i = 0; i < max_keys; i++) {
+ if ((desc[i].flags & to_check) && !head->defined[i]) {
+ fprintf(stderr, "libpfi: %s missing\n", desc[i].name);
+ return PFI_EINSUFF;
+ }
+ }
+
+ return 0;
+}
+
+int pfi_header_init (pfi_header *head)
+{
+ int i;
+ pfi_header self = (pfi_header) malloc(sizeof(*self));
+
+ *head = self;
+ if (self == NULL)
+ return PFI_ENOMEM;
+
+ /* initialize maximum number of possible keys */
+ for (i = 0; i < num_keys; i++) {
+ memset(self, 0, sizeof(*self));
+ self->defined[i] = 0;
+ }
+
+ return 0;
+}
+
+int pfi_header_destroy (pfi_header *head)
+{
+ int i;
+ pfi_header self = *head;
+
+ for (i = 0; i < num_keys; i++) {
+ if (self->defined[i] && (key_desc[i].flags & PFI_STRING) &&
+ self->value[i].str) {
+ free(self->value[i].str);
+ }
+ }
+ free(*head);
+ *head = NULL;
+ return 0;
+}
+
+int pfi_header_setnumber (pfi_header head,
+ const char *key, uint32_t value)
+{
+ int key_id = find_key_by_name(key);
+
+ if (key_id < 0)
+ return PFI_EUNDEF;
+
+ if (key_desc[key_id].flags & PFI_STRING)
+ return PFI_EBADTYPE;
+
+ head->value[key_id].num = value;
+ head->defined[key_id] = 1;
+ return 0;
+}
+
+int pfi_header_setvalue (pfi_header head,
+ const char *key, const char *value)
+{
+ int key_id = find_key_by_name(key);
+
+ if ((uint32_t)value == (uint32_t)NULL)
+ return PFI_EINSUFF;
+
+ if ((key_id < 0) || (key_id >= num_keys))
+ return PFI_EUNDEF;
+
+ if (key_desc[key_id].flags & PFI_STRING) {
+ /*
+ * The value is a string. Copy to a newly allocated
+ * buffer. Delete the old value, if already set.
+ */
+ size_t len = strlen(value) + 1;
+ char *old_str = NULL;
+ char *str;
+
+ old_str = head->value[key_id].str;
+ if (old_str != NULL)
+ free(old_str);
+
+ str = head->value[key_id].str = (char *) malloc(len);
+ if (str == NULL)
+ return PFI_ENOMEM;
+
+ strcpy(str, value);
+ } else {
+ int len;
+ int ret;
+ /* FIXME: here we assume that the value is always
+ given in hex and starts with '0x'. */
+ ret = sscanf(value, "0x%x%n", &head->value[key_id].num, &len);
+ if (ret < 1 || value[len] != '\0')
+ return PFI_EBADTYPE;
+ }
+ head->defined[key_id] = 1;
+ return 0;
+}
+
+int pfi_header_getnumber (pfi_header head,
+ const char *key, uint32_t *value)
+{
+ int key_id = find_key_by_name(key);
+
+ if (key_id < 0)
+ return PFI_EUNDEF;
+
+ if (key_desc[key_id].flags & PFI_STRING)
+ return PFI_EBADTYPE;
+
+ if (!head->defined[key_id])
+ return PFI_EUNDEF;
+
+ *value = head->value[key_id].num;
+ return 0;
+}
+
+int pfi_header_getstring (pfi_header head,
+ const char *key, char *value, size_t size)
+{
+ int key_id = find_key_by_name(key);
+
+ if (key_id < 0)
+ return PFI_EUNDEF;
+
+ if (!(key_desc[key_id].flags & PFI_STRING))
+ return PFI_EBADTYPE;
+
+ if (!head->defined[key_id])
+ return PFI_EUNDEF;
+
+ strncpy(value, head->value[key_id].str, size-1);
+ value[size-1] = '\0';
+ return 0;
+}
+
+int pfi_header_write (FILE *out, pfi_header head)
+{
+ int i;
+ int ret;
+
+ pfi_header_setnumber(head, "version", PFI_HDRVERSION);
+
+ if ((ret = check_valid(head)) != 0)
+ return ret;
+
+ /* OK. Now write the header. */
+
+ ret = fwrite(PFI_MAGIC, 1, PFI_MAGIC_LEN, out);
+ if (ret < PFI_MAGIC_LEN)
+ return ret;
+
+
+ for (i = 0; i < num_keys; i++) {
+ if (!head->defined[i])
+ continue;
+
+ ret = fprintf(out, "%s=", key_desc[i].name);
+ if (ret < 0)
+ return PFI_EFILE;
+
+ if (key_desc[i].flags & PFI_STRING) {
+ ret = fprintf(out, "%s", head->value[i].str);
+ if (ret < 0)
+ return PFI_EFILE;
+ } else {
+ ret = fprintf(out, "0x%8x", head->value[i].num);
+ if (ret < 0)
+ return PFI_EFILE;
+
+ }
+ ret = fprintf(out, "\n");
+ if (ret < 0)
+ return PFI_EFILE;
+ }
+ ret = fprintf(out, "\n");
+ if (ret < 0)
+ return PFI_EFILE;
+
+ ret = fflush(out);
+ if (ret != 0)
+ return PFI_EFILE;
+
+ return 0;
+}
+
+int pfi_header_read (FILE *in, pfi_header head)
+{
+ char magic[PFI_MAGIC_LEN];
+ char mode[PFI_KEYWORD_LEN];
+ char buf[256];
+
+ if (PFI_MAGIC_LEN != fread(magic, 1, PFI_MAGIC_LEN, in))
+ return PFI_EFILE;
+ if (memcmp(magic, PFI_MAGIC, PFI_MAGIC_LEN) != 0) {
+ if (memcmp(magic, PFI_DATA, PFI_MAGIC_LEN) == 0) {
+ return PFI_DATA_START;
+ }
+ return PFI_ENOHEADER;
+ }
+
+ while (fgets(buf, sizeof(buf), in) != NULL && buf[0] != '\n') {
+ char *value;
+ char *end;
+ value = strchr(buf, '=');
+ if (value == NULL)
+ return PFI_ENOHEADER;
+
+ *value = '\0';
+ value++;
+ end = strchr(value, '\n');
+ if (end)
+ *end = '\0';
+
+ if (pfi_header_setvalue(head, buf, value))
+ return PFI_ENOHEADER;
+ }
+
+ if (check_valid(head) != 0)
+ return PFI_ENOHEADER;
+
+ /* set current mode no. in head */
+ pfi_header_getstring(head, "mode", mode, PFI_KEYWORD_LEN);
+ if (head->mode_no > get_mode_no(mode)) {
+ return PFI_EMODE;
+ }
+ head->mode_no = get_mode_no(mode);
+ return 0;
+}
+
+int pfi_header_dump (FILE *out, pfi_header head __attribute__((__unused__)))
+{
+ fprintf(out, "Sorry not implemented yet. Write mail to "
+ "Andreas Arnez and complain!\n");
+ return 0;
+}
+
+int pfi_read (FILE *in, pfi_read_func func, void *priv_data)
+{
+ int rc;
+ pfi_header header;
+
+ rc = pfi_header_init (&header);
+ if (0 != rc)
+ return rc;
+ if (!func)
+ return PFI_EINVAL;
+
+ while ((0 == rc) && !feof(in)) {
+ /*
+ * Read header and check consistency of the fields.
+ */
+ rc = pfi_header_read( in, header );
+ if (0 != rc)
+ break;
+ if (func) {
+ rc = func(in, header, priv_data);
+ if (rc != 0)
+ break;
+ }
+ }
+
+ pfi_header_destroy(&header);
+ return rc;
+}
diff --git a/ubi-utils/src/libpfiflash/pfiflash.c b/ubi-utils/src/libpfiflash/pfiflash.c
new file mode 100644
index 0000000..0859a22
--- /dev/null
+++ b/ubi-utils/src/libpfiflash/pfiflash.c
@@ -0,0 +1,617 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/**
+ * @file pfiflash.c
+ *
+ * @author Oliver Lohmann <oliloh@de.ibm.com>
+ *
+ * @brief This library is provides an interface to the pfiflash utility.
+ *
+ * <oliloh@de.ibm.com> Wed Mar 15 11:39:19 CET 2006 Initial creation.
+ *
+ * @TODO Comare data before writing it. This implies that the volume
+ * parameters are compared first: size, alignment, name, type, ...,
+ * this is the same, compare the data. Volume deletion is deffered
+ * until the difference has been found out.
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
+#define __USE_GNU
+#include <string.h>
+
+#include <libubi.h>
+#include <pfiflash.h>
+
+#include <mtd/ubi-user.h> /* FIXME Is this ok here!!?? */
+
+#include "ubimirror.h"
+#include "error.h"
+#include "reader.h"
+#include "example_ubi.h"
+#include "bootenv.h"
+
+static const char copyright [] __attribute__((unused)) =
+ "Copyright (c) International Business Machines Corp., 2006";
+
+#define EBUF(fmt...) do { \
+ snprintf(err_buf, err_buf_size, fmt); \
+ } while (0)
+
+static pdd_func_t pdd_funcs[PDD_HANDLING_NUM] =
+ {
+ &bootenv_pdd_keep,
+ &bootenv_pdd_merge,
+ &bootenv_pdd_overwrite
+ };
+/**< An array of PDD function pointers indexed by the algorithm. */
+
+
+typedef enum ubi_update_process_t {
+ UBI_REMOVE = 0,
+ UBI_WRITE,
+} ubi_update_process_t;
+
+static int
+skip_raw_sections(FILE* pfi, list_t pfi_raws,
+ char* err_buf, size_t err_buf_size)
+{
+ int rc = 0;
+
+ void *i;
+ list_t ptr;
+ size_t j, skip_size;
+
+ if (is_empty(pfi_raws))
+ return 0;
+
+ foreach(i, ptr, pfi_raws) {
+ skip_size = ((pfi_raw_t)i)->data_size;
+ for(j = 0; j < skip_size; j++) {
+ fgetc(pfi);
+ if (ferror(pfi)) {
+ EBUF("Cannot skip raw section in PFI.");
+ rc = -EIO;
+ goto err;
+ }
+ }
+ }
+ err:
+ return rc;
+}
+
+/**
+ * @brief Wraps the ubi_mkvol functions and implements a hook for the bootenv
+ * update.
+ * @param devno UBI device number.
+ * @param s Current seqnum.
+ * @param u Information about the UBI volume from the PFI.
+ * @param err_buf An error buffer.
+ * @param err_buf_size The size of the error buffer.
+ * @return 0 On Sucess.
+ * @return else Error.
+ */
+static int
+my_ubi_mkvol(int devno, int s, pfi_ubi_t u, char *err_buf, size_t err_buf_size)
+{
+ int rc = 0;
+ int type;
+ ubi_lib_t ulib = NULL;
+
+ log_msg("%s(vol_id=%d, size=%d, data_size=%d, type=%d, "
+ "alig=%d, nlen=%d, name=%s)", __func__,
+ u->ids[s], u->size, u->data_size, u->type, u->alignment,
+ strnlen(u->names[s], PFI_UBI_VOL_NAME_LEN), u->names[s]);
+
+ rc = ubi_open(&ulib);
+ if (rc != 0) {
+ goto err;
+ }
+
+ switch (u->type) {
+ case pfi_ubi_static:
+ type = UBI_STATIC_VOLUME; break;
+ case pfi_ubi_dynamic:
+ type = UBI_DYNAMIC_VOLUME; break;
+ default:
+ type = UBI_DYNAMIC_VOLUME;
+ }
+
+ rc = ubi_mkvol(ulib, devno, u->ids[s], type, u->size, u->alignment,
+ u->names[s]);
+ if (rc != 0) {
+ EBUF("Cannot create volume: %d", u->ids[s]);
+ goto err;
+ }
+
+ err:
+ if (ulib != NULL)
+ ubi_close(&ulib);
+ return rc;
+}
+
+/**
+ * @brief A wrapper around the UBI library function ubi_rmvol.
+ * @param devno UBI device number.
+ * @param s Current seqnum.
+ * @param u Information about the UBI volume from the PFI.
+ * @param err_buf An error buffer.
+ * @param err_buf_size The size of the error buffer.
+ *
+ * If the volume does not exist, the function will return success.
+ */
+static int
+my_ubi_rmvol(int devno, uint32_t id, char *err_buf, size_t err_buf_size)
+{
+ int rc = 0;
+ ubi_lib_t ulib = NULL;
+ int fd;
+
+ log_msg("%s(id=%d)", __func__, id);
+
+ rc = ubi_open(&ulib);
+ if (rc != 0)
+ goto err;
+
+ /**
+ * Truncate if it exist or not.
+ */
+ fd = ubi_vol_open(ulib, devno, id, O_RDWR);
+ if (fd == -1)
+ return 0; /* not existent, return */
+
+ rc = ubi_vol_update(fd, 0);
+ if (rc < 0) {
+ fprintf(stderr, "update failed rc=%d errno=%d\n", rc, errno);
+ ubi_vol_close(fd);
+ goto err; /* if EBUSY than empty device, continue */
+ }
+ ubi_vol_close(fd);
+
+ rc = ubi_rmvol(ulib, devno, id);
+ if (rc != 0) {
+ /* @TODO Define a ubi_rmvol return value which says
+ * sth like EUBI_NOSUCHDEV. In this case, a failed
+ * operation is acceptable. Everything else has to be
+ * classified as real error. But talk to Andreas Arnez
+ * before defining something odd...
+ */
+ /* if ((errno == EINVAL) || (errno == ENODEV))
+ return 0; */ /* currently it is EINVAL or ENODEV */
+
+ dbg_msg("Remove UBI volume %d returned with error: %d "
+ "errno=%d", id, rc, errno);
+ goto err;
+ }
+ err:
+ if (ulib != NULL)
+ ubi_close(&ulib);
+ return rc;
+}
+
+static int
+read_bootenv_volume(int devno, uint32_t id, bootenv_t bootenv_old,
+ char *err_buf, size_t err_buf_size)
+{
+ int rc = 0;
+ ubi_lib_t ulib = NULL;
+ FILE* fp_in = NULL;
+
+ rc = ubi_open(&ulib);
+ if (rc)
+ return rc;
+
+ fp_in = ubi_vol_fopen_read(ulib, devno, id);
+ if (!fp_in) {
+ EBUF("Cannot open bootenv volume");
+ rc = -EIO;
+ goto err;
+ }
+
+ log_msg("%s reading old bootenvs", __func__);
+
+ /* Save old bootenvs for reference */
+ rc = bootenv_read(fp_in, bootenv_old, BOOTENV_MAXSIZE);
+ if (rc)
+ EBUF("Cannot read bootenv_old");
+ err:
+ if (fp_in)
+ fclose(fp_in);
+ if (ulib)
+ ubi_close(&ulib);
+ return rc;
+}
+
+static int
+write_bootenv_volume(int devno, uint32_t id, bootenv_t bootenv_old,
+ pdd_func_t pdd_f,
+ FILE* fp_in, /* new pdd data contained in pfi */
+ size_t fp_in_size, /* data size of new pdd data in pfi */
+ char *err_buf, size_t err_buf_size)
+{
+ int rc = 0;
+ int warnings = 0;
+ ubi_lib_t ulib = NULL;
+ bootenv_t bootenv_new = NULL;
+ bootenv_t bootenv_res = NULL;
+ size_t update_size = 0;
+ FILE *fp_out = NULL;
+
+ log_msg("%s(id=%d, fp_in=%p)", __func__, id, fp_in);
+
+ /* Workflow:
+ * 1. Apply PDD operation and get the size of the returning
+ * bootenv_res section. Without the correct size it wouldn't
+ * be possible to call UBI update vol.
+ * 2. Call UBI update vol
+ * 3. Get FILE* to vol dev
+ * 4. Write to FILE*
+ */
+
+ rc = ubi_open(&ulib);
+ if (rc != 0) {
+ goto err;
+ }
+
+ rc = bootenv_create(&bootenv_new);
+ if (rc != 0)
+ goto err;
+ rc = bootenv_create(&bootenv_res);
+ if (rc != 0)
+ goto err;
+
+ rc = bootenv_read(fp_in, bootenv_new, fp_in_size);
+ if (rc != 0)
+ goto err;
+
+ rc = pdd_f(bootenv_old, bootenv_new, &bootenv_res, &warnings,
+ err_buf, err_buf_size);
+ if (rc != 0)
+ goto err;
+ if (warnings) {
+ /* @TODO Do sth with the warning */
+ dbg_msg("A warning in the PDD operation occured: %d",
+ warnings);
+ }
+ log_msg("... (2)");
+
+ rc = bootenv_size(bootenv_res, &update_size);
+ if (rc != 0)
+ goto err;
+
+ fp_out = ubi_vol_fopen_update(ulib, devno, id, update_size);
+ if (fp_out == NULL)
+ goto err;
+
+ rc = bootenv_write(fp_out, bootenv_res);
+ if (rc != 0) {
+ EBUF("Write operation on ubi%d_%d failed.", devno, id);
+ rc = -EIO;
+ goto err;
+ }
+
+ err:
+ if (ulib != NULL)
+ ubi_close(&ulib);
+ if (bootenv_new != NULL)
+ bootenv_destroy(&bootenv_new);
+ if (bootenv_res != NULL)
+ bootenv_destroy(&bootenv_res);
+ if (fp_out)
+ fclose(fp_out);
+ return rc;
+}
+
+static int
+write_normal_volume(int devno, uint32_t id, size_t update_size, FILE* fp_in,
+ char *err_buf, size_t err_buf_size)
+{
+ int rc = 0;
+ ubi_lib_t ulib = NULL;
+ FILE* fp_out = NULL;
+ int c;
+ size_t i;
+
+ log_msg("%s(id=%d, update_size=%d fp_in=%p)",
+ __func__, id, update_size, fp_in);
+
+ rc = ubi_open(&ulib);
+ if (rc)
+ return rc;
+
+ fp_out = ubi_vol_fopen_update(ulib, devno, id, update_size);
+ if (fp_out == NULL) {
+ rc = -1;
+ goto err;
+ }
+
+ log_msg("starting the update ... "); /* FIXME DBG */
+ for (i = 0; i < update_size; i++) {
+ c = getc(fp_in);
+ if (c == EOF && ferror(fp_in)) {
+ rc = -EIO;
+ goto err;
+ }
+ if (putc(c, fp_out) == EOF) {
+ rc = -EIO;
+ goto err;
+ }
+ /* FIXME DBG */
+ /* if ((i & 0xFFF) == 0xFFF) log_msg("."); */
+ }
+ /* log_msg("\n"); */ /* FIXME DBG */
+ err:
+ if (fp_out)
+ fclose(fp_out);
+ if (ulib)
+ ubi_close(&ulib);
+ return rc;
+}
+
+
+/**
+ * @brief ...
+ * @precondition The PFI file contains at least one ubi_id entry.
+ * This is assured by the PFI read process.
+ * @postcondition The used seqnum number is set in the UBI PFI
+ * header list.
+ * The UBI volumes specified by seqnum are processed.
+ */
+static int
+process_ubi_volumes(FILE* pfi, int seqnum, list_t pfi_ubis,
+ bootenv_t bootenv_old, pdd_func_t pdd_f,
+ ubi_update_process_t ubi_update_process,
+ char *err_buf, size_t err_buf_size)
+{
+ int rc = 0;
+ pfi_ubi_t u;
+ list_t ptr;
+
+ foreach(u, ptr, pfi_ubis) {
+ int s = seqnum;
+ if (seqnum > (u->ids_size - 1)) {
+ s = 0; /* per default use the first */
+ }
+ u->curr_seqnum = s;
+
+ switch (ubi_update_process) {
+ case UBI_REMOVE:
+ if ((u->ids[s] == EXAMPLE_BOOTENV_VOL_ID_1) ||
+ (u->ids[s] == EXAMPLE_BOOTENV_VOL_ID_2)) {
+ rc =read_bootenv_volume(EXAMPLE_UBI_DEVICE,
+ u->ids[s],
+ bootenv_old, err_buf,
+ err_buf_size);
+ if (rc != 0)
+ goto err;
+ }
+ rc = my_ubi_rmvol(EXAMPLE_UBI_DEVICE, u->ids[s],
+ err_buf, err_buf_size);
+ if (rc != 0)
+ goto err;
+ break;
+ case UBI_WRITE:
+ rc = my_ubi_mkvol(EXAMPLE_UBI_DEVICE, s, u,
+ err_buf, err_buf_size);
+ if (rc != 0)
+ goto err;
+ if ((u->ids[s] == EXAMPLE_BOOTENV_VOL_ID_1) ||
+ (u->ids[s] == EXAMPLE_BOOTENV_VOL_ID_2)) {
+ rc = write_bootenv_volume(EXAMPLE_UBI_DEVICE,
+ u->ids[s],
+ bootenv_old, pdd_f,
+ pfi,
+ u->data_size,
+ err_buf,
+ err_buf_size);
+ }
+ else {
+ rc = write_normal_volume(EXAMPLE_UBI_DEVICE,
+ u->ids[s],
+ u->data_size, pfi,
+ err_buf,
+ err_buf_size);
+ }
+ if (rc != 0)
+ goto err;
+ break;
+ default:
+ EBUF("Invoked unknown UBI operation.");
+ rc = -1;
+ goto err;
+
+ }
+ if (rc != 0) {
+ goto err;
+ }
+ }
+ err:
+ return rc;
+
+}
+
+static int
+erase_unmapped_ubi_volumes(int devno, list_t pfi_ubis,
+ char *err_buf, size_t err_buf_size)
+{
+ int rc = 0;
+ list_t ptr;
+ pfi_ubi_t u;
+ size_t i;
+ uint8_t ubi_volumes[PFI_UBI_MAX_VOLUMES];
+
+ for (i = 0; i < PFI_UBI_MAX_VOLUMES; i++) {
+ ubi_volumes[i] = 1;
+ }
+
+ foreach(u, ptr, pfi_ubis) {
+ /* iterate over each vol_id */
+ for(i = 0; i < u->ids_size; i++) {
+ if (u->ids[i] > PFI_UBI_MAX_VOLUMES) {
+ EBUF("PFI file contains an invalid "
+ "volume id: %d", u->ids[i]);
+ goto err;
+ }
+ /* remove from removal list */
+ ubi_volumes[u->ids[i]] = 0;
+ }
+ }
+
+ for (i = 0; i < PFI_UBI_MAX_VOLUMES; i++) {
+ if (ubi_volumes[i]) {
+ rc = my_ubi_rmvol(devno, i, err_buf, err_buf_size);
+ if (rc != 0)
+ goto err;
+ }
+ }
+ err:
+ return rc;
+}
+
+static int
+mirror_ubi_volumes(uint32_t devno, list_t pfi_ubis,
+ char *err_buf, size_t err_buf_size)
+{
+ int rc = 0;
+ list_t ptr;
+ uint32_t j;
+ pfi_ubi_t i;
+ ubi_lib_t ulib = NULL;
+
+ log_msg("%s(...)", __func__);
+
+ rc = ubi_open(&ulib);
+ if (rc != 0)
+ goto err;
+
+ /**
+ * Execute all mirror operations on redundant groups.
+ * Create a volume within a redundant group if it does
+ * not exist already (this is a precondition of
+ * ubimirror).
+ */
+ foreach(i, ptr, pfi_ubis) {
+ for(j = 0; j < i->ids_size; j++) {
+ /* skip self-match */
+ if (i->ids[j] == i->ids[i->curr_seqnum])
+ continue;
+
+ rc = my_ubi_rmvol(devno, i->ids[j], err_buf,
+ err_buf_size);
+ if (rc != 0)
+ goto err;
+
+ rc = my_ubi_mkvol(devno, j, i, err_buf, err_buf_size);
+ if (rc != 0)
+ goto err;
+ }
+ }
+
+ foreach(i, ptr, pfi_ubis) {
+ rc = ubimirror(devno, i->curr_seqnum, i->ids,
+ i->ids_size, err_buf, err_buf_size);
+ if (rc != 0)
+ goto err;
+ }
+
+
+ err:
+ if (ulib != NULL)
+ ubi_close(&ulib);
+ return rc;
+}
+
+int
+pfiflash(FILE* pfi, int complete, int seqnum, pdd_handling_t pdd_handling,
+ char *err_buf, size_t err_buf_size)
+{
+ int rc = 0;
+ pdd_func_t pdd_f = NULL;
+
+ if (pfi == NULL)
+ return -EINVAL;
+
+ /**
+ * If the user didnt specify a seqnum we start per default
+ * with the index 0
+ */
+ int curr_seqnum = seqnum < 0 ? 0 : seqnum;
+
+ list_t pfi_raws = mk_empty(); /* list of raw sections from a pfi */
+ list_t pfi_ubis = mk_empty(); /* list of ubi sections from a pfi */
+
+ bootenv_t bootenv;
+ rc = bootenv_create(&bootenv);
+ if (rc != 0) {
+ EBUF("Cannot create bootenv variable");
+ }
+
+ rc = read_pfi_headers(&pfi_raws, &pfi_ubis, pfi,
+ err_buf, err_buf_size);
+ if (rc != 0) {
+ EBUF("Cannot read PFI headers.");
+ goto err;
+ }
+
+ /* @TODO: If you want to implement an IPL update - start here. */
+ rc = skip_raw_sections(pfi, pfi_raws, err_buf, err_buf_size);
+ if (rc != 0) {
+ goto err;
+ }
+
+ if (complete) {
+ rc = erase_unmapped_ubi_volumes(EXAMPLE_UBI_DEVICE, pfi_ubis,
+ err_buf, err_buf_size);
+ if (rc != 0) {
+ EBUF("Cannot delete unmapped UBI volumes.");
+ goto err;
+ }
+ }
+
+ if ((pdd_handling >= 0) && (pdd_handling < PDD_HANDLING_NUM)) {
+ pdd_f = pdd_funcs[pdd_handling];
+ }
+ else {
+ EBUF("Used unknown PDD handling algorithm (pdd_handling)");
+ }
+
+ rc = process_ubi_volumes(pfi, curr_seqnum, pfi_ubis, bootenv, pdd_f,
+ UBI_REMOVE, err_buf, err_buf_size);
+ if (rc != 0) {
+ goto err;
+ }
+ rc = process_ubi_volumes(pfi, curr_seqnum, pfi_ubis, bootenv, pdd_f,
+ UBI_WRITE, err_buf, err_buf_size);
+ if (rc != 0) {
+ goto err;
+ }
+ if (seqnum < 0) { /* mirror redundant pairs */
+ rc = mirror_ubi_volumes(EXAMPLE_UBI_DEVICE, pfi_ubis,
+ err_buf, err_buf_size);
+ if (rc != 0)
+ goto err;
+ }
+
+ err:
+ pfi_raws = remove_all((free_func_t)&free_pfi_raw, pfi_raws);
+ pfi_ubis = remove_all((free_func_t)&free_pfi_ubi, pfi_ubis);
+ bootenv_destroy(&bootenv);
+ return rc;
+}
diff --git a/ubi-utils/src/libreader/reader.c b/ubi-utils/src/libreader/reader.c
new file mode 100644
index 0000000..c8242df
--- /dev/null
+++ b/ubi-utils/src/libreader/reader.c
@@ -0,0 +1,442 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Oliver Lohmann
+ *
+ * Read in PFI (partial flash image) data and store it into internal
+ * data structures for further processing. Take also care about
+ * special handling if the data contains PDD (platform description
+ * data/boot-parameters).
+ */
+
+#include <string.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include "bootenv.h"
+#include "reader.h"
+
+/* @FIXME hard coded offsets right now - get them from Artem? */
+#define NAND_DEFAULT_VID_HDR_OFF 1984
+#define NOR_DEFAULT_VID_HDR_OFF 64
+
+#define EBUF_PFI(fmt...) \
+ do { int i = snprintf(err_buf, err_buf_size, "%s\n", label); \
+ snprintf(err_buf + i, err_buf_size - i, fmt); \
+ } while (0)
+
+#define EBUF(fmt...) \
+ do { snprintf(err_buf, err_buf_size, fmt); } while (0)
+
+
+int
+read_pdd_data(FILE* fp_pdd, pdd_data_t* pdd_data,
+ char* err_buf, size_t err_buf_size)
+{
+ int rc = 0;
+ bootenv_t pdd = NULL;
+ pdd_data_t res = NULL;
+ const char* value;
+
+ res = (pdd_data_t) malloc(sizeof(struct pdd_data));
+ if (!res) {
+ rc = -ENOMEM;
+ goto err;
+ }
+ rc = bootenv_create(&pdd);
+ if (rc != 0) {
+ goto err;
+ }
+ rc = bootenv_read_txt(fp_pdd, pdd);
+ if (rc != 0) {
+ goto err;
+ }
+ rc = bootenv_get(pdd, "flash_type", &value);
+ if (rc != 0) {
+ goto err;
+ }
+
+ if (strcmp(value, "NAND") == 0) {
+ res->flash_type = NAND_FLASH;
+ res->vid_hdr_offset = NAND_DEFAULT_VID_HDR_OFF;
+ }
+ else if (strcmp(value, "NOR") == 0){
+ res->flash_type = NOR_FLASH;
+ res->vid_hdr_offset = NOR_DEFAULT_VID_HDR_OFF;
+ }
+ else {
+ snprintf(err_buf, err_buf_size,
+ "Unkown flash type: %s", value);
+ goto err;
+ }
+
+ rc = bootenv_get_num(pdd, "flash_eraseblock_size",
+ &(res->eb_size));
+ if (rc != 0) {
+ EBUF("Cannot read 'flash_eraseblock_size' from pdd.");
+ goto err;
+ }
+
+ rc = bootenv_get_num(pdd, "flash_size",
+ &(res->flash_size));
+ if (rc != 0) {
+ EBUF("Cannot read 'flash_size' from pdd.");
+ goto err;
+ }
+
+ goto out;
+ err:
+ if (res) {
+ free(res);
+ res = NULL;
+ }
+ out:
+ bootenv_destroy(&pdd);
+ *pdd_data = res;
+ return rc;
+}
+
+int
+read_pfi_raw(pfi_header pfi_hd, FILE* fp_pfi, pfi_raw_t* pfi_raw,
+ const char* label, char* err_buf, size_t err_buf_size)
+{
+ int rc = 0;
+ char tmp_str[PFI_KEYWORD_LEN];
+ bootenv_list_t raw_start_list = NULL;
+ pfi_raw_t res;
+
+ res = (pfi_raw_t) malloc(sizeof(struct pfi_raw));
+ if (!res)
+ return -ENOMEM;
+
+ rc = pfi_header_getnumber(pfi_hd, "size", &(res->data_size));
+ if (rc != 0) {
+ EBUF_PFI("Cannot read 'size' from PFI.");
+ goto err;
+ }
+
+ rc = pfi_header_getstring(pfi_hd, "raw_starts",
+ tmp_str, PFI_KEYWORD_LEN);
+ if (rc != 0) {
+ EBUF_PFI("Cannot read 'raw_starts' from PFI.");
+ goto err;
+ }
+
+ rc = bootenv_list_create(&raw_start_list);
+ if (rc != 0) {
+ goto err;
+ }
+
+ rc = bootenv_list_import(raw_start_list, tmp_str);
+ if (rc != 0) {
+ EBUF_PFI("Cannot translate PFI value: %s", tmp_str);
+ goto err;
+ }
+
+ rc = bootenv_list_to_num_vector(raw_start_list,
+ &(res->starts_size), &(res->starts));
+ if (rc != 0) {
+ EBUF_PFI("Cannot create numeric value array: %s", tmp_str);
+ goto err;
+ }
+
+ goto out;
+
+ err:
+ if (res) {
+ free(res);
+ res = NULL;
+ }
+ out:
+ bootenv_list_destroy(&raw_start_list);
+ *pfi_raw = res;
+ return rc;
+}
+
+int
+read_pfi_ubi(pfi_header pfi_hd, FILE* fp_pfi, pfi_ubi_t* pfi_ubi,
+ const char *label, char* err_buf, size_t err_buf_size)
+{
+ int rc = 0;
+ const char** tmp_names = NULL;
+ char tmp_str[PFI_KEYWORD_LEN];
+ bootenv_list_t ubi_id_list = NULL;
+ bootenv_list_t ubi_name_list = NULL;
+ pfi_ubi_t res;
+ uint32_t i;
+
+ res = (pfi_ubi_t) calloc(1, sizeof(struct pfi_ubi));
+ if (!res)
+ return -ENOMEM;
+
+ rc = pfi_header_getnumber(pfi_hd, "size", &(res->data_size));
+ if (rc != 0) {
+ EBUF_PFI("Cannot read 'size' from PFI.");
+ goto err;
+ }
+
+ rc = pfi_header_getstring(pfi_hd, "ubi_ids", tmp_str, PFI_KEYWORD_LEN);
+ if (rc != 0) {
+ EBUF_PFI("Cannot read 'ubi_ids' from PFI.");
+ goto err;
+ }
+
+ rc = bootenv_list_create(&ubi_id_list);
+ if (rc != 0) {
+ goto err;
+ }
+ rc = bootenv_list_create(&ubi_name_list);
+ if (rc != 0) {
+ goto err;
+ }
+
+ rc = bootenv_list_import(ubi_id_list, tmp_str);
+ if (rc != 0) {
+ EBUF_PFI("Cannot translate PFI value: %s", tmp_str);
+ goto err;
+ }
+
+ rc = bootenv_list_to_num_vector(ubi_id_list, &(res->ids_size),
+ &(res->ids));
+ if (rc != 0) {
+ EBUF_PFI("Cannot create numeric value array: %s", tmp_str);
+ goto err;
+ }
+
+ if (res->ids_size == 0) {
+ rc = -1;
+ EBUF_PFI("Sanity check failed: No ubi_ids specified.");
+ goto err;
+ }
+
+ rc = pfi_header_getstring(pfi_hd, "ubi_type",
+ tmp_str, PFI_KEYWORD_LEN);
+ if (rc != 0) {
+ EBUF_PFI("Cannot read 'ubi_type' from PFI.");
+ goto err;
+ }
+ if (strcmp(tmp_str, "static") == 0)
+ res->type = pfi_ubi_static;
+ else if (strcmp(tmp_str, "dynamic") == 0)
+ res->type = pfi_ubi_dynamic;
+ else {
+ EBUF_PFI("Unknown ubi_type in PFI.");
+ goto err;
+ }
+
+ rc = pfi_header_getnumber(pfi_hd, "ubi_alignment", &(res->alignment));
+ if (rc != 0) {
+ EBUF_PFI("Cannot read 'ubi_alignment' from PFI.");
+ goto err;
+ }
+
+ rc = pfi_header_getnumber(pfi_hd, "ubi_size", &(res->size));
+ if (rc != 0) {
+ EBUF_PFI("Cannot read 'ubi_size' from PFI.");
+ goto err;
+ }
+
+ rc = pfi_header_getstring(pfi_hd, "ubi_names",
+ tmp_str, PFI_KEYWORD_LEN);
+ if (rc != 0) {
+ EBUF_PFI("Cannot read 'ubi_names' from PFI.");
+ goto err;
+ }
+
+ rc = bootenv_list_import(ubi_name_list, tmp_str);
+ if (rc != 0) {
+ EBUF_PFI("Cannot translate PFI value: %s", tmp_str);
+ goto err;
+ }
+ rc = bootenv_list_to_vector(ubi_name_list, &(res->names_size),
+ &(tmp_names));
+ if (rc != 0) {
+ EBUF_PFI("Cannot create string array: %s", tmp_str);
+ goto err;
+ }
+
+ if (res->names_size != res->ids_size) {
+ EBUF_PFI("Sanity check failed: ubi_ids list does not match "
+ "sizeof ubi_names list.");
+ rc = -1;
+ }
+
+ /* copy tmp_names to own structure */
+ res->names = (char**) calloc(1, res->names_size * sizeof (char*));
+ if (res->names == NULL)
+ goto err;
+
+ for (i = 0; i < res->names_size; i++) {
+ res->names[i] = calloc(PFI_UBI_VOL_NAME_LEN + 1, sizeof(char));
+ if (res->names[i] == NULL)
+ goto err;
+ strncpy(res->names[i], tmp_names[i], PFI_UBI_VOL_NAME_LEN + 1);
+ }
+
+ goto out;
+
+ err:
+ if (res) {
+ if (res->names) {
+ for (i = 0; i < res->names_size; i++) {
+ if (res->names[i]) {
+ free(res->names[i]);
+ }
+ }
+ free(res->names);
+ }
+ if (res->ids) {
+ free(res->ids);
+ }
+ free(res);
+ res = NULL;
+ }
+
+ out:
+ bootenv_list_destroy(&ubi_id_list);
+ bootenv_list_destroy(&ubi_name_list);
+ if (tmp_names != NULL)
+ free(tmp_names);
+ *pfi_ubi = res;
+ return rc;
+}
+
+
+int
+free_pdd_data(pdd_data_t* pdd_data)
+{
+ if (*pdd_data) {
+ free(*pdd_data);
+ }
+ *pdd_data = NULL;
+
+ return 0;
+}
+
+int
+free_pfi_raw(pfi_raw_t* pfi_raw)
+{
+ pfi_raw_t tmp = *pfi_raw;
+ if (tmp) {
+ if (tmp->starts)
+ free(tmp->starts);
+ free(tmp);
+ }
+ *pfi_raw = NULL;
+
+ return 0;
+}
+
+int
+free_pfi_ubi(pfi_ubi_t* pfi_ubi)
+{
+ size_t i;
+ pfi_ubi_t tmp = *pfi_ubi;
+ if (tmp) {
+ if (tmp->ids)
+ free(tmp->ids);
+ if (tmp->names) {
+ for (i = 0; i < tmp->names_size; i++) {
+ if (tmp->names[i]) {
+ free(tmp->names[i]);
+ }
+ }
+ free(tmp->names);
+ }
+ free(tmp);
+ }
+ *pfi_ubi = NULL;
+
+ return 0;
+}
+
+
+int
+read_pfi_headers(list_t *pfi_raws, list_t *pfi_ubis, FILE* fp_pfi,
+ char* err_buf, size_t err_buf_size)
+{
+ int rc = 0;
+ char mode[PFI_KEYWORD_LEN];
+ char label[PFI_LABEL_LEN];
+
+ *pfi_raws = mk_empty(); pfi_raw_t raw = NULL;
+ *pfi_ubis = mk_empty(); pfi_ubi_t ubi = NULL;
+ pfi_header pfi_header = NULL;
+
+ /* read all headers from PFI and store them in lists */
+ rc = pfi_header_init(&pfi_header);
+ if (rc != 0) {
+ EBUF("Cannot initialize pfi header.");
+ goto err;
+ }
+ while ((rc == 0) && !feof(fp_pfi)) {
+ rc = pfi_header_read(fp_pfi, pfi_header);
+ if (rc != 0) {
+ if (rc == PFI_DATA_START) {
+ rc = 0;
+ break; /* data section starts,
+ all headers read */
+ }
+ else {
+ goto err;
+ }
+ }
+ rc = pfi_header_getstring(pfi_header, "label", label,
+ PFI_LABEL_LEN);
+ if (rc != 0) {
+ EBUF("Cannot read 'label' from PFI.");
+ goto err;
+ }
+ rc = pfi_header_getstring(pfi_header, "mode", mode,
+ PFI_KEYWORD_LEN);
+ if (rc != 0) {
+ EBUF("Cannot read 'mode' from PFI.");
+ goto err;
+ }
+ if (strcmp(mode, "ubi") == 0) {
+ rc = read_pfi_ubi(pfi_header, fp_pfi, &ubi, label,
+ err_buf, err_buf_size);
+ if (rc != 0) {
+ goto err;
+ }
+ *pfi_ubis = append_elem(ubi, *pfi_ubis);
+ }
+ else if (strcmp(mode, "raw") == 0) {
+ rc = read_pfi_raw(pfi_header, fp_pfi, &raw, label,
+ err_buf, err_buf_size);
+ if (rc != 0) {
+ goto err;
+ }
+ *pfi_raws = append_elem(raw, *pfi_raws);
+ }
+ else {
+ EBUF("Recvieved unknown mode from PFI: %s", mode);
+ goto err;
+ }
+ }
+ goto out;
+
+ err:
+ *pfi_raws = remove_all((free_func_t)&free_pfi_raw, *pfi_raws);
+ *pfi_ubis = remove_all((free_func_t)&free_pfi_ubi, *pfi_ubis);
+ out:
+ pfi_header_destroy(&pfi_header);
+ return rc;
+
+}
diff --git a/ubi-utils/src/libubi/libubi.c b/ubi-utils/src/libubi/libubi.c
new file mode 100644
index 0000000..9b9a793
--- /dev/null
+++ b/ubi-utils/src/libubi/libubi.c
@@ -0,0 +1,773 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * UBI (Unsorted Block Images) library.
+ *
+ * Author: Artem B. Bityutskiy
+ * Oliver Lohmann
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <limits.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <stdint.h>
+#include <mtd/ubi-user.h>
+
+#include "libubi.h"
+#include "libubi_int.h"
+#include "libubi_sysfs.h"
+
+/**
+ * struct ubi_lib - UBI library descriptor.
+ *
+ * @ubi general UBI information
+ *
+ * @sysfs_root sysfs root directory
+ * @ubi_root UBI root directory in sysfs
+ *
+ * @nlen_max full path to the "maximum volume name length" sysfs file
+ * @version full path to the "UBI version" sysfs file
+ *
+ * @cdev_path path pattern to UBI character devices
+ * @cdev_path_len maximum length of the @cdev_path string after substitution
+ * @udev_path path to sysfs directories corresponding to UBI devices
+ * @wear_path path to sysfs file containing UBI wear information
+ * @vol_count_path path to sysfs file containing the number of volumes in an
+ * UBI device
+ * @tot_ebs_path path to sysfs file containing the total number of
+ * eraseblock on an UBI device
+ * @avail_ebs_path path to sysfs file containing the number of unused
+ * eraseblocks on an UBI device, available for new volumes
+ * @eb_size_path path to sysfs file containing size of UBI eraseblocks
+ * @nums_path path to sysfs file containing major and minor number of an
+ * UBI device
+ * @vol_cdev_path path to UBI volume character devices
+ * @vdev_path path to sysfs directories corresponding to UBI volume
+ * devices
+ * @vol_nums_path path to sysfs file containing major and minor number of an
+ * UBI volume device
+ * @vol_bytes_path path to sysfs file containing size of an UBI volume device
+ * in bytes
+ * @vol_ebs_path path to sysfs file containing the number of eraseblocks in
+ * an UBI volume device
+ * @vol_type_path path to sysfs file containing type of an UBI volume
+ * @vol_name_path @FIXME: Describe me.
+ *
+ * This structure is created and initialized by 'ubi_init()' and is passed to
+ * all UBI library calls.
+ */
+struct ubi_lib
+{
+ struct ubi_info ubi;
+
+ char *sysfs_root;
+ char *ubi_root;
+
+ char *nlen_max;
+ char *version;
+ char *cdev_path;
+ int cdev_path_len;
+ char *udev_path;
+ char *wear_path;
+ char *vol_count_path;
+ char *tot_ebs_path;
+ char *avail_ebs_path;
+ char *eb_size_path;
+ char *nums_path;
+ int vol_cdev_path_len;
+ char *vol_cdev_path;
+ char *vdev_path;
+ char *vol_nums_path;
+ char *vol_bytes_path;
+ char *vol_ebs_path;
+ char *vol_type_path;
+ char *vol_name_path;
+};
+
+
+/**
+ * mkpath - compose full path from 2 given components.
+ *
+ * @path first component @name second component
+ *
+ * Returns the resulting path in case of success and %NULL in case of failure.
+ * Callers have to take care the resulting path is freed.
+ */
+static char*
+mkpath(const char *path, const char *name)
+{
+ char *n;
+ int len1 = strlen(path);
+ int len2 = strlen(name);
+
+ n = malloc(len1 + len2 + 2);
+ if (!n)
+ return NULL;
+
+ memcpy(n, path, len1);
+ if (n[len1 - 1] != '/')
+ n[len1++] = '/';
+
+ memcpy(n + len1, name, len2 + 1);
+ return n;
+}
+
+
+static int
+get_ubi_info(ubi_lib_t desc, struct ubi_info *ubi)
+{
+ int err;
+ int n = 1;
+ char *path;
+ struct stat stat;
+
+ err = sysfs_read_int(desc->version, (int*) &ubi->version);
+ if (err)
+ return -1;
+
+ err = sysfs_read_int(desc->nlen_max, (int*) &ubi->nlen_max);
+ if (err)
+ return -1;
+
+ /* Calculate number of UBI devices */
+ do {
+ char dir[20];
+
+ sprintf(&dir[0], "ubi%d", n);
+ path = mkpath(desc->sysfs_root, dir);
+ if (!path)
+ return ENOMEM;
+
+ err = lstat(path, &stat);
+ if (err == 0)
+ n += 1;
+ free(path);
+ } while (err == 0);
+
+ if (errno != ENOENT)
+ return -1;
+
+ if (n == 0) {
+ ubi_err("no UBI devices found");
+ errno = EINVAL;
+ return -1;
+ }
+
+ errno = 0;
+ ubi->dev_count = n;
+ return 0;
+}
+
+void
+ubi_dump_handler(ubi_lib_t desc)
+{
+ ubi_lib_t d = desc;
+ printf( "UBI Library Descriptor:\n"
+ "ubi_root: %s\n"
+ "nlen_max: %s\n"
+ "version: %s\n"
+ "cdev_path: %s\n"
+ "udev_path: %s\n"
+ "wear_path: %s\n"
+ "vol_count_path: %s\n"
+ "tot_ebs_path: %s\n"
+ "avail_ebs_path: %s\n"
+ "eb_size_path: %s\n"
+ "nums_path: %s\n"
+ "vol_cdev_path: %s\n"
+ "vdev_path: %s\n"
+ "vol_nums_path: %s\n"
+ "vol_bytes_path: %s\n"
+ "vol_ebs_path: %s\n"
+ "vol_type_path: %s\n"
+ "vol_name_path: %s\n"
+ "cdev_path_len: %d\n\n",
+ d->ubi_root, d->nlen_max, d->version, d->cdev_path,
+ d->udev_path, d->wear_path, d->vol_count_path,
+ d->tot_ebs_path, d->avail_ebs_path, d->eb_size_path,
+ d->nums_path, d->vol_cdev_path, d->vdev_path,
+ d->vol_nums_path, d->vol_bytes_path, d->vol_ebs_path,
+ d->vol_type_path, d->vol_name_path, d->cdev_path_len);
+}
+
+int
+ubi_set_cdev_pattern(ubi_lib_t desc, const char *pattern)
+{
+ char *patt;
+
+ patt = strdup(pattern);
+ if (!patt) {
+ ubi_err("cannot allocate memory");
+ return -1;
+ }
+
+ if (desc->cdev_path)
+ free(desc->cdev_path);
+
+ desc->cdev_path = patt;
+ desc->cdev_path_len = strlen(patt) + 1 + UBI_MAX_ID_SIZE;
+
+ ubi_dbg("ubi dev pattern is now \"%s\"", patt);
+
+ return 0;
+}
+
+int
+ubi_set_vol_cdev_pattern(ubi_lib_t desc, const char *pattern)
+{
+ char *patt;
+
+ patt = strdup(pattern);
+ if (!patt) {
+ ubi_err("cannot allocate memory");
+ return -1;
+ }
+
+ free(desc->vol_cdev_path);
+ desc->vol_cdev_path = patt;
+ desc->vol_cdev_path_len = strlen(patt) + 1 + 2 * UBI_MAX_ID_SIZE;
+
+ ubi_dbg("ubi volume dev pattern is now \"%s\"", patt);
+
+ return 0;
+}
+
+int
+ubi_open(ubi_lib_t *desc)
+{
+ int err = -1;
+ ubi_lib_t res;
+ struct stat stat;
+
+ res = calloc(1, sizeof(struct ubi_lib));
+ if (!res) {
+ ubi_err("cannot allocate memory");
+ return -1;
+ }
+
+ res->cdev_path = NULL;
+ err = ubi_set_cdev_pattern(res, UBI_CDEV_PATH);
+ if (err)
+ goto error;
+
+ /* TODO: this actually has to be discovered */
+ res->sysfs_root = strdup(UBI_SYSFS_ROOT);
+ if (!res->sysfs_root)
+ goto error;
+
+ res->ubi_root = mkpath(res->sysfs_root, UBI_ROOT);
+ if (!res->ubi_root)
+ goto error;
+
+ res->nlen_max = mkpath(res->ubi_root, UBI_NLEN_MAX);
+ if (!res->nlen_max)
+ goto error;
+
+ res->version = mkpath(res->ubi_root, UBI_VERSION);
+ if (!res->version)
+ goto error;
+
+ res->udev_path = mkpath(res->ubi_root, "ubi%d/");
+ if (!res->udev_path)
+ goto error;
+
+ res->wear_path = mkpath(res->udev_path, UBI_WEAR);
+ if (!res->wear_path)
+ goto error;
+
+ res->vol_count_path = mkpath(res->udev_path, UBI_VOL_COUNT);
+ if (!res->vol_count_path)
+ goto error;
+
+ res->tot_ebs_path = mkpath(res->udev_path, UBI_AVAIL_EBS);
+ if (!res->tot_ebs_path)
+ goto error;
+
+ res->avail_ebs_path = mkpath(res->udev_path, UBI_TOT_EBS);
+ if (!res->avail_ebs_path)
+ goto error;
+
+ res->eb_size_path = mkpath(res->udev_path, UBI_EB_SIZE);
+ if (!res->eb_size_path)
+ goto error;
+
+ res->nums_path = mkpath(res->udev_path, UBI_NUMS);
+ if (!res->nums_path)
+ goto error;
+
+ err = ubi_set_vol_cdev_pattern(res, UBI_VOL_CDEV_PATH);
+ if (err)
+ goto error;
+
+ res->vdev_path = mkpath(res->udev_path, "%d/");
+ if (!res->vdev_path)
+ goto error;
+
+ res->vol_nums_path = mkpath(res->vdev_path, UBI_NUMS);
+ if (!res->vol_nums_path)
+ goto error;
+
+ res->vol_bytes_path = mkpath(res->vdev_path, UBI_VBYTES);
+ if (!res->vol_bytes_path)
+ goto error;
+
+ res->vol_ebs_path = mkpath(res->vdev_path, UBI_VEBS);
+ if (!res->vol_ebs_path)
+ goto error;
+
+ res->vol_type_path = mkpath(res->vdev_path, UBI_VTYPE);
+ if (!res->vol_type_path)
+ goto error;
+
+ res->vol_name_path = mkpath(res->vdev_path, UBI_VNAME);
+ if (!res->vol_name_path)
+ goto error;
+
+ /* Check if UBI exists in the system */
+ err = lstat(res->ubi_root, &stat);
+ if (err) {
+ perror("lstat");
+ fprintf(stderr, "%s\n", res->ubi_root);
+ err = UBI_ENOTFOUND;
+ goto error;
+ }
+
+ err = get_ubi_info(res, &res->ubi);
+ if (err)
+ goto error;
+
+ *desc = res;
+
+ ubi_dbg("opened library successfully.");
+
+ return 0;
+
+error:
+ ubi_close(&res);
+
+ if (err == -1 && errno == ENOMEM)
+ ubi_err("Cannot allocate memory");
+
+ return err;
+}
+
+int
+ubi_close(ubi_lib_t *desc)
+{
+ ubi_lib_t tmp = *desc;
+
+ free(tmp->vol_name_path);
+ free(tmp->vol_type_path);
+ free(tmp->vol_ebs_path);
+ free(tmp->vol_bytes_path);
+ free(tmp->vol_nums_path);
+ free(tmp->vdev_path);
+ free(tmp->vol_cdev_path);
+ free(tmp->nums_path);
+ free(tmp->eb_size_path);
+ free(tmp->avail_ebs_path);
+ free(tmp->tot_ebs_path);
+ free(tmp->vol_count_path);
+ free(tmp->wear_path);
+ free(tmp->udev_path);
+ free(tmp->cdev_path);
+ free(tmp->version);
+ free(tmp->nlen_max);
+ free(tmp->ubi_root);
+ free(tmp->sysfs_root);
+ free(tmp);
+
+ *desc = NULL;
+
+ return 0;
+}
+
+void
+ubi_perror(const char *prefix, int code)
+{
+ if (code == 0)
+ return;
+
+ fprintf(stderr, "%s: ", prefix);
+
+ switch (code) {
+ case UBI_ENOTFOUND:
+ fprintf(stderr, "UBI was not found in system\n");
+ break;
+ case UBI_EBUG:
+ fprintf(stderr, "an UBI or UBI library bug\n");
+ break;
+ case UBI_EINVAL:
+ fprintf(stderr, "invalid parameter\n");
+ break;
+ case -1:
+ perror(prefix);
+ break;
+ default:
+ ubi_err("unknown error code %d", code);
+ break;
+ }
+}
+
+int
+ubi_get_dev_info(ubi_lib_t desc, unsigned int devn, struct ubi_dev_info *di)
+{
+ int err;
+
+ if (devn >= desc->ubi.dev_count) {
+ ubi_err("bad device number, max is %d\n",
+ desc->ubi.dev_count - 1);
+ return UBI_EINVAL;
+ }
+
+ err = sysfs_read_dev_subst(desc->nums_path, &di->major,
+ &di->minor, 1, devn);
+ if (err)
+ return -1;
+
+ err = sysfs_read_ull_subst(desc->wear_path, &di->wear, 1, devn);
+ if (err)
+ return -1;
+
+ err = sysfs_read_uint_subst(desc->vol_count_path,
+ &di->vol_count, 1, devn);
+ if (err)
+ return -1;
+
+ err = sysfs_read_uint_subst(desc->eb_size_path, &di->eb_size, 1, devn);
+ if (err)
+ return -1;
+
+ err = sysfs_read_uint_subst(desc->tot_ebs_path, &di->total_ebs, 1, devn);
+ if (err)
+ return -1;
+
+ err = sysfs_read_uint_subst(desc->avail_ebs_path,
+ &di->avail_ebs, 1, devn);
+ if (err)
+ return -1;
+
+#if 0
+ ubi_dbg("major:minor %d:%d, wear %llu, EB size %d, "
+ "vol. count %d, tot. EBs %d, avail. EBs %d",
+ di->major, di->minor, di->wear, di->eb_size,
+ di->vol_count, di->total_ebs, di->avail_ebs);
+#endif
+
+ return err;
+}
+
+int
+ubi_get_vol_info(ubi_lib_t desc, unsigned int devn, unsigned int vol_id,
+ struct ubi_vol_info *req)
+{
+ int err;
+ int len;
+ char buf1[10];
+ char buf2[desc->ubi.nlen_max];
+
+ err = sysfs_read_dev_subst(desc->vol_nums_path, &req->major,
+ &req->minor, 2, devn, vol_id);
+ if (err)
+ return -1;
+
+ err = sysfs_read_ull_subst(desc->vol_bytes_path,
+ &req->bytes, 2, devn, vol_id);
+ if (err)
+ return -1;
+
+ err = sysfs_read_uint_subst(desc->vol_ebs_path,
+ &req->eraseblocks, 2, devn, vol_id);
+ if (err)
+ return -1;
+
+ len = sysfs_read_data_subst(desc->vol_type_path, &buf1[0],
+ 10, 2, devn, vol_id);
+ if (len == -1)
+ return -1;
+
+ if (buf1[len - 1] != '\n') {
+ ubi_err("bad volume type");
+ return UBI_EBUG;
+ }
+
+ if (!strncmp(&buf1[0], "static", sizeof("static") - 1)) {
+ req->type = UBI_STATIC_VOLUME;
+ } else if (!strncmp(&buf1[0], "dynamic", sizeof("dynamic") - 1)) {
+ req->type = UBI_DYNAMIC_VOLUME;
+ } else {
+ ubi_err("bad type %s", &buf1[0]);
+ return -1;
+ }
+
+ len = sysfs_read_data_subst(desc->vol_name_path, &buf2[0],
+ desc->ubi.nlen_max, 2, devn, vol_id);
+ if (len == -1)
+ return -1;
+
+ if (buf2[len - 1] != '\n') {
+ ubi_err("bad volume name");
+ return UBI_EBUG;
+ }
+
+ req->name = malloc(len);
+ if (!req->name) {
+ ubi_err("cannot allocate memory");
+ return -1;
+ }
+
+ memcpy(req->name, &buf2[0], len - 1);
+ req->name[len - 1] = '\0';
+
+ return 0;
+}
+
+/**
+ * ubi_cdev_open - open a UBI device
+ *
+ * @desc UBI library descriptor
+ * @devn Number of UBI device to open
+ * @flags Flags to pass to open()
+ *
+ * This function opens a UBI device by number and returns a file
+ * descriptor. In case of an error %-1 is returned and errno is set
+ * appropriately.
+ */
+static int
+ubi_cdev_open(ubi_lib_t desc, int devn, int flags)
+{
+ char *buf;
+ int fd;
+
+ ubi_dbg("desc=%p, devn=%d, flags=%08x\n", desc, devn, flags);
+
+ if (desc == NULL) {
+ ubi_err("desc is NULL\n");
+ return -1;
+ }
+ if (desc->vol_cdev_path_len == 0) {
+ ubi_err("path_len == 0\n");
+ return -1;
+ }
+ buf = malloc(desc->cdev_path_len);
+
+ sprintf(buf, desc->cdev_path, devn);
+
+ fd = open(buf, flags);
+ if (fd == -1)
+ ubi_dbg("cannot open %s", buf);
+
+ free(buf);
+ return fd;
+}
+
+/**
+ * ubi_cdev_close - close a UBI device
+ *
+ * @dev_fd file descriptor of UBI device to close
+ *
+ * This function closes the given UBI device.
+ */
+static int
+ubi_cdev_close(int dev_fd)
+{
+ return close(dev_fd);
+}
+
+/**
+ * @size is now in bytes.
+ */
+int
+ubi_mkvol(ubi_lib_t desc, int devn, int vol_id, int vol_type,
+ long long bytes, int alignment, const char *name)
+{
+ int fd;
+ int err;
+ struct ubi_mkvol_req req;
+
+ if ((fd = ubi_cdev_open(desc, devn, O_RDWR)) == -1)
+ return -1;
+
+ req.vol_id = vol_id;
+ req.bytes = bytes;
+ req.vol_type = vol_type;
+ req.alignment = alignment;
+ req.name_len = strlen(name);
+ req.name = name;
+
+ /* printf("DBG: %s(vol_id=%d, bytes=%lld, type=%d, alig=%d, nlen=%d, "
+ "name=%s)\n", __func__, vol_id, bytes, vol_type, alignment,
+ strlen(name), name);*/
+
+ err = ioctl(fd, UBI_IOCMKVOL, &req);
+ if (err < 0) {
+ ubi_err("ioctl returned %d errno=%d\n", err, errno);
+ goto out_close;
+ }
+
+ ubi_dbg("created volume %d, size %lld, name \"%s\" "
+ "at UBI dev %d\n", vol_id, bytes, name, devn);
+
+ close(fd);
+ return err;
+ out_close:
+ ubi_cdev_close(fd);
+ return err;
+}
+
+int
+ubi_rmvol(ubi_lib_t desc, int devn, int vol_id)
+{
+ int fd;
+ int err;
+
+ if ((fd = ubi_cdev_open(desc, devn, O_RDWR)) == -1)
+ return -1;
+
+ err = ioctl(fd, UBI_IOCRMVOL, &vol_id);
+ if (err < 0)
+ goto out_close;
+
+ ubi_dbg("removed volume %d", vol_id);
+
+ out_close:
+ ubi_cdev_close(fd);
+ return err;
+}
+
+int
+ubi_get_info(ubi_lib_t desc, struct ubi_info *ubi)
+{
+ memcpy(ubi, &desc->ubi, sizeof(struct ubi_info));
+ return 0;
+}
+
+
+int
+ubi_vol_open(ubi_lib_t desc, int devn, int vol_id, int flags)
+{
+ char *buf;
+ int fd;
+
+ ubi_dbg("desc=%p, devn=%d, vol_id=%d, flags=%08x\n",
+ desc, devn, vol_id, flags);
+
+ if (desc == NULL) {
+ ubi_err("desc is NULL\n");
+ return -1;
+ }
+ if (desc->vol_cdev_path_len == 0) {
+ ubi_err("path_len == 0\n");
+ return -1;
+ }
+ buf = malloc(desc->cdev_path_len);
+
+ sprintf(buf, desc->vol_cdev_path, devn, vol_id);
+
+ fd = open(buf, flags);
+ if (fd == -1)
+ ubi_dbg("cannot open %s", buf);
+
+ free(buf);
+ return fd;
+}
+
+int
+ubi_vol_close(int vol_fd)
+{
+ return close(vol_fd);
+}
+
+
+int
+ubi_vol_update(int vol_fd, unsigned long long bytes)
+{
+ int err;
+
+ err = ioctl(vol_fd, UBI_IOCVOLUP, &bytes);
+ if (err) {
+ ubi_err("%s failure calling update ioctl\n"
+ " IOCTL(%08x) err=%d errno=%d\n",
+ __func__, UBI_IOCVOLUP, err, errno);
+ }
+ return err;
+}
+
+FILE *
+ubi_vol_fopen_read(ubi_lib_t desc, int devn, uint32_t vol_id)
+{
+ FILE *fp;
+ int fd;
+
+ fd = ubi_vol_open(desc, devn, vol_id, O_RDONLY);
+ if (fd == -1)
+ return NULL;
+
+ fp = fdopen(fd, "r");
+ if (fp == NULL)
+ ubi_vol_close(fd);
+
+ return fp;
+}
+
+FILE *
+ubi_vol_fopen_update(ubi_lib_t desc, int devn, uint32_t vol_id,
+ unsigned long long bytes)
+{
+ FILE *fp;
+ int fd;
+ int err;
+
+ fd = ubi_vol_open(desc, devn, vol_id, O_RDWR);
+ if (fd == -1)
+ return NULL;
+
+ fp = fdopen(fd, "r+");
+ if (fp == NULL) {
+ printf("DBG: %s(errno=%d)\n", __func__, errno);
+ ubi_vol_close(fd);
+ return NULL;
+ }
+ err = ubi_vol_update(fd, bytes);
+ if (err < 0) {
+ printf("DBG: %s() fd=%d err=%d\n", __func__, fd, err);
+ fclose(fp);
+ return NULL;
+ }
+ return fp;
+}
+
+int
+ubi_vol_get_used_bytes(int vol_fd, unsigned long long *bytes)
+{
+ off_t res;
+
+ res = lseek(vol_fd, 0, SEEK_END);
+ if (res == (off_t)-1)
+ return -1;
+ *bytes = (unsigned long long) res;
+ res = lseek(vol_fd, 0, SEEK_SET);
+ return res == (off_t)-1 ? -1 : 0;
+}
diff --git a/ubi-utils/src/libubi/libubi_int.h b/ubi-utils/src/libubi/libubi_int.h
new file mode 100644
index 0000000..1640010
--- /dev/null
+++ b/ubi-utils/src/libubi/libubi_int.h
@@ -0,0 +1,119 @@
+#ifndef __UBI_INT_H__
+#define __UBI_INT_H__
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * UBI (Unsorted Block Images) library.
+ *
+ * Author: Artem B. Bityutskiy
+ */
+
+/*
+ * Enable/disable UBI library debugging messages.
+ */
+#undef UBILIB_DEBUG
+
+/*
+ * UBI library error message.
+ */
+#define ubi_err(fmt, ...) do { \
+ fprintf(stderr, "UBI Library Error at %s: ", __func__); \
+ fprintf(stderr, fmt, ##__VA_ARGS__); \
+ fprintf(stderr, "\n"); \
+ } while(0)
+
+#ifdef UBILIB_DEBUG
+#define ubi_dbg(fmt, ...) do { \
+ fprintf(stderr, "UBI Debug: %s: ", __func__); \
+ fprintf(stderr, fmt, ##__VA_ARGS__); \
+ fprintf(stderr, "\n"); \
+ } while(0)
+
+#else
+#define ubi_dbg(fmt, ...)
+#endif
+
+/**
+ * SYSFS Entries.
+ *
+ * @def UBI_ROOT
+ * @brief Name of the root UBI directory in sysfs.
+ *
+ * @def UBI_NLEN_MAX
+ * @brief Name of syfs file containing the maximum UBI volume name length.
+ *
+ * @def UBI_VERSION
+ * @brief Name of sysfs file containing UBI version.
+ *
+ * @def UBI_WEAR
+ * @brief Name of sysfs file containing wear level of an UBI device.
+ *
+ * @def UBI_VOL_COUNT
+ * @brief Name of sysfs file contaning the of volume on an UBI device
+ *
+ * @def UBI_TOT_EBS
+ * @brief Name of sysfs file contaning the total number of
+ * eraseblocks on an UBI device.
+ *
+ * @def UBI_AVAIL_EBS
+ * @brief Name of sysfs file contaning the number of unused eraseblocks on
+ * an UBI device.
+ *
+ * @def UBI_EB_SIZE
+ * @brief Name of sysfs file containing size of UBI eraseblocks.
+ *
+ * @def UBI_NUMS
+ * @brief Name of sysfs file containing major and minor numbers
+ * of an UBI device or an UBI volume device.
+ *
+ * @def UBI_VBYTES
+ * @brief Name of sysfs file containing size of an UBI volume device in
+ * bytes.
+ *
+ * @def UBI_VEBS
+ * @brief Name of sysfs file containing size of an UBI volume device in
+ * eraseblocks.
+ *
+ * @def UBI_VTYPE
+ * @brief Name of sysfs file containing type of an UBI volume device.
+ *
+ * @def UBI_VNAME
+ * @brief Name of sysfs file containing name of an UBI volume device.
+ **/
+#define UBI_ROOT "ubi"
+#define UBI_NLEN_MAX "volume_name_max"
+#define UBI_VERSION "version"
+#define UBI_WEAR "wear"
+#define UBI_VOL_COUNT "volumes_count"
+#define UBI_TOT_EBS "total_eraseblocks"
+#define UBI_AVAIL_EBS "avail_eraseblocks"
+#define UBI_EB_SIZE "eraseblock_size"
+#define UBI_NUMS "dev"
+#define UBI_VBYTES "bytes"
+#define UBI_VEBS "eraseblocks"
+#define UBI_VTYPE "type"
+#define UBI_VNAME "name"
+
+#define UBI_CDEV_PATH "/dev/ubi%d"
+#define UBI_VOL_CDEV_PATH "/dev/ubi%d_%d"
+#define UBI_SYSFS_ROOT "/sys/class"
+
+#define UBI_MAX_ID_SIZE 9
+
+#endif /* !__UBI_INT_H__ */
diff --git a/ubi-utils/src/libubi/libubi_sysfs.c b/ubi-utils/src/libubi/libubi_sysfs.c
new file mode 100644
index 0000000..f7ecebc
--- /dev/null
+++ b/ubi-utils/src/libubi/libubi_sysfs.c
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * UBI (Unsorted Block Images) library.
+ *
+ * Author: Artem B. Bityutskiy
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <limits.h>
+#include <errno.h>
+#include <stdarg.h>
+
+#include "libubi_int.h"
+
+int
+sysfs_read_data(const char *file, void *buf, int len)
+{
+ int fd;
+ ssize_t rd;
+
+ fd = open(file, O_RDONLY);
+ if (fd == -1) {
+ ubi_err("cannot open file %s", file);
+ return -1;
+ }
+
+ rd = read(fd, buf, len);
+ if (rd == -1)
+ ubi_err("cannot read file %s", file);
+
+ close(fd);
+
+ return rd;
+}
+
+int
+sysfs_read_data_subst(const char *patt, void *buf, int len, int n, ...)
+{
+ va_list args;
+ char buf1[strlen(patt) + 20 * n];
+
+ va_start(args, n);
+ vsprintf(&buf1[0], patt, args);
+ va_end(args);
+
+ return sysfs_read_data(&buf1[0], buf, len);
+}
+
+int
+sysfs_read_dev(const char *file, unsigned int *major, unsigned int *minor)
+{
+ int fd;
+ int ret;
+ ssize_t rd;
+ int err = -1;
+ char buf[40];
+
+ fd = open(file, O_RDONLY);
+ if (fd == -1) {
+ ubi_err("cannot open file %s", file);
+ return -1;
+ }
+
+ rd = read(fd, &buf[0], 20);
+ if (rd == -1) {
+ ubi_err("cannot read file %s", file);
+ goto error;
+ }
+ if (rd < 4) {
+ ubi_err("bad contents of file %s:", file);
+ goto error;
+ }
+
+ err = -1;
+ if (buf[rd -1] != '\n') {
+ ubi_err("bad contents of file %s", file);
+ goto error;
+ }
+
+ ret = sscanf(&buf[0], "%d:%d\n", major, minor);
+ if (ret != 2) {
+ ubi_err("bad contents of file %s", file);
+ goto error;
+ }
+
+ err = 0;
+
+error:
+ close(fd);
+
+ return err;
+}
+
+int
+sysfs_read_dev_subst(const char *patt, unsigned int *major,
+ unsigned int *minor, int n, ...)
+{
+ va_list args;
+ char buf[strlen(patt) + 20 * n];
+
+ va_start(args, n);
+ vsprintf(&buf[0], patt, args);
+ va_end(args);
+
+ return sysfs_read_dev(&buf[0], major, minor);
+}
+
+static int
+sysfs_read_ull(const char *file, unsigned long long *num)
+{
+ return 0;
+}
+
+int
+sysfs_read_ull_subst(const char *patt, unsigned long long *num, int n, ...)
+{
+ va_list args;
+ char buf[strlen(patt) + 20 * n];
+
+ va_start(args, n);
+ vsprintf(&buf[0], patt, args);
+ va_end(args);
+
+ return sysfs_read_ull(&buf[0], num);
+}
+
+static int
+sysfs_read_uint(const char *file, unsigned int *num)
+{
+ return 0;
+}
+
+int
+sysfs_read_uint_subst(const char *patt, unsigned int *num, int n, ...)
+{
+ va_list args;
+ char buf[strlen(patt) + 20 * n];
+
+ va_start(args, n);
+ vsprintf(&buf[0], patt, args);
+ va_end(args);
+
+ return sysfs_read_uint(&buf[0], num);
+}
+
+int
+sysfs_read_ll(const char *file, long long *num)
+{
+ int fd;
+ ssize_t rd;
+ int err = -1;
+ char buf[20];
+ char *endptr;
+
+ fd = open(file, O_RDONLY);
+ if (fd == -1)
+ return -1;
+
+ rd = read(fd, &buf[0], 20);
+ if (rd == -1)
+ goto out;
+
+ if (rd < 2) {
+ ubi_err("bad contents in file %s: \"%c%c...\"",
+ file, buf[0], buf[1]);
+ goto out_errno;
+ }
+
+ *num = strtoll(&buf[0], &endptr, 10);
+ if (endptr == &buf[0] || *endptr != '\n') {
+ ubi_err("bad contents in file %s: \"%c%c...\"",
+ file, buf[0], buf[1]);
+ goto out_errno;
+ }
+
+ if (*num < 0) {
+ ubi_err("bad number in file %s: %lld", file, *num);
+ goto out_errno;
+ }
+
+ err = 0;
+
+out_errno:
+ errno = EINVAL;
+
+out:
+ close(fd);
+ return err;
+}
+
+int
+sysfs_read_int(const char *file, int *num)
+{
+ int err;
+ long long res = 0;
+
+ err = sysfs_read_ll(file, &res);
+ if (err)
+ return err;
+
+ if (res < 0 || res > INT_MAX) {
+ ubi_err("bad number in file %s: %lld", file, res);
+ errno = EINVAL;
+ return -1;
+ }
+
+ *num = res;
+ return 0;
+}
diff --git a/ubi-utils/src/libubi/libubi_sysfs.h b/ubi-utils/src/libubi/libubi_sysfs.h
new file mode 100644
index 0000000..2fb6072
--- /dev/null
+++ b/ubi-utils/src/libubi/libubi_sysfs.h
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * UBI (Unsorted Block Images) library.
+ *
+ * Author: Artem B. Bityutskiy
+ */
+
+/**
+ * sysfs_read_data - read data from a sysfs file.
+ *
+ * @file path to the file to read from
+ * @buf furrer where to store read data
+ * @len length of provided buffer @buf
+ *
+ * This function returns the number of read bytes or -1 in case of error.
+ */
+int sysfs_read_data(const char *file, void *buf, int len);
+
+/**
+ * sysfs_read_data_subst - form path to a sysfs file and read data from it.
+ *
+ * @patt path to the file to read from
+ * @buf furrer where to store read data
+ * @len length of provided buffer @buf
+ * @n number of parameters to substitute to @patt
+ *
+ * This function forms path to a sysfs file by means of substituting parameters
+ * to @patt and then reads @len bytes from this file and stores the read data
+ * to @buf. This function returns the number of read bytes or -1 in case of
+ * error.
+ */
+int sysfs_read_data_subst(const char *patt, void *buf, int len, int n, ...);
+
+/**
+ * sysfs_read_dev - read major and minor number from a sysfs file.
+ *
+ * @file path to the file to read from
+ * @major major number is returned here
+ * @minor minor number is returned here
+ */
+int sysfs_read_dev(const char *file, unsigned int *major,
+ unsigned int *minor);
+/**
+ * sysfs_read_dev_subst - for path to a file and read major and minor number
+ * from it.
+ *
+ * @patt pattern of the path to the file to read from
+ * @major major number is returned here
+ * @minor minor number is returned here
+ * @n number of arguments to substitute
+ *
+ * This function substitures arguments to the @patt file path pattern and reads
+ * major and minor numbers from the resulting file.
+ */
+int sysfs_read_dev_subst(const char *patt, unsigned int *major,
+ unsigned int *minor, int n, ...);
+
+/**
+ * sysfs_read_ull_subst - form path to a sysfs file and read an unsigned long
+ * long value from there.
+ *
+ * @patt pattern of file path
+ * @num the read value is returned here
+ * @n number of parameters to substitute
+ *
+ *
+ * This function first forms the path to a sysfs file by means of substituting
+ * passed parameters to the @patt string, and then read an 'unsigned long long'
+ * value from this file.
+ */
+int sysfs_read_ull_subst(const char *patt, unsigned long long *num,
+ int n, ...);
+
+/**
+ * sysfs_read_uint_subst - the same as 'sysfs_read_uint_subst()' but reads an
+ * unsigned int value.
+ */
+int sysfs_read_uint_subst(const char *patt, unsigned int *num,
+ int n, ...);
+
+/**
+ * sysfs_read_ll - read a long long integer from an UBI sysfs file.
+ *
+ * @file file name from where to read
+ * @num the result is returned here
+ */
+int sysfs_read_ll(const char *file, long long *num);
+
+/**
+ * sysfs_read_int - the same as 'sysfs_read_ll()' but reads an 'int' value.
+ */
+int sysfs_read_int(const char *file, int *num);
diff --git a/ubi-utils/src/libubigen/ubigen.c b/ubi-utils/src/libubigen/ubigen.c
new file mode 100644
index 0000000..0cfa687
--- /dev/null
+++ b/ubi-utils/src/libubigen/ubigen.c
@@ -0,0 +1,486 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Oliver Lohmann
+ *
+ * Add UBI headers to binary data.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <mtd/ubi-header.h>
+
+#include "config.h"
+#include "ubigen.h"
+#include "crc32.h"
+
+#define UBI_NAME_SIZE 256
+#define DEFAULT_VID_OFFSET ((DEFAULT_PAGESIZE) - (UBI_VID_HDR_SIZE))
+#define MIN(a,b) ((a) < (b) ? (a) : (b))
+
+static uint32_t crc32_table[256];
+
+struct ubi_info {
+ struct ubi_vid_hdr* v; /* Volume ID header */
+ struct ubi_ec_hdr* ec; /* Erase count header */
+
+ FILE* fp_in; /* Input Stream */
+ FILE* fp_out; /* Output stream */
+
+ size_t eb_size; /* Physical EB size in bytes */
+ size_t leb_size; /* Size of a logical EB in a physical EB */
+ size_t leb_total; /* Total input size in logical EB */
+ size_t alignment; /* Block alignment */
+ size_t data_pad; /* Size of padding in each physical EB */
+
+ size_t bytes_total; /* Total input size in bytes */
+ size_t bytes_read; /* Nymber of read bytes (total) */
+
+ uint32_t blks_written; /* Number of written logical EB */
+
+ uint8_t* buf; /* Allocated buffer */
+ uint8_t* ptr_ec_hdr; /* Pointer to EC hdr in buf */
+ uint8_t* ptr_vid_hdr; /* Pointer to VID hdr in buf */
+ uint8_t* ptr_data; /* Pointer to data region in buf */
+};
+
+
+static uint32_t
+byte_to_blk(uint64_t byte, uint32_t eb_size)
+{
+ return (byte % eb_size) == 0
+ ? (byte / eb_size)
+ : (byte / eb_size) + 1;
+}
+
+static int
+validate_ubi_info(ubi_info_t u)
+{
+ if ((u->v->vol_type != UBI_VID_DYNAMIC) &&
+ (u->v->vol_type != UBI_VID_STATIC)) {
+ return EUBIGEN_INVALID_TYPE;
+ }
+
+ if (ubi32_to_cpu(u->ec->vid_hdr_offset) < UBI_VID_HDR_SIZE) {
+ return EUBIGEN_INVALID_HDR_OFFSET;
+ }
+
+ return 0;
+}
+
+static int
+skip_blks(ubi_info_t u, uint32_t blks)
+{
+ uint32_t i;
+ size_t read = 0, to_read = 0;
+
+ /* Step to a maximum of leb_total - 1 to keep the
+ restrictions. */
+ for (i = 0; i < MIN(blks, u->leb_total-1); i++) {
+ /* Read in data */
+ to_read = MIN(u->leb_size,
+ (u->bytes_total - u->bytes_read));
+ read = fread(u->ptr_data, 1, to_read, u->fp_in);
+ if (read != to_read) {
+ return -EIO;
+ }
+ u->bytes_read += read;
+ u->blks_written++;
+ }
+
+ return 0;
+}
+
+static void
+clear_buf(ubi_info_t u)
+{
+ memset(u->buf, 0xff, u->eb_size);
+}
+
+static void
+write_ec_hdr(ubi_info_t u)
+{
+ memcpy(u->ptr_ec_hdr, u->ec, UBI_EC_HDR_SIZE);
+}
+
+static int
+fill_data_buffer_from_file(ubi_info_t u, size_t* read)
+{
+ size_t to_read = 0;
+
+ if (u-> fp_in == NULL)
+ return -EIO;
+
+ to_read = MIN(u->leb_size, (u->bytes_total - u->bytes_read));
+ *read = fread(u->ptr_data, 1, to_read, u->fp_in);
+ if (*read != to_read) {
+ return -EIO;
+ }
+ return 0;
+}
+
+static void
+add_static_info(ubi_info_t u, size_t data_size, ubigen_action_t action)
+{
+ uint32_t crc = clc_crc32(crc32_table, UBI_CRC32_INIT,
+ u->ptr_data, data_size);
+
+ u->v->data_size = cpu_to_ubi32(data_size);
+ u->v->data_crc = cpu_to_ubi32(crc);
+
+ if (action & BROKEN_DATA_CRC) {
+ u->v->data_crc =
+ cpu_to_ubi32(ubi32_to_cpu(u->v->data_crc) + 1);
+ }
+ if (action & BROKEN_DATA_SIZE) {
+ u->v->data_size =
+ cpu_to_ubi32(ubi32_to_cpu(u->v->data_size) + 1);
+ }
+}
+
+static void
+write_vid_hdr(ubi_info_t u, ubigen_action_t action)
+{
+ uint32_t crc = clc_crc32(crc32_table, UBI_CRC32_INIT,
+ u->v, UBI_VID_HDR_SIZE_CRC);
+ /* Write VID header */
+ u->v->hdr_crc = cpu_to_ubi32(crc);
+ if (action & BROKEN_HDR_CRC) {
+ u->v->hdr_crc = cpu_to_ubi32(ubi32_to_cpu(u->v->hdr_crc) + 1);
+ }
+ memcpy(u->ptr_vid_hdr, u->v, UBI_VID_HDR_SIZE);
+}
+
+static int
+write_to_output_stream(ubi_info_t u)
+{
+ size_t written;
+
+ written = fwrite(u->buf, 1, u->eb_size, u->fp_out);
+ if (written != u->eb_size) {
+ return -EIO;
+ }
+ return 0;
+}
+
+int
+ubigen_write_leb(ubi_info_t u, ubigen_action_t action)
+{
+ int rc = 0;
+ size_t read = 0;
+
+ clear_buf(u);
+ write_ec_hdr(u);
+
+ rc = fill_data_buffer_from_file(u, &read);
+ if (rc != 0)
+ return rc;
+
+ if (u->v->vol_type == UBI_VID_STATIC) {
+ add_static_info(u, read, action);
+ }
+
+ u->v->lnum = cpu_to_ubi32(u->blks_written);
+
+ if (action & MARK_AS_UPDATE) {
+ u->v->copy_flag = (u->v->copy_flag)++;
+ }
+
+ write_vid_hdr(u, action);
+ rc = write_to_output_stream(u);
+ if (rc != 0)
+ return rc;
+
+ /* Update current handle */
+ u->bytes_read += read;
+ u->blks_written++;
+ return 0;
+}
+
+int
+ubigen_write_complete(ubi_info_t u)
+{
+ size_t i;
+ int rc = 0;
+
+ for (i = 0; i < u->leb_total; i++) {
+ rc = ubigen_write_leb(u, NO_ERROR);
+ if (rc != 0)
+ return rc;
+ }
+
+ return 0;
+}
+
+int
+ubigen_write_broken_update(ubi_info_t u, uint32_t blk)
+{
+ int rc = 0;
+
+ rc = skip_blks(u, blk);
+ if (rc != 0)
+ return rc;
+
+ rc = ubigen_write_leb(u, MARK_AS_UPDATE | BROKEN_DATA_CRC);
+ if (rc != 0)
+ return rc;
+
+
+ return 0;
+}
+
+void
+dump_info(ubi_info_t u)
+{
+#ifdef DEBUG
+ int err = 0;
+ if (!u) {
+ fprintf(stderr, "<empty>");
+ return;
+ }
+ if (!u->ec) {
+ fprintf(stderr, "<ec-empty>");
+ err = 1;
+ }
+ if (!u->v) {
+ fprintf(stderr, "<v-empty>");
+ err = 1;
+ }
+ if (err) return;
+
+ fprintf(stderr, "ubi volume\n");
+ fprintf(stderr, "version : %8d\n", u->v->version);
+ fprintf(stderr, "vol_id : %8d\n", ubi32_to_cpu(u->v->vol_id));
+ fprintf(stderr, "vol_type : %8s\n",
+ u->v->vol_type == UBI_VID_STATIC ?
+ "static" : "dynamic");
+ fprintf(stderr, "used_ebs : %8d\n",
+ ubi32_to_cpu(u->v->used_ebs));
+ fprintf(stderr, "eb_size : 0x%08x\n", u->eb_size);
+ fprintf(stderr, "leb_size : 0x%08x\n", u->leb_size);
+ fprintf(stderr, "data_pad : 0x%08x\n",
+ ubi32_to_cpu(u->v->data_pad));
+ fprintf(stderr, "leb_total : %8d\n", u->leb_total);
+ fprintf(stderr, "header offs : 0x%08x\n",
+ ubi32_to_cpu(u->ec->vid_hdr_offset));
+ fprintf(stderr, "bytes_total : %8d\n", u->bytes_total);
+ fprintf(stderr, " + in MiB : %8.2f M\n",
+ ((float)(u->bytes_total)) / 1024 / 1024);
+ fprintf(stderr, "-------------------------------\n\n");
+#else
+ return;
+#endif
+}
+
+int
+ubigen_destroy(ubi_info_t *u)
+{
+ if (u == NULL)
+ return -EINVAL;
+
+ ubi_info_t tmp = *u;
+
+ if (tmp) {
+ if (tmp->v)
+ free(tmp->v);
+ if (tmp->ec)
+ free(tmp->ec);
+ if (tmp->buf)
+ free(tmp->buf);
+ free(tmp);
+ }
+ *u = NULL;
+ return 0;
+}
+
+void
+ubigen_init(void)
+{
+ init_crc32_table(crc32_table);
+}
+
+int
+ubigen_create(ubi_info_t* u, uint32_t vol_id, uint8_t vol_type,
+ uint32_t eb_size, uint64_t ec, uint32_t alignment,
+ uint8_t version, uint32_t vid_hdr_offset, uint8_t compat_flag,
+ size_t data_size, FILE* fp_in, FILE* fp_out)
+{
+ int rc = 0;
+ ubi_info_t res = NULL;
+ uint32_t crc;
+ uint32_t data_offset;
+
+ if (alignment == 0) {
+ rc = EUBIGEN_INVALID_ALIGNMENT;
+ goto ubigen_create_err;
+ }
+ if ((fp_in == NULL) || (fp_out == NULL)) {
+ rc = -EINVAL;
+ goto ubigen_create_err;
+ }
+
+ res = (ubi_info_t) calloc(1, sizeof(struct ubi_info));
+ if (res == NULL) {
+ rc = -ENOMEM;
+ goto ubigen_create_err;
+ }
+
+ res->v = (struct ubi_vid_hdr*) calloc(1, sizeof(struct ubi_vid_hdr));
+ if (res->v == NULL) {
+ rc = -ENOMEM;
+ goto ubigen_create_err;
+ }
+
+ res->ec = (struct ubi_ec_hdr*) calloc(1, sizeof(struct ubi_ec_hdr));
+ if (res->ec == NULL) {
+ rc = -ENOMEM;
+ goto ubigen_create_err;
+ }
+
+ /* data which is needed in the general process */
+ vid_hdr_offset = vid_hdr_offset ? vid_hdr_offset : DEFAULT_VID_OFFSET;
+ data_offset = vid_hdr_offset + UBI_VID_HDR_SIZE;
+ res->bytes_total = data_size;
+ res->eb_size = eb_size ? eb_size : DEFAULT_BLOCKSIZE;
+ res->data_pad = (res->eb_size - data_offset) % alignment;
+ res->leb_size = res->eb_size - data_offset - res->data_pad;
+ res->leb_total = byte_to_blk(data_size, res->leb_size);
+ res->alignment = alignment;
+
+ if ((res->eb_size < (vid_hdr_offset + UBI_VID_HDR_SIZE))) {
+ rc = EUBIGEN_TOO_SMALL_EB;
+ goto ubigen_create_err;
+ }
+ res->fp_in = fp_in;
+ res->fp_out = fp_out;
+
+ /* vid hdr data which doesn't change */
+ res->v->magic = cpu_to_ubi32(UBI_VID_HDR_MAGIC);
+ res->v->version = version ? version : UBI_VERSION;
+ res->v->vol_type = vol_type;
+ res->v->vol_id = cpu_to_ubi32(vol_id);
+ res->v->compat = compat_flag;
+ res->v->data_pad = cpu_to_ubi32(res->data_pad);
+
+ /* static only: used_ebs */
+ if (res->v->vol_type == UBI_VID_STATIC) {
+ res->v->used_ebs = cpu_to_ubi32(byte_to_blk
+ (res->bytes_total,
+ res->leb_size));
+ }
+
+ /* ec hdr (fixed, doesn't change) */
+ res->ec->magic = cpu_to_ubi32(UBI_EC_HDR_MAGIC);
+ res->ec->version = version ? version : UBI_VERSION;
+ res->ec->ec = cpu_to_ubi64(ec);
+ res->ec->vid_hdr_offset = cpu_to_ubi32(vid_hdr_offset);
+
+ res->ec->data_offset = cpu_to_ubi32(data_offset);
+
+ crc = clc_crc32(crc32_table, UBI_CRC32_INIT, res->ec,
+ UBI_EC_HDR_SIZE_CRC);
+ res->ec->hdr_crc = cpu_to_ubi32(crc);
+
+ /* prepare a read buffer */
+ res->buf = (uint8_t*) malloc (res->eb_size * sizeof(uint8_t));
+ if (res->buf == NULL) {
+ rc = -ENOMEM;
+ goto ubigen_create_err;
+ }
+
+ /* point to distinct regions within the buffer */
+ res->ptr_ec_hdr = res->buf;
+ res->ptr_vid_hdr = res->buf + ubi32_to_cpu(res->ec->vid_hdr_offset);
+ res->ptr_data = res->buf + ubi32_to_cpu(res->ec->vid_hdr_offset)
+ + UBI_VID_HDR_SIZE;
+
+ rc = validate_ubi_info(res);
+ if (rc != 0) {
+ fprintf(stderr, "Volume validation failed: %d\n", rc);
+ goto ubigen_create_err;
+ }
+
+ dump_info(res);
+ *u = res;
+ return rc;
+
+ ubigen_create_err:
+ if (res) {
+ if (res->v)
+ free(res->v);
+ if (res->ec)
+ free(res->ec);
+ if (res->buf)
+ free(res->buf);
+ free(res);
+ }
+ *u = NULL;
+ return rc;
+}
+
+int
+ubigen_get_leb_size(ubi_info_t u, size_t* size)
+{
+ if (u == NULL)
+ return -EINVAL;
+
+ *size = u->leb_size;
+ return 0;
+}
+
+
+int
+ubigen_get_leb_total(ubi_info_t u, size_t* total)
+{
+ if (u == NULL)
+ return -EINVAL;
+
+ *total = u->leb_total;
+ return 0;
+}
+
+int
+ubigen_set_lvol_rec(ubi_info_t u, size_t reserved_bytes,
+ const char* vol_name, struct ubi_vol_tbl_record *lvol_rec)
+{
+ uint32_t crc;
+
+ if ((u == NULL) || (vol_name == NULL))
+ return -EINVAL;
+
+ memset(lvol_rec, 0x0, UBI_VTBL_RECORD_SIZE);
+
+ lvol_rec->reserved_pebs =
+ cpu_to_ubi32(byte_to_blk(reserved_bytes, u->leb_size));
+ lvol_rec->alignment = cpu_to_ubi32(u->alignment);
+ lvol_rec->data_pad = u->v->data_pad;
+ lvol_rec->vol_type = u->v->vol_type;
+
+ lvol_rec->name_len =
+ cpu_to_ubi16((uint16_t)strlen((const char*)vol_name));
+
+ memcpy(lvol_rec->name, vol_name, UBI_VOL_NAME_MAX + 1);
+
+ crc = clc_crc32(crc32_table, UBI_CRC32_INIT,
+ lvol_rec, UBI_VTBL_RECORD_SIZE_CRC);
+ lvol_rec->crc = cpu_to_ubi32(crc);
+
+ return 0;
+}
diff --git a/ubi-utils/src/libubimirror/ubimirror.c b/ubi-utils/src/libubimirror/ubimirror.c
new file mode 100644
index 0000000..bf6b37c
--- /dev/null
+++ b/ubi-utils/src/libubimirror/ubimirror.c
@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <memory.h>
+#include <fcntl.h>
+
+#include <libubi.h>
+#include "ubimirror.h"
+
+#define COMPARE_BUF_SIZE (128 * 1024)
+
+#define EBUF(fmt...) do { \
+ snprintf(err_buf, err_buf_size, fmt); \
+} while (0)
+
+enum {
+ compare_error = -1,
+ seek_error = -2,
+ write_error = -3,
+ read_error = -4,
+ update_error = -5,
+ ubi_error = -6,
+ open_error = -7,
+ close_error = -8,
+ compare_equal = 0,
+ compare_different = 1
+};
+
+/*
+ * Read len number of bytes from fd.
+ * Return 0 on EOF, -1 on error.
+ */
+static ssize_t fill_buffer(int fd, unsigned char *buf, size_t len)
+{
+ ssize_t got, have = 0;
+
+ do {
+ got = read(fd, buf + have, len - have);
+ if( got == -1 && errno != EINTR )
+ return -1;
+ have += got;
+ } while ( got > 0 && have < len);
+ return have;
+}
+
+/*
+ * Write len number of bytes to fd.
+ * Return bytes written (>= 0), -1 on error.
+ */
+static ssize_t flush_buffer(int fd, unsigned char *buf, size_t len)
+{
+ ssize_t done, have = 0;
+
+ do {
+ done = write(fd, buf + have, len - have);
+ if( done == -1 && errno != EINTR )
+ return -1;
+ have += done;
+ } while ( done > 0 && have < len);
+ return have;
+}
+
+/*
+ * Compare two files. Return 0, 1, or -1, depending on whether the
+ * files are equal, different, or an error occured.
+ * Return compare-different when target volume can not be read. Might be
+ * an interrupted volume update and then the target device returns -EIO but
+ * can be updated.
+ *
+ * fd_a is source
+ * fd_b is destination
+ */
+static int
+compare_files(int fd_a, int fd_b)
+{
+ unsigned char buf_a[COMPARE_BUF_SIZE], buf_b[COMPARE_BUF_SIZE];
+ ssize_t len_a, len_b;
+ int rc;
+
+ for (;;) {
+ len_a = fill_buffer(fd_a, buf_a, sizeof(buf_a));
+ if (len_a == -1){
+ rc = compare_error;
+ break;
+ }
+ len_b = fill_buffer(fd_b, buf_b, sizeof(buf_b));
+ if (len_b == -1){
+ rc = compare_different;
+ break;
+ }
+ if( len_a != len_b ){
+ rc = compare_different;
+ break;
+ }
+ if( len_a == 0 ){ /* Size on both filies equal and EOF */
+ rc = compare_equal;
+ break;
+ }
+ if( memcmp(buf_a, buf_b, len_a) != 0 ){
+ rc = compare_different;
+ break;
+ }
+ }
+ /* Position both files at the beginning */
+ if( lseek(fd_a, 0, SEEK_SET) == -1 ||
+ lseek(fd_b, 0, SEEK_SET) == -1 )
+ rc = seek_error;
+ return rc;
+}
+
+static int
+copy_files(int fd_in, int fd_out)
+{
+ unsigned char buf_a[COMPARE_BUF_SIZE];
+ ssize_t len_a, len_b;
+ unsigned long long update_size, copied;
+
+ if( ubi_vol_get_used_bytes(fd_in, &update_size) == -1 ||
+ ubi_vol_update(fd_out, update_size) == -1 )
+ return update_error;
+ for( copied = 0; copied < update_size; copied += len_b ){
+ len_a = fill_buffer(fd_in, buf_a, sizeof(buf_a));
+ if (len_a == -1)
+ return read_error;
+ if (len_a == 0) /* Reach EOF */
+ return 0;
+ len_b = flush_buffer(fd_out, buf_a, len_a);
+ if( len_b != len_a )
+ return write_error;
+ }
+ return 0;
+}
+
+int
+ubimirror(uint32_t devno, int seqnum, uint32_t *ids, size_t ids_size,
+ char *err_buf, size_t err_buf_size)
+{
+ int rc = 0;
+ uint32_t src_id;
+ ubi_lib_t ulib = NULL;
+ int fd_in = -1, i = 0, fd_out = -1;
+
+ if (ids_size == 0)
+ return 0;
+ else {
+ if ((seqnum < 0) || (seqnum > (ids_size - 1))) {
+ EBUF("volume id %d out of range", seqnum);
+ return EUBIMIRROR_NO_SRC;
+ }
+ src_id = ids[seqnum];
+ }
+
+ rc = ubi_open(&ulib);
+ if (rc != 0)
+ return ubi_error;
+
+ fd_in = ubi_vol_open(ulib, devno, src_id, O_RDONLY);
+ if (fd_in == -1){
+ EBUF("open error source volume %d", ids[i]);
+ rc = open_error;
+ goto err;
+ }
+
+ for (i = 0; i < ids_size; i++) {
+ if (ids[i] == src_id) /* skip self-mirror */
+ continue;
+
+ fd_out = ubi_vol_open(ulib, devno, ids[i], O_RDWR);
+ if (fd_out == -1){
+ EBUF("open error destination volume %d", ids[i]);
+ rc = open_error;
+ goto err;
+ }
+ rc = compare_files(fd_in, fd_out);
+ if (rc < 0 ){
+ EBUF("compare error volume %d and %d", src_id, ids[i]);
+ goto err;
+ }
+ rc = copy_files(fd_in, fd_out);
+ if (rc != 0) {
+ EBUF("mirror error volume %d to %d", src_id, ids[i]);
+ goto err;
+ }
+ if( (rc = ubi_vol_close(fd_out)) == -1 ){
+ EBUF("close error volume %d", ids[i]);
+ rc = close_error;
+ goto err;
+ }else
+ fd_out = -1;
+ }
+err:
+ if (ulib != NULL)
+ ubi_close(&ulib);
+ if (fd_in != -1)
+ ubi_vol_close(fd_in);
+ if (fd_out != -1)
+ ubi_vol_close(fd_out);
+ return rc;
+}
diff --git a/ubi-utils/src/mkbootenv/mkbootenv.c b/ubi-utils/src/mkbootenv/mkbootenv.c
new file mode 100644
index 0000000..49ce597
--- /dev/null
+++ b/ubi-utils/src/mkbootenv/mkbootenv.c
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Oliver Lohmann
+ *
+ * Create boot-parameter/pdd data from an ASCII-text input file.
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <argp.h>
+#include <unistd.h>
+#include <errno.h>
+#include <mtd/ubi-header.h>
+
+#include "config.h"
+#include "bootenv.h"
+#include "error.h"
+
+const char *argp_program_version = PACKAGE_VERSION;
+const char *argp_program_bug_address = PACKAGE_BUGREPORT;
+static char doc[] = "\nVersion: " PACKAGE_VERSION "\n\tBuilt on "
+ BUILD_CPU" "BUILD_OS" at "__DATE__" "__TIME__"\n"
+ "\n"
+ "mkbootenv - processes bootenv text files and convertes "
+ "them into a binary format.\n";
+
+static const char copyright [] __attribute__((unused)) =
+ "Copyright (c) International Business Machines Corp., 2006";
+
+static struct argp_option options[] = {
+ { .name = "copyright",
+ .key = 'c',
+ .arg = NULL,
+ .flags = 0,
+ .doc = "Print copyright information.",
+ .group = 1 },
+ { .name = "output",
+ .key = 'o',
+ .arg = "<output>",
+ .flags = 0,
+ .doc = "Write the the output data to <output> instead of stdout.",
+ .group = 1 },
+ { .name = NULL,
+ .key = 0,
+ .arg = NULL,
+ .flags = 0,
+ .doc = NULL,
+ .group = 0 },
+};
+
+typedef struct myargs {
+ FILE* fp_in;
+ FILE* fp_out;
+
+ char *arg1;
+ char **options; /* [STRING...] */
+} myargs;
+
+
+
+static error_t
+parse_opt(int key, char *arg, struct argp_state *state)
+{
+ int err = 0;
+
+ myargs *args = state->input;
+
+ switch (key) {
+ case 'c':
+ fprintf(stderr, "%s\n", copyright);
+ exit(0);
+ break;
+ case 'o':
+ args->fp_out = fopen(arg, "wb");
+ if ((args->fp_out) == NULL) {
+ fprintf(stderr,
+ "Cannot open file %s for output\n", arg);
+ exit(1);
+ }
+ break;
+ case ARGP_KEY_ARG:
+ args->fp_in = fopen(arg, "rb");
+ if ((args->fp_in) == NULL) {
+ fprintf(stderr,
+ "Cannot open file %s for input\n", arg);
+ exit(1);
+ }
+ args->arg1 = arg;
+ args->options = &state->argv[state->next];
+ state->next = state->argc;
+ break;
+ case ARGP_KEY_END:
+ if (err) {
+ fprintf(stderr, "\n");
+ argp_usage(state);
+ exit(1);
+ }
+ break;
+ default:
+ return(ARGP_ERR_UNKNOWN);
+ }
+
+ return 0;
+}
+
+static struct argp argp = {
+ .options = options,
+ .parser = parse_opt,
+ .args_doc = "[bootenv-txt-file]",
+ .doc = doc,
+ .children = NULL,
+ .help_filter = NULL,
+ .argp_domain = NULL,
+};
+
+int
+main(int argc, char **argv) {
+ int rc = 0;
+ bootenv_t env;
+
+ myargs args = {
+ .fp_in = stdin,
+ .fp_out = stdout,
+ .arg1 = NULL,
+ .options = NULL,
+ };
+
+ argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, &args);
+
+ rc = bootenv_create(&env);
+ if (rc != 0) {
+ err_msg("Cannot create bootenv handle.");
+ goto err;
+ }
+ rc = bootenv_read_txt(args.fp_in, env);
+ if (rc != 0) {
+ err_msg("Cannot read bootenv from input file.");
+ goto err;
+ }
+ rc = bootenv_write(args.fp_out, env);
+ if (rc != 0) {
+ err_msg("Cannot write bootenv to output file.");
+ goto err;
+ }
+
+ if (args.fp_in != stdin) {
+ fclose(args.fp_in);
+ }
+ if (args.fp_out != stdout) {
+ fclose(args.fp_out);
+ }
+
+err:
+ bootenv_destroy(&env);
+ return rc;
+}
diff --git a/ubi-utils/src/mkpfi/f128_nand_sample.cfg b/ubi-utils/src/mkpfi/f128_nand_sample.cfg
new file mode 100644
index 0000000..e468d9d
--- /dev/null
+++ b/ubi-utils/src/mkpfi/f128_nand_sample.cfg
@@ -0,0 +1,38 @@
+[targets]
+complete=ipl,spl,bootenv,kernel,rootfs
+bootcode=spl,bootenv
+
+# Build sections
+[ipl]
+image=ipl.bin
+raw_starts=0x00000000
+raw_total_size=128kiB
+
+[spl]
+image=u-boot.bin
+ubi_ids=2,3
+ubi_size=2MiB
+ubi_type=static
+ubi_names=spl_0,spl_1
+
+[bootenv]
+bootenv_file=bootenv_complete.txt
+ubi_ids=4,5
+ubi_size=128kiB
+ubi_type=static
+ubi_names=bootenv_0,bootenv_1
+
+[kernel]
+image=vmlinux.bin
+ubi_ids=6,7
+ubi_size=6MiB
+ubi_type=static
+ubi_names=kernel_0,kernel_1
+
+[rootfs]
+image=rootfs.bin
+ubi_ids=8,9
+ubi_alignment=2kiB
+ubi_size=16MiB
+ubi_type=dynamic
+ubi_names=rootfs_0,rootfs_1
diff --git a/ubi-utils/src/mkpfi/f64_nor_sample.cfg b/ubi-utils/src/mkpfi/f64_nor_sample.cfg
new file mode 100644
index 0000000..fd44e27
--- /dev/null
+++ b/ubi-utils/src/mkpfi/f64_nor_sample.cfg
@@ -0,0 +1,39 @@
+[targets]
+complete=ipl,spl,bootenv,kernel,rootfs
+bootcode=spl,bootenv
+rootfs=rootfs
+
+# Build sections
+[ipl]
+image=ipl.bin
+raw_starts=0x02FE0000, 0x03FE0000
+raw_total_size=128kiB
+
+[spl]
+image=u-boot.bin
+ubi_ids=2,3
+ubi_size=2MiB
+ubi_type=static
+ubi_names=spl_0,spl_1
+
+[bootenv]
+bootenv_file=bootenv_complete.txt
+ubi_ids=4,5
+ubi_size=128kiB
+ubi_type=static
+ubi_names=bootenv_0,bootenv_1
+
+[kernel]
+image=vmlinux.bin
+ubi_ids=6,7
+ubi_size=6MiB
+ubi_type=static
+ubi_names=kernel_0,kernel_1
+
+[rootfs]
+image=rootfs.bin
+ubi_ids=8,9
+ubi_alignment=2kiB
+ubi_size=16128kiB
+ubi_type=dynamic
+ubi_names=rootfs_0,rootfs_1
diff --git a/ubi-utils/src/mkpfi/mkpfi b/ubi-utils/src/mkpfi/mkpfi
new file mode 100755
index 0000000..2cce587
--- /dev/null
+++ b/ubi-utils/src/mkpfi/mkpfi
@@ -0,0 +1,723 @@
+#!/usr/bin/perl
+#
+# Copyright (c) International Business Machines Corp., 2006
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+# the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+#
+
+#
+# mkpfi
+#
+# This perl program is assembles PFI files from a config file.
+#
+# Author: Oliver Lohmann (oliloh@de.ibm.com)
+#
+use warnings;
+use strict;
+use lib "/usr/lib/perl5"; # Please change this path as you need it, or
+ # make a proposal how this could be done
+ # nicer.
+use Getopt::Long;
+use Pod::Usage;
+use Config::IniFiles;
+use File::Temp;
+
+# ----------------------------------------------------------------------------
+# Versions
+our $version : unique = "0.1";
+our $pfi_version : unique = "0x1";
+
+# ----------------------------------------------------------------------------
+# Globals
+my $verbose = 0;
+my $cfg;
+
+my %opts = ();
+my %files = (config => "");
+my @tmp_files;
+
+my %tools = (ubicrc32 => "ubicrc32");
+
+# ----------------------------------------------------------------------------
+# Processing the input sections
+#
+# The idea is to combine each section entry with a function
+# in order to allow some kind of preprocessing for the values
+# before they are written into the PFI file.
+# This is especially useful to be more verbose and
+# user-friendly in the layout file.
+#
+# All key-function hashes are applied after the general
+# validation of the configuration file.
+# If any mandatory key is missing in a section the user
+# will be informed and the PFI creation process is aborted.
+#
+# Default keys will be checked for their presence inside the config
+# file. If they are missing, they will be generated with appr. values.
+
+# Mandatory keys for UBI volumes.
+my %ubi_keys = ("ubi_ids" => \&check_id_list,
+ "ubi_size" => \&replace_num,
+ "ubi_type" => \&replace_type,
+ "ubi_names" => \&remove_spaces,
+ "ubi_alignment" => \&replace_num);
+
+# Mandatory keys for RAW sections.
+my %raw_keys = ("raw_starts" => \&expand_starts,
+ "raw_total_size" => \&replace_num);
+
+# Common default keys for documentation and control purposes.
+my %common_keys = ("flags" => \&replace_num,
+ "label" => \&do_nothing);
+
+# Define any defaults here. Values which maintained in this default
+# region need not to be specified by the user explicitly.
+my %def_ubi_keys = ("ubi_alignment" => [\&set_default, "0x1"]);
+my %def_raw_keys = ();
+my %def_common_keys = ("flags" => [\&set_default, "0x0"],
+ "label" => [\&generate_label, ""]);
+
+# ----------------------------------------------------------------------------
+# Input keys, actually the path to the input data.
+
+my %input_keys = ("image" => \&do_nothing);
+
+# Placeholder keys allow the replacement via a special
+# purpose function. E.g. the bootenv_file key will be used
+# to generate bootenv binary data from an text file and
+# replace the bootenv_file key with an image key to handle it
+# in the same way in the further creation process.
+my %input_placeholder_keys = ("bootenv_file" => \&create_bootenv_image);
+
+# ----------------------------------------------------------------------------
+# Helper
+
+# @brief Get current time string.
+sub get_date {
+ my $tmp = scalar localtime;
+ $tmp =~ s/ /_/g;
+ return $tmp;
+}
+
+# @brief Print an info message to stdout.
+sub INFO($) {
+ my $str = shift;
+
+ if (!$verbose) {
+ return;
+ }
+
+ print STDOUT $str;
+}
+
+# @brief Print an error message to stderr.
+sub ERR($) {
+ my $str = shift;
+ print STDERR $str;
+}
+
+# @brief Print a warning message to stderr.
+sub WARN($) {
+ my $str = shift;
+ print STDERR $str;
+}
+
+sub parse_command_line($) {
+ my $opt = shift;
+ my $result = GetOptions( "help" => \$$opt{'help'},
+ "man" => \$$opt{'man'},
+ "config=s" => \$$opt{'config'},
+ "verbose" => \$$opt{'verbose'},
+ ) or pod2usage(2);
+ pod2usage(1) if defined ($$opt{help});
+ pod2usage(-verbose => 2) if defined ($$opt{man});
+
+ $verbose = $$opt{verbose} if defined $$opt{verbose};
+
+ if (!defined $$opt{config}) {
+ ERR("[ ERROR: No config file specified. Aborting...\n");
+ exit 1;
+ }
+
+}
+
+# @brief Check if all needed tools are in PATH.
+sub check_tools {
+ my $err = 0;
+ my $key;
+
+ foreach $key (keys %tools) {
+ if (`which $tools{$key}` eq "") {
+ ERR("\n") if ($err == 0);
+ ERR("! Please add the tool \'$tools{$key}\' " .
+ "to your path!\n");
+ $err = 1;
+ }
+ }
+ die "[ ERROR: Did not find all needed tools!\n" if $err;
+}
+
+sub open_cfg_file($) {
+ my $fname = shift;
+ my $res = new Config::IniFiles( -file => $fname );
+
+ die "[ ERROR: Cannot load your config file!\n" if (!defined $res);
+ return $res;
+}
+
+sub set_default($$$$) {
+ my ($cfg, $section, $parameter, $def_value) = @_;
+ $cfg->newval($section, $parameter, $def_value);
+ return;
+}
+
+sub generate_label($$$$) {
+ my ($cfg, $section, $parameter, $def_value) = @_;
+ my $new_label = $def_value . $section;
+ $new_label .= "_" . get_date;
+ $cfg->newval($section, $parameter, $new_label);
+ return;
+}
+
+# @brief Converts any num to a unified hex string, i.e the resulting value
+# always starts with "0x" and is aligned to 8 hexdigits.
+# @return Returns 0 on success, otherwise an error occured.
+#
+sub any_num_to_hex($$) {
+ my $val = shift;
+ my $res = shift;
+
+ # M(iB)
+ if ($val =~ m/([0-9]+)[Mm][i]?[Bb]?/g) {
+ $$res = sprintf("0x%08x", $1 * 1024 * 1024);
+ }
+ # k(iB)
+ elsif ($val =~ m/([0-9]+)[kK][i]?[Bb]?/g) {
+ $$res = sprintf("0x%08x", $1 * 1024);
+ }
+ # hex
+ elsif ($val =~ m/0x?([0-9a-fA-F]+)/g) {
+ $$res = sprintf("0x%08x", hex $1);
+ }
+ # decimal
+ elsif ($val =~ m/^([0-9]+)$/g) {
+ $$res = sprintf("0x%08x", $1);
+ }
+ else {
+ $$res = "";
+ return -1;
+ }
+
+ return 0;
+}
+
+sub remove_spaces($$$) {
+ my ($cfg, $section, $parameter) = @_;
+ my ($start, @starts, @new_starts);
+ my $val = $cfg->val($section, $parameter);
+ my $res;
+
+ $val =~ s/ //g; # spaces
+ $cfg->newval($section, $parameter, $val);
+}
+
+sub expand_starts($$$) {
+ my ($cfg, $section, $parameter) = @_;
+ my ($start, @starts, @new_starts);
+ my $val = $cfg->val($section, $parameter);
+ my $res;
+
+ $val =~ s/ //g; # spaces
+ @starts = split(/,/, $val);
+
+ foreach $start (@starts) {
+ if (any_num_to_hex($start, \$res) != 0) {
+ ERR("[ ERROR: [$section]\n");
+ ERR("[ Expecting a list of numeric " .
+ "values for parameter: $parameter\n");
+ exit 1;
+ }
+ push (@new_starts, $res);
+ }
+ $res = join(',', @starts);
+
+ $cfg->newval($section, $parameter, $res);
+}
+
+sub check_id_list($$$) {
+ my ($cfg, $section, $parameter) = @_;
+ my $val = $cfg->val($section, $parameter);
+ my $res;
+
+ if (!($val =~ m/^[0-9]+[,0-9]*/)) {
+ ERR("[ ERROR: Syntax error in 'ubi_ids' in " .
+ "section '$section': $val\n");
+ ERR("[ Aborting... ");
+ exit 1;
+ }
+}
+
+sub replace_type($$$) {
+ my ($cfg, $section, $parameter) = @_;
+ my $val = $cfg->val($section, $parameter);
+ my $res;
+
+ $res = lc($val);
+ grep {$res eq $_} ('static', 'dynamic')
+ or die "[ ERROR: Unknown UBI Volume Type in " .
+ "section '$section': $val\n";
+
+ $cfg->newval($section, $parameter, $res);
+}
+
+
+sub replace_num($$$) {
+ my ($cfg, $section, $parameter) = @_;
+ my $val = $cfg->val($section, $parameter);
+ my $res = "";
+
+ if (any_num_to_hex($val, \$res) != 0) {
+ ERR("[ ERROR: [$section]\n");
+ ERR("[ Expecting a numeric value " .
+ "for parameter: $parameter\n");
+ exit 1;
+ }
+ $cfg->newval($section, $parameter, $res);
+}
+
+sub do_nothing($$$) {
+ my ($cfg, $section, $parameter) = @_;
+ return;
+}
+
+sub bootenv_sanity_check($) {
+ my $env = shift; # hash array containing bootenv
+ my %pdd = ();
+
+ defined($$env{'pdd'}) or return "'pdd' not defined";
+ foreach (split /,/, $$env{'pdd'}) {
+ defined($$env{$_}) or return "undefined '$_' in pdd";
+ $pdd{$_} = 1;
+ }
+
+ defined $$env{'pdd_preserve'} or
+ return "";
+ foreach (split /,/, $$env{'pdd_preserve'}) {
+ defined($pdd{$_})
+ or return "pdd_preserve field '$_' not in pdd";
+ }
+ return "";
+}
+
+sub create_bootenv_image($$$) {
+ my ($cfg, $section, $parameter) = @_;
+ my $txt_fn = $cfg->val($section, "bootenv_file");
+ my $in;
+
+ my %value = ();
+ my @key = ();
+
+ open $in, "<", $txt_fn
+ or die "[ ERROR: can't open bootenv file '$txt_fn'.\n";
+ while (<$in>) {
+ next if (/^\s*(\#.*)?$/); # Skip comments/whitespace.
+
+ if (/^(\S+?)\+\=(.*)$/) {
+ defined($value{$1}) or
+ die "$txt_fn:$.: error: appending to" .
+ " non-existent '$1'\n";
+ $value{$1} .= $2;
+ } elsif (/^(\S+?)\=(.*)$/) {
+ not defined($value{$1}) or
+ die "$txt_fn:$.: error: trying to" .
+ " redefine '$1'\n";
+ push @key, $1;
+ $value{$1} = $2;
+ } else {
+ die "$txt_fn:$.: error: unrecognized syntax\n";
+ }
+ }
+ close $in;
+
+ $_ = &bootenv_sanity_check(\%value)
+ and die "$txt_fn: error: $_\n";
+
+ my $tmp_file = new File::Temp();
+ push (@tmp_files, $tmp_file);
+
+ foreach (@key) {
+ print $tmp_file "$_=", $value{$_}, "\0";
+ }
+ close $tmp_file;
+
+ $cfg->newval($section, "image", $tmp_file-> filename);
+}
+
+sub process_keys($$$) {
+ my ($cfg, $section, $keys) = @_;
+ my @parameters = $cfg->Parameters($section);
+ my $i;
+
+ for ($i = 0 ; $i < scalar(@parameters) ; $i++ ) {
+ if (defined($$keys{$parameters[$i]})) {
+ $$keys{$parameters[$i]}->($cfg, $section,
+ $parameters[$i]);
+ }
+ }
+
+}
+
+sub is_in_keylist($$) {
+ my ($key, $keys) = @_;
+ my $i;
+
+ for ($i = 0; $i < scalar(@$keys); $i++) {
+ if ($$keys[$i] eq $key) {
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+sub check_default_keys($$$) {
+ my ($cfg, $section, $keys) = @_;
+ my @parameters = $cfg->Parameters($section);
+ my $key;
+
+ foreach $key (keys %$keys) {
+ if (!is_in_keylist($key, \@parameters)) {
+ $$keys{$key}[0]->
+ ($cfg, $section, $key, $$keys{$key}[1]);
+ }
+ }
+
+}
+
+
+
+sub check_keys($$$) {
+ my ($cfg, $section, $keys) = @_;
+ my @parameters = $cfg->Parameters($section);
+ my ($i, $key, $err);
+
+ $err = 0;
+ for ($i = 0 ; $i < scalar(@$keys) ; $i++ ) {
+ if (!is_in_keylist($$keys[$i], \@parameters)) {
+ ERR("[ ERROR: [$section]\n") if $err == 0;
+ $err = 1;
+ ERR("[ Missing key '$$keys[$i]'\n");
+ }
+ }
+
+ if ($err) {
+ ERR("[ Aborting...\n");
+ exit 1;
+ }
+}
+
+sub push_pfi_data($$$$$) {
+ my ($cfg, $section, $pfi_infos, $keys, $mode) = @_;
+ my ($tmp, $i, $hdr);
+
+ my %pfi_info = ();
+ $pfi_info{'mode'} = $mode;
+ $pfi_info{'image'} = $cfg->val($section, "image");
+
+ # Build the PFI header
+ $hdr = sprintf("PFI!\n");
+ $hdr .= sprintf("version=0x%08x\n", hex $pfi_version);
+ $hdr .= sprintf("mode=$mode\n");
+
+ # calculate the size of the binary data part
+ $tmp = -s $cfg->val($section, "image");
+ if (!defined $tmp) {
+ ERR("[ ERROR: [$section]\n");
+ ERR("[ Missing input image: "
+ . $cfg->val($section, "image") . "\n");
+ exit 1;
+ }
+ # Check for the image to fit into the given space
+ my $quota;
+ if ($mode eq 'raw') {
+ $quota = oct $cfg->val($section, "raw_total_size");
+ } elsif ($mode eq 'ubi') {
+ $quota = oct $cfg->val($section, "ubi_size");
+ }
+ $tmp <= $quota
+ or die "[ERROR: image file too big: " .
+ $cfg->val($section, "image") . "\n";
+ $pfi_info{'size'} = $tmp;
+
+ $hdr .= sprintf("size=0x%08x\n", $tmp);
+
+ my $img_file = $cfg->val($section, "image");
+ my $crc32 = `$tools{'ubicrc32'} $img_file 2>&1`;
+ if (any_num_to_hex($crc32, \$tmp) != 0) {
+ die "[ ERROR: $tools{'ubicrc32'} returned with errors";
+ }
+ $hdr .= sprintf("crc=$tmp\n");
+
+
+ # Process all remaining keys
+ for ($i = 0; $i < scalar (@$keys); $i++) {
+ if ($$keys[$i] eq "image") { # special case image input file
+ if (! -e ($tmp = $cfg->val($section, "image"))) {
+ ERR("[ ERROR: [$section]\n");
+ ERR("[ Cannot find input file $tmp\n");
+ exit 1;
+ }
+ next;
+ }
+ $hdr .= sprintf("%s=%s\n", $$keys[$i],
+ $cfg->val($section, $$keys[$i]));
+ }
+
+ $hdr .= sprintf("\n"); # end marker for PFI-header
+
+ $pfi_info{'header'} = $hdr;
+
+ # store in the header list
+ push @$pfi_infos, \%pfi_info;
+}
+
+sub process_section($$$$$$) {
+ my ($cfg, $section, $pfi_infos, $custom_keys,
+ $def_custom_keys, $mode) = @_;
+ my @keys = (keys %common_keys, keys %$custom_keys);
+ my @complete_keys = (@keys, keys %input_keys);
+
+ # set defaults if necessary
+ check_default_keys($cfg, $section, $def_custom_keys);
+ check_default_keys($cfg, $section, \%def_common_keys);
+
+ # check for placeholders...
+ process_keys($cfg, $section, \%input_placeholder_keys);
+
+ # VALIDATE layout.cfg entries
+ check_keys($cfg, $section, \@complete_keys);
+
+ # execute linked functions (if any)
+ process_keys($cfg, $section, \%common_keys);
+ process_keys($cfg, $section, $custom_keys);
+
+ push_pfi_data($cfg, $section, $pfi_infos, \@keys, $mode);
+}
+
+sub get_section_info($$) {
+ my ($cfg, $section) = @_;
+ my @parameters = $cfg->Parameters($section);
+ my ($ubi, $raw, $i, @res);
+
+ $ubi = $raw = 0;
+ for ($i = 0 ; $i < scalar(@parameters) ; $i++ ) {
+ if ($parameters[$i] =~ m/ubi_/gi) {
+ $ubi = 1;
+ @res = (\%ubi_keys, \%def_ubi_keys, "ubi");
+ }
+ if ($parameters[$i] =~ m/raw_/gi) {
+ $raw = 1;
+ @res = (\%raw_keys, \%def_raw_keys, "raw");
+ }
+ }
+
+ if (($ubi + $raw) != 1) { # double definition in section
+ ERR("[ ERROR: Layout error in section '$section'\n");
+ exit 1;
+ }
+
+ return @res;
+}
+
+sub mk_target_list($$) {
+ my $val = shift;
+ my $tmp = shift;
+ my $complete = 0;
+
+ if ($val =~ m/\((.*)\)/g) {
+ $val = $1;
+ $complete = 1;
+ }
+ $val =~ s/ //g; # spaces
+
+ @$tmp = split(/,/, $val);
+
+ return $complete;
+}
+
+sub copy_bytes($$$) {
+ my ($in, $out, $to_copy) = @_;
+
+ while ($to_copy) {
+ my $buf;
+ my $bufsize = 1024*1024;
+
+ $bufsize < $to_copy or $bufsize = $to_copy;
+ read($in, $buf, $bufsize) == $bufsize
+ or die "[ ERROR: Image file shrunk during operation\n";
+ print $out $buf;
+ $to_copy -= $bufsize;
+ }
+}
+
+sub write_target($$) {
+ my ($pfi_infos, $target) = @_;
+ my ($pfi_info);
+
+ INFO("[ Writting target pfi file: '$target.pfi'...\n");
+ if (-e "$target.pfi") {
+ WARN("! Replaced old pfi...\n");
+ `rm -f $target.pfi`;
+ }
+ open(FILE, ">", "$target.pfi")
+ or die "[ ERROR: Cannot create output file: $target.pfi\n";
+ binmode(FILE);
+
+ # @FIXME sort by mode (first raw, then ubi)
+ # Currently this ordering is based on a string comparism. :-)
+ @$pfi_infos = sort {(lc $$a{'mode'}) cmp (lc $$b{'mode'})} @$pfi_infos;
+
+ # Print all headers first
+ foreach $pfi_info (@$pfi_infos) {
+ print FILE $$pfi_info{'header'};
+
+ }
+ # Print the linked data sections
+ print FILE "DATA\n";
+ foreach $pfi_info (@$pfi_infos) {
+ open(IMAGE, "<", $$pfi_info{'image'})
+ or die "[ ERROR: Cannot open input image: " .
+ "$$pfi_info{'image'}" . "\n";
+ binmode(IMAGE);
+ &copy_bytes(\*IMAGE, \*FILE, $$pfi_info{'size'});
+ close(IMAGE) or die "[ ERROR: Cannot close input image: " .
+ "$$pfi_info{'image'}" . "\n";
+ }
+ close(FILE) or die "[ ERROR: Cannot close output file: $target.pfi\n";
+}
+
+sub process_config($) {
+ my $cfg = shift;
+ my @sections = $cfg->Sections;
+ my ($i, $j, $keylist, $def_keylist, $mode, $tmp,
+ @tlist, $complete,@pfi_infos);
+
+ my @parameters = $cfg->Parameters("targets") or
+ die "[ ERROR: Config file has no 'targets' section!\n";
+
+ for ($i = 0 ; $i < scalar(@parameters) ; $i++ ) {
+ INFO("[ Processing target '$parameters[$i]'...\n");
+ @pfi_infos = ();
+
+ # get a list of subtargets
+ $complete = mk_target_list($cfg->val("targets",
+ $parameters[$i]), \@tlist);
+ # build all subtargets
+ for ($j = 0 ; $j < scalar(@tlist) ; $j++ ) {
+ ($keylist, $def_keylist, $mode)
+ = get_section_info($cfg, $tlist[$j]);
+ process_section($cfg, $tlist[$j],
+ \@pfi_infos,
+ $keylist, $def_keylist, $mode);
+ }
+
+ write_target(\@pfi_infos, $parameters[$i]);
+ }
+
+ INFO("[ Success.\n");
+
+
+}
+
+sub clear_files() {
+ # @FIXME:
+ # Works implicitly and Fedora seems to have removed
+ # the cleanup call. Thus for now, inactive.
+ # File::Temp::cleanup();
+}
+
+require 5.008_000; # Tested with version 5.8.0.
+select STDOUT; $| = 1; # make STDOUT output unbuffered
+select STDERR; $| = 1; # make STDERR output unbuffered
+
+parse_command_line(\%opts);
+check_tools;
+$cfg = open_cfg_file($opts{config});
+process_config($cfg);
+clear_files;
+
+__END__
+
+
+=head1 NAME
+
+mkpfi - Using GetOpt::Long, Pod::Usage, Config::IniFiles
+
+
+=head1 SYNOPSIS
+
+mkpfi [OPTIONS ...]
+
+
+ OPTION
+
+ [--config] [--help] [--man]
+
+
+=head1 ABSTRACT
+
+Perl script for generating pdd pfi files from given config files.
+
+=head1 OPTIONS
+
+=over
+
+=item B<--help>
+
+Print out brief help message.
+
+=item B<--usage>
+
+Print usage.
+
+=item B<--config>
+
+Config input file.
+
+=item B<--man>
+
+Print manual page, same as 'perldoc mkpfi'.
+
+=item B<--verbose>
+
+Be verbose!
+
+=back
+
+=head1 BUGS
+
+Report via MTD mailing list
+
+
+=head1 SEE ALSO
+
+http://www.linux-mtd.infradead.org/
+
+
+=head1 AUTHOR
+
+Oliver Lohmann (oliloh@de.ibm.com)
+
+=cut
diff --git a/ubi-utils/src/nand2bin/nand2bin.c b/ubi-utils/src/nand2bin/nand2bin.c
new file mode 100644
index 0000000..a728fb5
--- /dev/null
+++ b/ubi-utils/src/nand2bin/nand2bin.c
@@ -0,0 +1,327 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Frank Haverkamp
+ *
+ * An utility to decompose NAND images and strip OOB off. Not yet finished ...
+ */
+#include <config.h>
+#include <argp.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <getopt.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include "nandecc.h"
+
+#define MAXPATH 1024
+#define MIN(x,y) ((x)<(y)?(x):(y))
+
+struct args {
+ const char *oob_file;
+ const char *output_file;
+ size_t pagesize;
+
+ /* special stuff needed to get additional arguments */
+ char *arg1;
+ char **options; /* [STRING...] */
+};
+
+static struct args myargs = {
+ .output_file = "data.bin",
+ .oob_file = "oob.bin",
+ .pagesize = 2048,
+ .arg1 = NULL,
+ .options = NULL,
+};
+
+static error_t parse_opt (int key, char *arg, struct argp_state *state);
+
+const char *argp_program_bug_address = "<haver@vnet.ibm.com>";
+
+static char doc[] = "\nVersion: " VERSION "\n\t"
+ HOST_OS" "HOST_CPU" at "__DATE__" "__TIME__"\n"
+ "\nSplit data and OOB.\n";
+
+static struct argp_option options[] = {
+ { .name = "pagesize",
+ .key = 'p',
+ .arg = "<pagesize>",
+ .flags = 0,
+ .doc = "NAND pagesize",
+ .group = OPTION_ARG_OPTIONAL },
+
+ { .name = "output",
+ .key = 'o',
+ .arg = "<output>",
+ .flags = 0,
+ .doc = "Data output file",
+ .group = OPTION_ARG_OPTIONAL },
+
+ { .name = "oob",
+ .key = 'O',
+ .arg = "<oob>",
+ .flags = 0,
+ .doc = "OOB output file",
+ .group = OPTION_ARG_OPTIONAL },
+
+ { .name = NULL, .key = 0, .arg = NULL, .flags = 0,
+ .doc = NULL, .group = 0 },
+};
+
+static struct argp argp = {
+ .options = options,
+ .parser = parse_opt,
+ .args_doc = "input.mif",
+ .doc = doc,
+ .children = NULL,
+ .help_filter = NULL,
+ .argp_domain = NULL,
+};
+
+/*
+ * str_to_num - Convert string into number and cope with endings like
+ * k, K, kib, KiB for kilobyte
+ * m, M, mib, MiB for megabyte
+ */
+uint32_t str_to_num(char *str)
+{
+ char *s = str;
+ ulong num = strtoul(s, &s, 0);
+
+ if (*s != '\0') {
+ if (strcmp(s, "KiB") == 0)
+ num *= 1024;
+ else if (strcmp(s, "MiB") == 0)
+ num *= 1024*1024;
+ else {
+ fprintf(stderr, "WARNING: Wrong number format "
+ "\"%s\", check your paramters!\n", str);
+ }
+ }
+ return num;
+}
+
+/*
+ * @brief Parse the arguments passed into the test case.
+ *
+ * @param key The parameter.
+ * @param arg Argument passed to parameter.
+ * @param state Location to put information on parameters.
+ *
+ * @return error
+ *
+ * Get the `input' argument from `argp_parse', which we know is a
+ * pointer to our arguments structure.
+ */
+static error_t
+parse_opt(int key, char *arg, struct argp_state *state)
+{
+ struct args *args = state->input;
+
+ switch (key) {
+ case 'p': /* --pagesize<pagesize> */
+ args->pagesize = str_to_num(arg); break;
+
+ case 'o': /* --output=<output.bin> */
+ args->output_file = arg;
+ break;
+
+ case 'O': /* --oob=<oob.bin> */
+ args->output_file = arg;
+ break;
+
+ case ARGP_KEY_NO_ARGS:
+ /* argp_usage(state); */
+ break;
+
+ case ARGP_KEY_ARG:
+ args->arg1 = arg;
+ /* Now we consume all the rest of the arguments.
+ `state->next' is the index in `state->argv' of the
+ next argument to be parsed, which is the first STRING
+ we're interested in, so we can just use
+ `&state->argv[state->next]' as the value for
+ arguments->strings.
+
+ _In addition_, by setting `state->next' to the end
+ of the arguments, we can force argp to stop parsing here and
+ return. */
+
+ args->options = &state->argv[state->next];
+ state->next = state->argc;
+ break;
+
+ case ARGP_KEY_END:
+ /* argp_usage(state); */
+ break;
+
+ default:
+ return(ARGP_ERR_UNKNOWN);
+ }
+
+ return 0;
+}
+
+static int calc_oobsize(size_t pagesize)
+{
+ switch (pagesize) {
+ case 512: return 16;
+ case 2048: return 64;
+ default:
+ exit(EXIT_FAILURE);
+ }
+ return 0;
+}
+
+static inline void
+hexdump(FILE *fp, const uint8_t *buf, size_t size)
+{
+ int k;
+
+ for (k = 0; k < size; k++) {
+ fprintf(fp, "%02x ", buf[k]);
+ if ((k & 15) == 15)
+ fprintf(fp, "\n");
+ }
+}
+
+static int
+process_page(uint8_t* buf, uint8_t *oobbuf, size_t pagesize)
+{
+ int eccpoi, oobsize;
+ size_t i;
+
+ switch (pagesize) {
+ case 2048: oobsize = 64; eccpoi = 64 / 2; break;
+ case 512: oobsize = 16; eccpoi = 16 / 2; break;
+ default:
+ fprintf(stderr, "Unsupported page size: %d\n", pagesize);
+ return -EINVAL;
+ }
+ memset(oobbuf, 0xff, oobsize);
+
+ for (i = 0; i < pagesize; i += 256, eccpoi += 3) {
+ oobbuf[eccpoi++] = 0x0;
+ /* Calculate ECC */
+ nand_calculate_ecc(&buf[i], &oobbuf[eccpoi]);
+ }
+ return 0;
+}
+
+static int decompose_image(FILE *in_fp, FILE *bin_fp, FILE *oob_fp,
+ size_t pagesize)
+{
+ int read, rc, page = 0;
+ size_t oobsize = calc_oobsize(pagesize);
+ uint8_t *buf = malloc(pagesize);
+ uint8_t *oob = malloc(oobsize);
+ uint8_t *calc_oob = malloc(oobsize);
+ uint8_t *calc_buf = malloc(pagesize);
+
+ if (!buf)
+ exit(EXIT_FAILURE);
+ if (!oob)
+ exit(EXIT_FAILURE);
+ if (!calc_oob)
+ exit(EXIT_FAILURE);
+ if (!calc_buf)
+ exit(EXIT_FAILURE);
+
+ while (!feof(in_fp)) {
+ read = fread(buf, 1, pagesize, in_fp);
+ if (ferror(in_fp)) {
+ fprintf(stderr, "I/O Error.");
+ exit(EXIT_FAILURE);
+ }
+ rc = fwrite(buf, 1, pagesize, bin_fp);
+ if (ferror(bin_fp)) {
+ fprintf(stderr, "I/O Error.");
+ exit(EXIT_FAILURE);
+ }
+ read = fread(oob, 1, oobsize, in_fp);
+ if (ferror(in_fp)) {
+ fprintf(stderr, "I/O Error.");
+ exit(EXIT_FAILURE);
+ }
+ rc = fwrite(oob, 1, oobsize, oob_fp);
+ if (ferror(bin_fp)) {
+ fprintf(stderr, "I/O Error.");
+ exit(EXIT_FAILURE);
+ }
+ process_page(buf, calc_oob, pagesize);
+
+ memcpy(calc_buf, buf, pagesize);
+
+ rc = nand_correct_data(calc_buf, oob);
+ if ((rc != -1) || (memcmp(buf, calc_buf, pagesize) != 0)) {
+ fprintf(stdout, "Page %d: data does not match!\n",
+ page);
+ }
+ page++;
+ }
+ free(calc_buf);
+ free(calc_oob);
+ free(oob);
+ free(buf);
+ return 0;
+}
+
+int
+main(int argc, char *argv[])
+{
+ FILE *in, *bin, *oob;
+
+ argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, &myargs);
+
+ if (!myargs.arg1) {
+ fprintf(stderr, "Please specify input file!\n");
+ exit(EXIT_FAILURE);
+ }
+
+ in = fopen(myargs.arg1, "r");
+ if (!in) {
+ perror("Cannot open file");
+ exit(EXIT_FAILURE);
+ }
+ bin = fopen(myargs.output_file, "w+");
+ if (!bin) {
+ perror("Cannot open file");
+ exit(EXIT_FAILURE);
+ }
+ oob = fopen(myargs.oob_file, "w+");
+ if (!oob) {
+ perror("Cannot open file");
+ exit(EXIT_FAILURE);
+ }
+
+ decompose_image(in, bin, oob, myargs.pagesize);
+
+ fclose(in);
+ fclose(bin);
+ fclose(oob);
+
+ exit(EXIT_SUCCESS);
+}
diff --git a/ubi-utils/src/nand2bin/nandcorr.c b/ubi-utils/src/nand2bin/nandcorr.c
new file mode 100644
index 0000000..7f1a547
--- /dev/null
+++ b/ubi-utils/src/nand2bin/nandcorr.c
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * ECC algorithm for NAND FLASH. Detects and corrects 1 bit errors in
+ * a 256 bytes of data.
+ *
+ * Reimplement by Thomas Gleixner after staring long enough at the
+ * mess in drivers/mtd/nand/nandecc.c
+ *
+ */
+
+#include "nandecc.h"
+
+static int countbits(uint32_t byte)
+{
+ int res = 0;
+
+ for (;byte; byte >>= 1)
+ res += byte & 0x01;
+ return res;
+}
+
+int nand_correct_data(uint8_t *dat, const uint8_t *fail_ecc)
+
+{
+ uint8_t s0, s1, s2;
+
+ /*
+ * Do error detection
+ *
+ * Be careful, the index magic is due to a pointer to a
+ * uint32_t.
+ */
+ s0 = fail_ecc[1];
+ s1 = fail_ecc[2];
+ s2 = fail_ecc[3];
+
+ /* Check for a single bit error */
+ if( ((s0 ^ (s0 >> 1)) & 0x55) == 0x55 &&
+ ((s1 ^ (s1 >> 1)) & 0x55) == 0x55 &&
+ ((s2 ^ (s2 >> 1)) & 0x54) == 0x54) {
+
+ uint32_t byteoffs, bitnum;
+
+ byteoffs = (s1 << 0) & 0x80;
+ byteoffs |= (s1 << 1) & 0x40;
+ byteoffs |= (s1 << 2) & 0x20;
+ byteoffs |= (s1 << 3) & 0x10;
+
+ byteoffs |= (s0 >> 4) & 0x08;
+ byteoffs |= (s0 >> 3) & 0x04;
+ byteoffs |= (s0 >> 2) & 0x02;
+ byteoffs |= (s0 >> 1) & 0x01;
+
+ bitnum = (s2 >> 5) & 0x04;
+ bitnum |= (s2 >> 4) & 0x02;
+ bitnum |= (s2 >> 3) & 0x01;
+
+ dat[byteoffs] ^= (1 << bitnum);
+
+ return 1;
+ }
+
+ if(countbits(s0 | ((uint32_t)s1 << 8) | ((uint32_t)s2 <<16)) == 1)
+ return 1;
+
+ return -1;
+}
+
diff --git a/ubi-utils/src/pddcustomize/pddcustomize.c b/ubi-utils/src/pddcustomize/pddcustomize.c
new file mode 100644
index 0000000..f71d916
--- /dev/null
+++ b/ubi-utils/src/pddcustomize/pddcustomize.c
@@ -0,0 +1,496 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Oliver Lohmann
+ *
+ * PDD (platform description data) contains a set of system specific
+ * boot-parameters. Some of those parameters need to be handled
+ * special on updates, e.g. the MAC addresses. They must also be kept
+ * if the system is updated and one must be able to modify them when
+ * the system has booted the first time. This tool is intended to do
+ * PDD modification.
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <getopt.h>
+#include <argp.h>
+#include <unistd.h>
+#include <errno.h>
+#include <mtd/ubi-header.h>
+
+#include "config.h"
+#include "bootenv.h"
+#include "error.h"
+#include "example_ubi.h"
+#include "libubi.h"
+#include "ubimirror.h"
+
+typedef enum action_t {
+ ACT_NORMAL = 0,
+ ACT_LIST,
+ ACT_ARGP_ABORT,
+ ACT_ARGP_ERR,
+} action_t;
+
+#define ABORT_ARGP do { \
+ state->next = state->argc; \
+ args->action = ACT_ARGP_ABORT; \
+} while (0)
+
+#define ERR_ARGP do { \
+ state->next = state->argc; \
+ args->action = ACT_ARGP_ERR; \
+} while (0)
+
+const char *argp_program_version = PACKAGE_VERSION;
+const char *argp_program_bug_address = PACKAGE_BUGREPORT;
+static char doc[] = "\nVersion: " PACKAGE_VERSION "\n\tBuilt on "
+ BUILD_CPU" "BUILD_OS" at "__DATE__" "__TIME__"\n"
+ "\n"
+ "pddcustomize - customize bootenv and pdd values.\n";
+
+static const char copyright [] __attribute__((unused)) =
+ "FIXME: insert license type"; /* FIXME */
+
+static struct argp_option options[] = {
+ { name: "copyright", key: 'c', arg: NULL, flags: 0,
+ doc: "Print copyright information.",
+ group: 1 },
+
+ { name: "input", key: 'i', arg: "<input>", flags: 0,
+ doc: "Binary input file. For debug purposes.",
+ group: 1 },
+
+ { name: "output", key: 'o', arg: "<output>", flags: 0,
+ doc: "Binary output file. For debug purposes.",
+ group: 1 },
+
+ { name: "list", key: 'l', arg: NULL, flags: 0,
+ doc: "List card bootenv/pdd values.",
+ group: 1 },
+
+ { name: "both", key: 'b', arg: NULL, flags: 0,
+ doc: "Mirror updated PDD to redundand copy.",
+ group: 1 },
+
+ { name: "side", key: 's', arg: "<seqnum>", flags: 0,
+ doc: "The side/seqnum to update.",
+ group: 1 },
+
+ { name: "host", key: 'x', arg: NULL, flags: 0,
+ doc: "use x86 platform for debugging.",
+ group: 1 },
+
+ { name: NULL, key: 0, arg: NULL, flags: 0, doc: NULL, group: 0 },
+};
+
+typedef struct myargs {
+ action_t action;
+ const char* file_in;
+ const char* file_out;
+ int both;
+ int side;
+ int x86; /* X86 host, use files for testing */
+ bootenv_t env_in;
+
+ char *arg1;
+ char **options; /* [STRING...] */
+} myargs;
+
+static int
+get_update_side(const char* str)
+{
+ uint32_t i = strtoul(str, NULL, 0);
+
+ if ((i != 0) && (i != 1)) {
+ return -1;
+ }
+
+ return i;
+}
+
+static int
+extract_pair(bootenv_t env, const char* str)
+{
+ int rc = 0;
+ char* key;
+ char* val;
+
+ key = strdup(str);
+ if (key == NULL)
+ return -ENOMEM;
+
+ val = strstr(key, "=");
+ if (val == NULL) {
+ err_msg("Wrong argument: %s\n"
+ "Expecting key=value pair.\n", str);
+ rc = -1;
+ goto err;
+ }
+
+ *val = '\0'; /* split strings */
+ val++;
+ rc = bootenv_set(env, key, val);
+
+err:
+ free(key);
+ return rc;
+}
+
+static error_t
+parse_opt(int key, char *arg, struct argp_state *state)
+{
+ int rc = 0;
+ int err = 0;
+
+ myargs *args = state->input;
+
+ switch (key) {
+ case 'c':
+ err_msg("%s\n", copyright);
+ ABORT_ARGP;
+ break;
+ case 'l':
+ args->action = ACT_LIST;
+ break;
+ case 'b':
+ args->both = 1;
+ break;
+ case 'x':
+ args->x86 = 1;
+ break;
+ case 's':
+ args->side = get_update_side(arg);
+ if (args->side < 0) {
+ err_msg("Unsupported seqnum: %d.\n"
+ "Supported seqnums are '0' and '1'\n",
+ args->side, arg);
+ ERR_ARGP;
+ }
+ break;
+ case 'i':
+ args->file_in = arg;
+ break;
+ case 'o':
+ args->file_out = arg;
+ break;
+ case ARGP_KEY_ARG:
+ rc = extract_pair(args->env_in, arg);
+ if (rc != 0)
+ ERR_ARGP;
+ break;
+ case ARGP_KEY_END:
+ if (err) {
+ err_msg("\n");
+ argp_usage(state);
+ ERR_ARGP;
+ }
+ break;
+ default:
+ return(ARGP_ERR_UNKNOWN);
+ }
+
+ return 0;
+}
+
+static struct argp argp = {
+ options: options,
+ parser: parse_opt,
+ args_doc: "[key=value] [...]",
+ doc: doc,
+ children: NULL,
+ help_filter: NULL,
+ argp_domain: NULL,
+};
+
+
+static int
+list_bootenv(bootenv_t env)
+{
+ int rc = 0;
+ rc = bootenv_write_txt(stdout, env);
+ if (rc != 0) {
+ err_msg("Cannot list bootenv/pdd. rc: %d\n", rc);
+ goto err;
+ }
+err:
+ return rc;
+}
+
+static int
+process_key_value(bootenv_t env_in, bootenv_t env)
+{
+ int rc = 0;
+ size_t size, i;
+ const char* tmp;
+ const char** key_vec = NULL;
+
+ rc = bootenv_get_key_vector(env_in, &size, 0, &key_vec);
+ if (rc != 0)
+ goto err;
+
+ for (i = 0; i < size; i++) {
+ rc = bootenv_get(env_in, key_vec[i], &tmp);
+ if (rc != 0) {
+ err_msg("Cannot read value to input key: %s. rc: %d\n",
+ key_vec[i], rc);
+ goto err;
+ }
+ rc = bootenv_set(env, key_vec[i], tmp);
+ if (rc != 0) {
+ err_msg("Cannot set value key: %s. rc: %d\n",
+ key_vec[i], rc);
+ goto err;
+ }
+ }
+
+err:
+ if (key_vec != NULL)
+ free(key_vec);
+ return rc;
+}
+
+static int
+read_bootenv(const char* file, bootenv_t env)
+{
+ int rc = 0;
+ FILE* fp_in = NULL;
+
+ fp_in = fopen(file, "rb");
+ if (fp_in == NULL) {
+ err_msg("Cannot open file: %s\n", file);
+ return -EIO;
+ }
+
+ rc = bootenv_read(fp_in, env, BOOTENV_MAXSIZE);
+ if (rc != 0) {
+ err_msg("Cannot read bootenv from file %s. rc: %d\n",
+ file, rc);
+ goto err;
+ }
+
+err:
+ fclose(fp_in);
+ return rc;
+}
+
+/*
+ * Read bootenv from ubi volume
+ */
+static int
+ubi_read_bootenv(uint32_t devno, uint32_t id, bootenv_t env)
+{
+ ubi_lib_t ulib = NULL;
+ int rc = 0;
+ FILE* fp_in = NULL;
+
+ rc = ubi_open(&ulib);
+ if( rc ){
+ err_msg("Cannot allocate ubi structure\n");
+ return rc;
+ }
+
+ fp_in = ubi_vol_fopen_read(ulib, devno, id);
+ if (fp_in == NULL) {
+ err_msg("Cannot open volume:%d number:%d\n", devno, id);
+ goto err;
+ }
+
+ rc = bootenv_read(fp_in, env, BOOTENV_MAXSIZE);
+ if (rc != 0) {
+ err_msg("Cannot read volume:%d number:%d\n", devno, id);
+ goto err;
+ }
+
+err:
+ if( fp_in )
+ fclose(fp_in);
+ ubi_close(&ulib);
+ return rc;
+}
+
+static int
+write_bootenv(const char* file, bootenv_t env)
+{
+ int rc = 0;
+ FILE* fp_out;
+
+ fp_out = fopen(file, "wb");
+ if (fp_out == NULL) {
+ err_msg("Cannot open file: %s\n", file);
+ return -EIO;
+ }
+
+ rc = bootenv_write(fp_out, env);
+ if (rc != 0) {
+ err_msg("Cannot write bootenv to file %s. rc: %d\n", file, rc);
+ goto err;
+ }
+
+err:
+ fclose(fp_out);
+ return rc;
+}
+
+/*
+ * Read bootenv from ubi volume
+ */
+static int
+ubi_write_bootenv(uint32_t devno, uint32_t id, bootenv_t env)
+{
+ ubi_lib_t ulib = NULL;
+ int rc = 0;
+ FILE* fp_out;
+ size_t nbytes ;
+
+ rc = bootenv_size(env, &nbytes);
+ if( rc ){
+ err_msg("Cannot determine size of bootenv structure\n");
+ return rc;
+ }
+ rc = ubi_open(&ulib);
+ if( rc ){
+ err_msg("Cannot allocate ubi structure\n");
+ return rc;
+ }
+ fp_out = ubi_vol_fopen_update(ulib, devno, id,
+ (unsigned long long)nbytes);
+ if (fp_out == NULL) {
+ err_msg("Cannot open volume:%d number:%d\n", devno, id);
+ goto err;
+ }
+
+ rc = bootenv_write(fp_out, env);
+ if (rc != 0) {
+ err_msg("Cannot write bootenv to volume %d number:%d\n",
+ devno, id);
+ goto err;
+ }
+
+err:
+ if( fp_out )
+ fclose(fp_out);
+ ubi_close(&ulib);
+ return rc;
+}
+
+static int
+do_mirror(int volno)
+{
+ char errbuf[1024];
+ uint32_t ids[2];
+ int rc;
+ int src_volno_idx = 0;
+
+ ids[0] = EXAMPLE_BOOTENV_VOL_ID_1;
+ ids[1] = EXAMPLE_BOOTENV_VOL_ID_2;
+
+ if (volno == EXAMPLE_BOOTENV_VOL_ID_2)
+ src_volno_idx = 1;
+
+ rc = ubimirror(EXAMPLE_UBI_DEVICE, src_volno_idx, ids, 2, errbuf,
+ sizeof errbuf);
+ if( rc )
+ err_msg(errbuf);
+ return rc;
+}
+
+int
+main(int argc, char **argv) {
+ int rc = 0;
+ bootenv_t env = NULL;
+ uint32_t boot_volno;
+ myargs args = {
+ .action = ACT_NORMAL,
+ .file_in = NULL,
+ .file_out = NULL,
+ .side = -1,
+ .x86 = 0,
+ .both = 0,
+ .env_in = NULL,
+
+ .arg1 = NULL,
+ .options = NULL,
+ };
+
+ rc = bootenv_create(&env);
+ if (rc != 0) {
+ err_msg("Cannot create bootenv handle. rc: %d", rc);
+ goto err;
+ }
+
+ rc = bootenv_create(&(args.env_in));
+ if (rc != 0) {
+ err_msg("Cannot create bootenv handle. rc: %d", rc);
+ goto err;
+ }
+
+ argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, &args);
+ if (args.action == ACT_ARGP_ERR) {
+ rc = -1;
+ goto err;
+ }
+ if (args.action == ACT_ARGP_ABORT) {
+ rc = 0;
+ goto out;
+ }
+
+ if ((args.side == 0) || (args.side == -1))
+ boot_volno = EXAMPLE_BOOTENV_VOL_ID_1;
+ else
+ boot_volno = EXAMPLE_BOOTENV_VOL_ID_2;
+
+ if( args.x86 )
+ rc = read_bootenv(args.file_in, env);
+ else
+ rc = ubi_read_bootenv(EXAMPLE_UBI_DEVICE, boot_volno, env);
+ if (rc != 0) {
+ goto err;
+ }
+
+ if (args.action == ACT_LIST) {
+ rc = list_bootenv(env);
+ if (rc != 0) {
+ goto err;
+ }
+ goto out;
+ }
+
+ rc = process_key_value(args.env_in, env);
+ if (rc != 0) {
+ goto err;
+ }
+
+ if( args.x86 )
+ rc = write_bootenv(args.file_in, env);
+ else
+ rc = ubi_write_bootenv(EXAMPLE_UBI_DEVICE, boot_volno, env);
+ if (rc != 0) {
+ goto err;
+ }
+ if( args.both ) /* No side specified, update both */
+ rc = do_mirror(boot_volno);
+
+ out:
+ err:
+ bootenv_destroy(&env);
+ bootenv_destroy(&(args.env_in));
+ return rc;
+}
diff --git a/ubi-utils/src/pfi2bin/pfi2bin.c b/ubi-utils/src/pfi2bin/pfi2bin.c
new file mode 100644
index 0000000..6536c19
--- /dev/null
+++ b/ubi-utils/src/pfi2bin/pfi2bin.c
@@ -0,0 +1,678 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Oliver Lohmann
+ *
+ * Convert a PFI file (partial flash image) into a plain binary file.
+ * This tool can be used to prepare the data to be burned into flash
+ * chips in a manufacturing step where the flashes are written before
+ * being soldered onto the hardware. For NAND images another step is
+ * required to add the right OOB data to the binary image.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <getopt.h>
+#include <stdio.h>
+#include <argp.h>
+#include <string.h>
+#include <assert.h>
+
+#include <ubigen.h>
+#include <mtd/ubi-header.h>
+
+#include "config.h"
+#include "list.h"
+#include "error.h"
+#include "reader.h"
+#include "peb.h"
+#include "crc32.h"
+
+#define MAX_FNAME 255
+#define DEFAULT_ERASE_COUNT 0 /* Hmmm.... Perhaps */
+#define ERR_BUF_SIZE 1024
+
+#define MIN(a,b) ((a) < (b) ? (a) : (b))
+
+static uint32_t crc32_table[256];
+static char err_buf[ERR_BUF_SIZE];
+
+/*
+ * Data used to buffer raw blocks which have to be
+ * located at a specific point inside the generated RAW file
+ */
+
+typedef enum action_t {
+ ACT_NOTHING = 0x00000000,
+ ACT_RAW = 0x00000001,
+} action_t;
+
+static const char copyright [] __attribute__((unused)) =
+ "Licensed Materials - Property of IBM\n"
+ "IBM Flexible Support Processor Licensed Material\n"
+ "(c) Copyright IBM Corp 2006 All Rights Reserved.\n"
+ "US Government Users Restricted Rights - Use, duplication\n"
+ "or disclosure restricted by GSA ADP Schedule Contract\n"
+ "with IBM Corp.";
+
+static error_t parse_opt (int key, char *arg, struct argp_state *state);
+
+const char *argp_program_version = PACKAGE_VERSION;
+const char *argp_program_bug_address = PACKAGE_BUGREPORT;
+static char doc[] = "\nVersion: " PACKAGE_VERSION "\n\tBuilt on "
+ BUILD_CPU" "BUILD_OS" at "__DATE__" "__TIME__"\n"
+ "\n"
+ "pfi2bin - a tool to convert PFI files into binary images.\n";
+
+static struct argp_option options[] = {
+ /* COMMON */
+ { name: NULL, key: 0, arg: NULL, flags: 0,
+ doc: "Common settings:",
+ group: OPTION_ARG_OPTIONAL},
+
+ { name: "verbose", key: 'v', arg: NULL, flags: 0,
+ doc: "Print more information.",
+ group: OPTION_ARG_OPTIONAL },
+
+ { name: "copyright", key: 'c', arg: NULL, flags: 0,
+ group: OPTION_ARG_OPTIONAL },
+
+
+ /* INPUT */
+ { name: NULL, key: 0, arg: NULL, flags: 0,
+ doc: "Input:",
+ group: 4},
+
+ { name: "platform", key: 'j', arg: "pdd-file", flags: 0,
+ doc: "PDD information which contains the card settings.",
+ group: 4 },
+
+ /* OUTPUT */
+ { name: NULL, key: 0, arg: NULL, flags: 0,
+ doc: "Output:",
+ group: 5},
+
+ { name: "output", key: 'o', arg: "filename", flags: 0,
+ doc: "Outputfile, default: stdout.",
+ group: 5 },
+
+ { name: NULL, key: 0, arg: NULL, flags: 0, doc: NULL, group: 0 },
+};
+
+typedef struct io {
+ FILE* fp_pdd; /* a FilePointer to the PDD data */
+ FILE* fp_pfi; /* a FilePointer to the PFI input stream */
+ FILE* fp_out; /* a FilePointer to the output stream */
+} *io_t;
+
+typedef struct myargs {
+ /* common settings */
+ action_t action;
+ int verbose;
+ const char *f_in_pfi;
+ const char *f_in_pdd;
+ const char *f_out;
+
+ /* special stuff needed to get additional arguments */
+ char *arg1;
+ char **options; /* [STRING...] */
+} myargs;
+
+static struct argp argp = {
+ options: options,
+ parser: parse_opt,
+ args_doc: "pfifile",
+ doc: doc,
+ children: NULL,
+ help_filter: NULL,
+ argp_domain: NULL,
+};
+
+static error_t
+parse_opt(int key, char *arg, struct argp_state *state)
+{
+ myargs *args = state->input;
+
+ switch (key) {
+ /* common settings */
+ case 'v': /* --verbose=<level> */
+ args->verbose = 1;
+ break;
+
+ case 'c': /* --copyright */
+ fprintf(stderr, "%s\n", copyright);
+ exit(0);
+ break;
+
+ case 'j': /* --platform */
+ args->f_in_pdd = arg;
+ break;
+
+ case 'o': /* --output */
+ args->f_out = arg;
+ break;
+
+ case ARGP_KEY_ARG:
+ args->f_in_pfi = arg;
+ /* args->arg1 = arg; */
+ args->options = &state->argv[state->next];
+ state->next = state->argc;
+ break;
+
+ case ARGP_KEY_END:
+ if (args->action == ACT_NOTHING) {
+ argp_usage(state);
+ exit(1);
+ }
+ break;
+
+ default:
+ return(ARGP_ERR_UNKNOWN);
+ }
+
+ return 0;
+}
+
+
+static size_t
+byte_to_blk(size_t byte, size_t blk_size)
+{
+ return (byte % blk_size) == 0
+ ? byte / blk_size
+ : byte / blk_size + 1;
+}
+
+
+
+
+/**
+ * @precondition IO: File stream points to first byte of RAW data.
+ * @postcondition IO: File stream points to first byte of next
+ * or EOF.
+ */
+static int
+memorize_raw_eb(pfi_raw_t pfi_raw, pdd_data_t pdd, list_t *raw_pebs,
+ io_t io)
+{
+ int rc = 0;
+ uint32_t i;
+
+ size_t read, to_read, eb_num;
+ size_t bytes_left;
+ list_t pebs = *raw_pebs;
+ peb_t peb = NULL;
+
+ long old_file_pos = ftell(io->fp_pfi);
+ for (i = 0; i < pfi_raw->starts_size; i++) {
+ bytes_left = pfi_raw->data_size;
+ rc = fseek(io->fp_pfi, old_file_pos, SEEK_SET);
+ if (rc != 0)
+ goto err;
+
+ eb_num = byte_to_blk(pfi_raw->starts[i], pdd->eb_size);
+ while (bytes_left) {
+ to_read = MIN(bytes_left, pdd->eb_size);
+ rc = peb_new(eb_num++, pdd->eb_size, &peb);
+ if (rc != 0)
+ goto err;
+ read = fread(peb->data, 1, to_read, io->fp_pfi);
+ if (read != to_read) {
+ rc = -EIO;
+ goto err;
+ }
+ pebs = append_elem(peb, pebs);
+ bytes_left -= read;
+ }
+
+ }
+ *raw_pebs = pebs;
+ return 0;
+err:
+ pebs = remove_all((free_func_t)&peb_free, pebs);
+ return rc;
+}
+
+static int
+convert_ubi_volume(pfi_ubi_t ubi, pdd_data_t pdd, list_t raw_pebs,
+ struct ubi_vol_tbl_record *vol_tab,
+ size_t *ebs_written, io_t io)
+{
+ int rc = 0;
+ uint32_t i, j;
+ peb_t raw_peb;
+ peb_t cmp_peb;
+ ubi_info_t u;
+ size_t leb_total = 0;
+ uint8_t vol_type;
+
+ switch (ubi->type) {
+ case pfi_ubi_static:
+ vol_type = UBI_VID_STATIC; break;
+ case pfi_ubi_dynamic:
+ vol_type = UBI_VID_DYNAMIC; break;
+ default:
+ vol_type = UBI_VID_DYNAMIC;
+ }
+
+ rc = peb_new(0, 0, &cmp_peb);
+ if (rc != 0)
+ goto err;
+
+ long old_file_pos = ftell(io->fp_pfi);
+ for (i = 0; i < ubi->ids_size; i++) {
+ rc = fseek(io->fp_pfi, old_file_pos, SEEK_SET);
+ if (rc != 0)
+ goto err;
+ rc = ubigen_create(&u, ubi->ids[i], vol_type,
+ pdd->eb_size, DEFAULT_ERASE_COUNT,
+ ubi->alignment, UBI_VERSION,
+ pdd->vid_hdr_offset, 0, ubi->data_size,
+ io->fp_pfi, io->fp_out);
+ if (rc != 0)
+ goto err;
+
+ rc = ubigen_get_leb_total(u, &leb_total);
+ if (rc != 0)
+ goto err;
+
+ j = 0;
+ while(j < leb_total) {
+ cmp_peb->num = *ebs_written;
+ raw_peb = is_in((cmp_func_t)peb_cmp, cmp_peb,
+ raw_pebs);
+ if (raw_peb) {
+ rc = peb_write(io->fp_out, raw_peb);
+ }
+ else {
+ rc = ubigen_write_leb(u, NO_ERROR);
+ j++;
+ }
+ if (rc != 0)
+ goto err;
+ (*ebs_written)++;
+ }
+ /* memorize volume table entry */
+ rc = ubigen_set_lvol_rec(u, ubi->size,
+ ubi->names[i],
+ (void*) &vol_tab[ubi->ids[i]]);
+ if (rc != 0)
+ goto err;
+ ubigen_destroy(&u);
+ }
+
+ peb_free(&cmp_peb);
+ return 0;
+
+err:
+ peb_free(&cmp_peb);
+ ubigen_destroy(&u);
+ return rc;
+}
+
+
+static FILE*
+my_fmemopen (void *buf, size_t size, const char *opentype)
+{
+ FILE* f;
+
+ assert(strcmp(opentype, "r") == 0);
+
+ f = tmpfile();
+ fwrite(buf, 1, size, f);
+ rewind(f);
+
+ return f;
+}
+
+/**
+ * @brief Builds a UBI volume table from a volume entry list.
+ * @return 0 On success.
+ * else Error.
+ */
+static int
+write_ubi_volume_table(pdd_data_t pdd, list_t raw_pebs,
+ struct ubi_vol_tbl_record *vol_tab, size_t vol_tab_size,
+ size_t *ebs_written, io_t io)
+{
+ int rc = 0;
+ ubi_info_t u;
+ peb_t raw_peb;
+ peb_t cmp_peb;
+ size_t leb_size, leb_total, j = 0;
+ uint8_t *ptr = NULL;
+ FILE* fp_leb = NULL;
+
+ rc = peb_new(0, 0, &cmp_peb);
+ if (rc != 0)
+ goto err;
+
+ /* @FIXME: Artem creates one volume with 2 LEBs.
+ * IMO 2 volumes would be more convenient. In order
+ * to get 2 reserved LEBs from ubigen, I have to
+ * introduce this stupid mechanism. Until no final
+ * decision of the VTAB structure is made... Good enough.
+ */
+ rc = ubigen_create(&u, UBI_LAYOUT_VOL_ID, UBI_VID_DYNAMIC,
+ pdd->eb_size, DEFAULT_ERASE_COUNT,
+ 1, UBI_VERSION,
+ pdd->vid_hdr_offset, UBI_COMPAT_REJECT,
+ vol_tab_size, stdin, io->fp_out);
+ /* @FIXME stdin for fp_in is a hack */
+ if (rc != 0)
+ goto err;
+ rc = ubigen_get_leb_size(u, &leb_size);
+ if (rc != 0)
+ goto err;
+ ubigen_destroy(&u);
+
+ ptr = (uint8_t*) malloc(leb_size * sizeof(uint8_t));
+ if (ptr == NULL)
+ goto err;
+ memset(ptr, 0xff, leb_size);
+ memcpy(ptr, vol_tab, vol_tab_size);
+ fp_leb = my_fmemopen(ptr, leb_size, "r");
+
+ rc = ubigen_create(&u, UBI_LAYOUT_VOL_ID, UBI_VID_DYNAMIC,
+ pdd->eb_size, DEFAULT_ERASE_COUNT,
+ 1, UBI_VERSION, pdd->vid_hdr_offset,
+ UBI_COMPAT_REJECT, leb_size * UBI_LAYOUT_VOLUME_EBS,
+ fp_leb, io->fp_out);
+ if (rc != 0)
+ goto err;
+ rc = ubigen_get_leb_total(u, &leb_total);
+ if (rc != 0)
+ goto err;
+
+ long old_file_pos = ftell(fp_leb);
+ while(j < leb_total) {
+ rc = fseek(fp_leb, old_file_pos, SEEK_SET);
+ if (rc != 0)
+ goto err;
+
+ cmp_peb->num = *ebs_written;
+ raw_peb = is_in((cmp_func_t)peb_cmp, cmp_peb,
+ raw_pebs);
+ if (raw_peb) {
+ rc = peb_write(io->fp_out, raw_peb);
+ }
+ else {
+ rc = ubigen_write_leb(u, NO_ERROR);
+ j++;
+ }
+
+ if (rc != 0)
+ goto err;
+ (*ebs_written)++;
+ }
+
+err:
+ free(ptr);
+ peb_free(&cmp_peb);
+ ubigen_destroy(&u);
+ fclose(fp_leb);
+ return rc;
+}
+
+static int
+write_remaining_raw_ebs(pdd_data_t pdd, list_t raw_blocks, size_t *ebs_written,
+ FILE* fp_out)
+{
+ int rc = 0;
+ uint32_t j, delta;
+ list_t ptr;
+ peb_t empty_eb, peb;
+
+ /* create an empty 0xff EB (for padding) */
+ rc = peb_new(0, pdd->eb_size, &empty_eb);
+
+ foreach(peb, ptr, raw_blocks) {
+ if (peb->num < *ebs_written) {
+ continue; /* omit blocks which
+ are already passed */
+ }
+
+ if (peb->num < *ebs_written) {
+ err_msg("eb_num: %d\n", peb->num);
+ err_msg("Bug: This should never happen. %d %s",
+ __LINE__, __FILE__);
+ goto err;
+ }
+
+ delta = peb->num - *ebs_written;
+ if (((delta + *ebs_written) * pdd->eb_size) > pdd->flash_size) {
+ err_msg("RAW block outside of flash_size.");
+ goto err;
+ }
+ for (j = 0; j < delta; j++) {
+ rc = peb_write(fp_out, empty_eb);
+ if (rc != 0)
+ goto err;
+ (*ebs_written)++;
+ }
+ rc = peb_write(fp_out, peb);
+ if (rc != 0)
+ goto err;
+ (*ebs_written)++;
+ }
+
+err:
+ peb_free(&empty_eb);
+ return rc;
+}
+
+static int
+init_vol_tab(struct ubi_vol_tbl_record **vol_tab, size_t *vol_tab_size)
+{
+ uint32_t crc;
+ size_t i;
+ struct ubi_vol_tbl_record* res = NULL;
+
+ *vol_tab_size = UBI_MAX_VOLUMES * UBI_VTBL_RECORD_SIZE;
+
+ res = (struct ubi_vol_tbl_record*) calloc(1, *vol_tab_size);
+ if (vol_tab == NULL) {
+ return -ENOMEM;
+ }
+
+ for (i = 0; i < UBI_MAX_VOLUMES; i++) {
+ crc = clc_crc32(crc32_table, UBI_CRC32_INIT,
+ &(res[i]), UBI_VTBL_RECORD_SIZE_CRC);
+ res[i].crc = cpu_to_ubi32(crc);
+ }
+
+ *vol_tab = res;
+ return 0;
+}
+
+static int
+create_raw(io_t io)
+{
+ int rc = 0;
+ size_t ebs_written = 0; /* eraseblocks written already... */
+ size_t vol_tab_size;
+ list_t ptr;
+
+ list_t pfi_raws = mk_empty(); /* list of raw sections from a pfi */
+ list_t pfi_ubis = mk_empty(); /* list of ubi sections from a pfi */
+ list_t raw_pebs = mk_empty(); /* list of raw eraseblocks */
+
+ struct ubi_vol_tbl_record *vol_tab = NULL;
+ pdd_data_t pdd = NULL;
+
+ rc = init_vol_tab (&vol_tab, &vol_tab_size);
+ if (rc != 0) {
+ err_msg("Cannot initialize volume table.");
+ goto err;
+ }
+
+ rc = read_pdd_data(io->fp_pdd, &pdd,
+ err_buf, ERR_BUF_SIZE);
+ if (rc != 0) {
+ err_msg("Cannot read necessary pdd_data: %s rc: %d",
+ err_buf, rc);
+ goto err;
+ }
+
+ rc = read_pfi_headers(&pfi_raws, &pfi_ubis, io->fp_pfi,
+ err_buf, ERR_BUF_SIZE);
+ if (rc != 0) {
+ err_msg("Cannot read pfi header: %s rc: %d",
+ err_buf, rc);
+ goto err;
+ }
+
+ pfi_raw_t pfi_raw;
+ foreach(pfi_raw, ptr, pfi_raws) {
+ rc = memorize_raw_eb(pfi_raw, pdd, &raw_pebs,
+ io);
+ if (rc != 0) {
+ err_msg("Cannot create raw_block in mem. rc: %d\n",
+ rc);
+ goto err;
+ }
+ }
+
+ pfi_ubi_t pfi_ubi;
+ foreach(pfi_ubi, ptr, pfi_ubis) {
+ rc = convert_ubi_volume(pfi_ubi, pdd, raw_pebs,
+ vol_tab, &ebs_written, io);
+ if (rc != 0) {
+ err_msg("Cannot convert UBI volume. rc: %d\n", rc);
+ goto err;
+ }
+ }
+
+ rc = write_ubi_volume_table(pdd, raw_pebs, vol_tab, vol_tab_size,
+ &ebs_written, io);
+ if (rc != 0) {
+ err_msg("Cannot write UBI volume table. rc: %d\n", rc);
+ goto err;
+ }
+
+ rc = write_remaining_raw_ebs(pdd, raw_pebs, &ebs_written, io->fp_out);
+ if (rc != 0)
+ goto err;
+
+ if (io->fp_out != stdout)
+ info_msg("Physical eraseblocks written: %8d\n", ebs_written);
+err:
+ free(vol_tab);
+ pfi_raws = remove_all((free_func_t)&free_pfi_raw, pfi_raws);
+ pfi_ubis = remove_all((free_func_t)&free_pfi_ubi, pfi_ubis);
+ raw_pebs = remove_all((free_func_t)&peb_free, raw_pebs);
+ free_pdd_data(&pdd);
+ return rc;
+}
+
+
+/* ------------------------------------------------------------------------- */
+static void
+open_io_handle(myargs *args, io_t io)
+{
+ /* set PDD input */
+ io->fp_pdd = fopen(args->f_in_pdd, "r");
+ if (io->fp_pdd == NULL) {
+ err_sys("Cannot open: %s", args->f_in_pdd);
+ }
+
+ /* set PFI input */
+ io->fp_pfi = fopen(args->f_in_pfi, "r");
+ if (io->fp_pfi == NULL) {
+ err_sys("Cannot open PFI input file: %s", args->f_in_pfi);
+ }
+
+ /* set output prefix */
+ if (strcmp(args->f_out,"") == 0)
+ io->fp_out = stdout;
+ else {
+ io->fp_out = fopen(args->f_out, "wb");
+ if (io->fp_out == NULL) {
+ err_sys("Cannot open output file: %s", args->f_out);
+ }
+ }
+}
+
+static void
+close_io_handle(io_t io)
+{
+ if (fclose(io->fp_pdd) != 0) {
+ err_sys("Cannot close PDD file.");
+ }
+ if (fclose(io->fp_pfi) != 0) {
+ err_sys("Cannot close PFI file.");
+ }
+ if (io->fp_out != stdout) {
+ if (fclose(io->fp_out) != 0) {
+ err_sys("Cannot close output file.");
+ }
+ }
+
+ io->fp_pdd = NULL;
+ io->fp_pfi = NULL;
+ io->fp_out = NULL;
+}
+
+int
+main(int argc, char *argv[])
+{
+ int rc = 0;
+
+ ubigen_init();
+ init_crc32_table(crc32_table);
+
+ struct io io = {NULL, NULL, NULL};
+ myargs args = {
+ .action = ACT_RAW,
+ .verbose = 0,
+
+ .f_in_pfi = "",
+ .f_in_pdd = "",
+ .f_out = "",
+
+ /* arguments */
+ .arg1 = NULL,
+ .options = NULL,
+ };
+
+ /* parse arguments */
+ argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, &args);
+
+ if (strcmp(args.f_in_pfi, "") == 0) {
+ err_quit("No PFI input file specified!");
+ }
+
+ if (strcmp(args.f_in_pdd, "") == 0) {
+ err_quit("No PDD input file specified!");
+ }
+
+ open_io_handle(&args, &io);
+
+ info_msg("[ Creating RAW...");
+ rc = create_raw(&io);
+ if (rc != 0) {
+ err_msg("Creating RAW failed.");
+ goto err;
+ }
+
+err:
+ close_io_handle(&io);
+ if (rc != 0) {
+ remove(args.f_out);
+ }
+
+ return rc;
+}
diff --git a/ubi-utils/src/pfiflash/pfiflash.c b/ubi-utils/src/pfiflash/pfiflash.c
new file mode 100644
index 0000000..18b3aa2
--- /dev/null
+++ b/ubi-utils/src/pfiflash/pfiflash.c
@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Oliver Lohmann
+ * Frank Haverkamp
+ *
+ * Process a PFI (partial flash image) and write the data to the
+ * specified UBI volumes. This tool is intended to be used for system
+ * update using PFI files.
+ */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <getopt.h>
+#include <argp.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include <pfiflash.h>
+#include "error.h"
+#include "config.h"
+
+const char *argp_program_version = PACKAGE_VERSION;
+const char *argp_program_bug_address = PACKAGE_BUGREPORT;
+static char doc[] = "\nVersion: " PACKAGE_VERSION "\n\tBuilt on "
+ BUILD_CPU" "BUILD_OS" at "__DATE__" "__TIME__"\n"
+ "\n"
+ "pfiflash - a tool for updating a controller with PFI files.\n";
+
+static const char copyright [] __attribute__((unused)) =
+ "FIXME: insert license type."; /* FIXME */
+
+static struct argp_option options[] = {
+ /* Output options */
+ { name: NULL, key: 0, arg: NULL, flags: 0,
+ doc: "Standard options:",
+ group: 1 },
+
+ { name: "copyright", key: 'c', arg: NULL, flags: 0,
+ doc: "Print copyright information.",
+ group: 1 },
+
+ { name: "verbose", key: 'v', arg: NULL, flags: 0,
+ doc: "Be verbose during program execution.",
+ group: 1 },
+
+ { name: "logfile", key: 'l', arg: "<file>", flags: 0,
+ doc: "Write a logfile to <file>.",
+ group: 1 },
+
+ /* Output options */
+ { name: NULL, key: 0, arg: NULL, flags: 0,
+ doc: "Process options:",
+ group: 2 },
+
+ { name: "complete", key: 'C', arg: NULL, flags: 0,
+ doc: "Execute a complete system update. Updates both sides.",
+ group: 2 },
+
+ { name: "side", key: 's', arg: "<seqnum>", flags: 0,
+ doc: "Select the side which shall be updated.",
+ group: 2 },
+
+ { name: "pdd-update", key: 'p', arg: "<type>", flags: 0,
+ doc: "Specify the pdd-update algorithm. <type> is either "
+ "'keep', 'merge' or 'overwrite'.",
+ group: 2 },
+
+ { name: NULL, key: 0, arg: NULL, flags: 0, doc: NULL, group: 0 },
+};
+
+typedef struct myargs {
+ int verbose;
+ const char *logfile;
+
+ pdd_handling_t pdd_handling;
+ int seqnum;
+ int complete;
+
+ FILE* fp_in;
+
+ /* special stuff needed to get additional arguments */
+ char *arg1;
+ char **options; /* [STRING...] */
+} myargs;
+
+static pdd_handling_t
+get_pdd_handling(const char* str)
+{
+ if (strcmp(str, "keep") == 0) {
+ return PDD_KEEP;
+ }
+ if (strcmp(str, "merge") == 0) {
+ return PDD_MERGE;
+ }
+ if (strcmp(str, "overwrite") == 0) {
+ return PDD_OVERWRITE;
+ }
+
+ return -1;
+}
+
+static int
+get_update_seqnum(const char* str)
+{
+ uint32_t i = strtoul(str, NULL, 0);
+
+ if ((i != 0) && (i != 1)) {
+ return -1;
+ }
+
+ return i;
+}
+
+
+static error_t
+parse_opt(int key, char *arg, struct argp_state *state)
+{
+ int err = 0;
+
+ myargs *args = state->input;
+
+ switch (key) {
+ /* standard options */
+ case 'c':
+ err_msg("%s\n", copyright);
+ exit(0);
+ break;
+ case 'v':
+ args->verbose = 1;
+ break;
+ case 'l':
+ args->logfile = arg;
+ break;
+ /* process options */
+ case 'C':
+ args->complete = 1;
+ break;
+ case 'p':
+ args->pdd_handling = get_pdd_handling(arg);
+ if (args->pdd_handling < 0) {
+ err_quit("Unknown PDD handling: %s.\n"
+ "Please use either 'keep', 'merge' or"
+ "'overwrite'.\n'");
+ }
+ break;
+ case 's':
+ args->seqnum = get_update_seqnum(arg);
+ if (args->seqnum < 0) {
+ err_quit("Unsupported side: %s.\n"
+ "Supported sides are '0' and '1'\n", arg);
+ }
+ break;
+
+ case ARGP_KEY_ARG: /* input file */
+ args->fp_in = fopen(arg, "r");
+ if ((args->fp_in) == NULL) {
+ err_sys("Cannot open PFI file %s for input", arg);
+ }
+ args->arg1 = arg;
+ args->options = &state->argv[state->next];
+ state->next = state->argc;
+ break;
+ case ARGP_KEY_END:
+ if (err) {
+ err_msg("\n");
+ argp_usage(state);
+ exit(1);
+ }
+ break;
+ default:
+ return(ARGP_ERR_UNKNOWN);
+ }
+
+ return 0;
+}
+
+static struct argp argp = {
+ options: options,
+ parser: parse_opt,
+ args_doc: "[pfifile]",
+ doc: doc,
+ children: NULL,
+ help_filter: NULL,
+ argp_domain: NULL,
+};
+
+int main (int argc, char** argv)
+{
+ int rc = 0;
+ char err_buf[PFIFLASH_MAX_ERR_BUF_SIZE];
+ memset(err_buf, '\0', PFIFLASH_MAX_ERR_BUF_SIZE);
+
+ myargs args = {
+ .verbose = 0,
+ .seqnum = -1,
+ .complete = 0,
+ .logfile = "/tmp/pfiflash.log",
+ .pdd_handling = PDD_KEEP,
+ .fp_in = stdin,
+ };
+
+ argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, &args);
+ error_initlog(args.logfile);
+
+ if (!args.fp_in) {
+ rc = -1;
+ snprintf(err_buf, PFIFLASH_MAX_ERR_BUF_SIZE,
+ "No PFI input file specified!\n");
+ goto err;
+ }
+
+ rc = pfiflash(args.fp_in, args.complete, args.seqnum,
+ args.pdd_handling, err_buf, PFIFLASH_MAX_ERR_BUF_SIZE);
+ if (rc != 0) {
+ goto err_fp;
+ }
+
+ err_fp:
+ if (args.fp_in != stdin)
+ fclose(args.fp_in);
+ err:
+ if (rc != 0)
+ err_msg("Error: %s\nrc: %d\n", err_buf, rc);
+ return rc;
+}
diff --git a/ubi-utils/src/ubicrc32/ubicrc32.c b/ubi-utils/src/ubicrc32/ubicrc32.c
new file mode 100644
index 0000000..fb4ef49
--- /dev/null
+++ b/ubi-utils/src/ubicrc32/ubicrc32.c
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Oliver Lohmann
+ *
+ * Calculate CRC32 with UBI start value for a given binary image.
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <argp.h>
+#include <unistd.h>
+#include <errno.h>
+#include <mtd/ubi-header.h>
+
+#include "config.h"
+#include "crc32.h"
+
+#define BUFSIZE 4096
+
+const char *argp_program_version = PACKAGE_VERSION;
+const char *argp_program_bug_address = PACKAGE_BUGREPORT;
+static char doc[] = "\nVersion: " PACKAGE_VERSION "\n\tBuilt on "
+ BUILD_CPU" "BUILD_OS" at "__DATE__" "__TIME__"\n"
+ "\n"
+ "ubicrc32 - calculates the UBI CRC32 value and prints it to stdout.\n";
+
+static const char copyright [] __attribute__((unused)) =
+ "FIXME: insert license type"; /* FIXME */
+
+
+static struct argp_option options[] = {
+ { name: "copyright", key: 'c', arg: NULL, flags: 0,
+ doc: "Print copyright information.",
+ group: 1 },
+
+ { name: NULL, key: 0, arg: NULL, flags: 0, doc: NULL, group: 0 },
+};
+
+typedef struct myargs {
+ FILE* fp_in;
+
+ char *arg1;
+ char **options; /* [STRING...] */
+} myargs;
+
+static error_t
+parse_opt(int key, char *arg, struct argp_state *state)
+{
+ int err = 0;
+
+ myargs *args = state->input;
+
+ switch (key) {
+ case 'c':
+ fprintf(stderr, "%s\n", copyright);
+ exit(0);
+ break;
+ case ARGP_KEY_ARG:
+ args->fp_in = fopen(arg, "rb");
+ if ((args->fp_in) == NULL) {
+ fprintf(stderr,
+ "Cannot open file %s for input\n", arg);
+ exit(1);
+ }
+ args->arg1 = arg;
+ args->options = &state->argv[state->next];
+ state->next = state->argc;
+ break;
+ case ARGP_KEY_END:
+ if (err) {
+ fprintf(stderr, "\n");
+ argp_usage(state);
+ exit(1);
+ }
+ break;
+ default:
+ return(ARGP_ERR_UNKNOWN);
+ }
+
+ return 0;
+}
+
+static struct argp argp = {
+ options: options,
+ parser: parse_opt,
+ args_doc: "[file]",
+ doc: doc,
+ children: NULL,
+ help_filter: NULL,
+ argp_domain: NULL,
+};
+
+int
+main(int argc, char **argv) {
+ int rc = 0;
+ uint32_t crc32_table[256];
+ uint8_t buf[BUFSIZE];
+ size_t read;
+ uint32_t crc32;
+
+ myargs args = {
+ .fp_in = stdin,
+ .arg1 = NULL,
+ .options = NULL,
+ };
+
+ argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, &args);
+
+ init_crc32_table(crc32_table);
+ crc32 = UBI_CRC32_INIT;
+ while (!feof(args.fp_in)) {
+ read = fread(buf, 1, BUFSIZE, args.fp_in);
+ if (ferror(args.fp_in)) {
+ fprintf(stderr, "I/O Error.");
+ exit(EXIT_FAILURE);
+ }
+ crc32 = clc_crc32(crc32_table, crc32, buf, read);
+ }
+
+ if (args.fp_in != stdin) {
+ fclose(args.fp_in);
+ }
+
+ fprintf(stdout, "0x%08x\n", crc32);
+ return rc;
+}
diff --git a/ubi-utils/src/ubicrc32/ubicrc32.pl b/ubi-utils/src/ubicrc32/ubicrc32.pl
new file mode 100755
index 0000000..add5f9d
--- /dev/null
+++ b/ubi-utils/src/ubicrc32/ubicrc32.pl
@@ -0,0 +1,74 @@
+#!/usr/bin/perl -w
+
+# Subroutine crc32(): Calculates the CRC on a given string.
+
+{
+ my @table = ();
+
+ # @brief Calculate CRC32 for a given string.
+ sub crc32
+ {
+ unless (@table) {
+ # Initialize the CRC table
+ my $poly = 0xEDB88320;
+ @table = ();
+
+ for my $i (0..255) {
+ my $c = $i;
+
+ for my $j (0..7) {
+ $c = ($c & 1) ? (($c >> 1) ^ $poly) : ($c >> 1);
+ }
+ $table[$i] = $c;
+ }
+ }
+ my $s = shift; # string to calculate the CRC for
+ my $crc = shift; # CRC start value
+
+ defined($crc)
+ or $crc = 0xffffffff; # Default CRC start value
+
+ for (my $i = 0; $i < length($s); $i++) {
+ $crc = $table[($crc ^ ord(substr($s, $i, 1))) & 0xff]
+ ^ ($crc >> 8);
+ }
+ return $crc;
+ }
+}
+
+sub crc32_on_file
+{
+ my $file = shift;
+
+ my $crc32 = crc32('');
+ my $buf = '';
+ my $ret = 0;
+
+ while ($ret = read($file, $buf, 8192)) {
+ $crc32 = crc32($buf, $crc32);
+ }
+ defined($ret)
+ or return undef;
+ printf("0x%x\n", $crc32);
+}
+
+
+# Main routine: Calculate the CRCs on the given files and print the
+# results.
+
+{
+ if (@ARGV) {
+ while (my $path = shift) {
+ my $file;
+ open $file, "<", $path
+ or die "Error opening '$path'.\n";
+
+ &crc32_on_file($file)
+ or die "Error reading from '$path'.\n";
+ close $file;
+ }
+ } else {
+ &crc32_on_file(\*STDIN)
+ or die "Error reading from stdin.\n";
+ }
+}
diff --git a/ubi-utils/src/ubigen/ubigen_main.c b/ubi-utils/src/ubigen/ubigen_main.c
new file mode 100644
index 0000000..8a464dd
--- /dev/null
+++ b/ubi-utils/src/ubigen/ubigen_main.c
@@ -0,0 +1,369 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Oliver Lohmann
+ *
+ * Tool to add UBI headers to binary images.
+ *
+ * 1.0 Initial version
+ * 1.1 Different CRC32 start value
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <getopt.h>
+#include <argp.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <mtd/ubi-header.h>
+
+#include "ubigen.h"
+#include "config.h"
+
+typedef enum action_t {
+ ACT_NORMAL = 0x00000001,
+ ACT_BROKEN_UPDATE = 0x00000002,
+} action_t;
+
+
+const char *argp_program_version = PACKAGE_VERSION;
+const char *argp_program_bug_address = PACKAGE_BUGREPORT;
+static char doc[] = "\nVersion: " PACKAGE_VERSION "\n\tBuilt on "
+ BUILD_CPU" "BUILD_OS" at "__DATE__" "__TIME__"\n"
+ "\n"
+ "ubigen - a tool for adding UBI information to a binary input file.\n";
+
+static const char copyright [] __attribute__((unused)) =
+ "FIXME: insert license type"; /* FIXME */
+
+#define CHECK_ENDP(option, endp) do { \
+ if (*endp) { \
+ fprintf(stderr, \
+ "Parse error option \'%s\'. " \
+ "No correct numeric value.\n" \
+ , option); \
+ exit(EXIT_FAILURE); \
+ } \
+} while(0)
+
+static struct argp_option options[] = {
+ /* COMMON */
+ { name: NULL, key: 0, arg: NULL, flags: 0,
+ doc: "Common settings:",
+ group: 1},
+
+ { name: "copyright", key: 'c', arg: NULL, flags: 0,
+ doc: "Print copyright information.",
+ group: 1 },
+
+ { name: "verbose", key: 'v', arg: NULL, flags: 0,
+ doc: "Print more progress information.",
+ group: 1 },
+
+ { name: "debug", key: 'd', arg: NULL, flags: 0,
+ group: 1 },
+
+
+ /* INPUT */
+ { name: NULL, key: 0, arg: NULL, flags: 0,
+ doc: "UBI Settings:",
+ group: 4},
+
+ { name: "alignment", key: 'A', arg: "<num>", flags: 0,
+ doc: "Set the alignment size to <num> (default 1).\n"
+ "Values can be specified as bytes, 'ki' or 'Mi'.",
+ group: 4 },
+
+ { name: "blocksize", key: 'B', arg: "<num>", flags: 0,
+ doc: "Set the eraseblock size to <num> (default 128 KiB).\n"
+ "Values can be specified as bytes, 'ki' or 'Mi'.",
+ group: 4 },
+
+ { name: "erasecount", key: 'E', arg: "<num>", flags: 0,
+ doc: "Set the erase count to <num> (default 0)",
+ group: 4 },
+
+ { name: "setver", key: 'X', arg: "<num>", flags: 0,
+ doc: "Set UBI version number to <num> (default 1)",
+ group: 4 },
+
+ { name: "id", key: 'I', arg: "<num>", flags: 0,
+ doc: "The UBI volume id.",
+ group: 4 },
+
+
+ { name: "offset", key: 'O', arg: "<num>", flags: 0,
+ doc: "Offset from start of an erase block to the UBI volume header.",
+ group: 4 },
+
+ { name: "type", key: 'T', arg: "<num>", flags: 0,
+ doc: "The UBI volume type:\n1 = dynamic, 2 = static",
+ group: 4 },
+
+ /* INPUT/OUTPUT */
+ { name: NULL, key: 0, arg: NULL, flags: 0,
+ doc: "Input/Output:",
+ group: 5 },
+
+ { name: "infile", key: 'i', arg: "<filename>", flags: 0,
+ doc: "Read input from file.",
+ group: 5 },
+
+ { name: "outfile", key: 'o', arg: "<filename>", flags: 0,
+ doc: "Write output to file (default is stdout).",
+ group: 5 },
+
+ /* Special options */
+ { name: NULL, key: 0, arg: NULL, flags: 0,
+ doc: "Special options:",
+ group: 6 },
+
+ { name: "broken-update", key: 'U', arg: "<leb>", flags: 0,
+ doc: "Create an ubi image which simulates a broken update.\n"
+ "<leb> specifies the logical eraseblock number to update.\n",
+ group: 6 },
+
+ { name: NULL, key: 0, arg: NULL, flags: 0, doc: NULL, group: 0 },
+};
+
+typedef struct myargs {
+ /* common settings */
+ action_t action;
+ int verbose;
+
+ int32_t id;
+ uint8_t type;
+ uint32_t eb_size;
+ uint64_t ec;
+ uint8_t version;
+ uint32_t hdr_offset;
+ uint32_t update_block;
+ uint32_t alignment;
+
+ FILE* fp_in;
+ FILE* fp_out;
+
+ /* special stuff needed to get additional arguments */
+ char *arg1;
+ char **options; /* [STRING...] */
+} myargs;
+
+
+static int ustrtoul(const char *cp, char **endp, unsigned int base)
+{
+ unsigned long result = strtoul(cp, endp, base);
+
+ switch (**endp) {
+ case 'G':
+ result *= 1024;
+ case 'M':
+ result *= 1024;
+ case 'k':
+ case 'K':
+ result *= 1024;
+ /* "Ki", "ki", "Mi" or "Gi" are to be used. */
+ if ((*endp)[1] == 'i')
+ (*endp) += 2;
+ }
+ return result;
+}
+
+static error_t
+parse_opt(int key, char *arg, struct argp_state *state)
+{
+ int err = 0;
+ char* endp;
+
+ myargs *args = state->input;
+
+ switch (key) {
+ case 'c':
+ fprintf(stderr, "%s\n", copyright);
+ exit(0);
+ break;
+ case 'o': /* output */
+ args->fp_out = fopen(arg, "wb");
+ if ((args->fp_out) == NULL) {
+ fprintf(stderr, "Cannot open file %s for output\n",
+ arg);
+ exit(1);
+ }
+ break;
+ case 'i': /* input */
+ args->fp_in = fopen(arg, "rb");
+ if ((args->fp_in) == NULL) {
+ fprintf(stderr, "Cannot open file %s for input\n",
+ arg);
+ exit(1);
+ }
+ break;
+ case 'v': /* verbose */
+ args->verbose = 1;
+ break;
+
+ case 'B': /* eb_size */
+ args->eb_size = (uint32_t) ustrtoul(arg, &endp, 0);
+ CHECK_ENDP("B", endp);
+ break;
+ case 'E': /* erasecount */
+ args->ec = (uint64_t) strtoul(arg, &endp, 0);
+ CHECK_ENDP("E", endp);
+ break;
+ case 'I': /* id */
+ args->id = (uint16_t) strtoul(arg, &endp, 0);
+ CHECK_ENDP("I", endp);
+ break;
+ case 'T': /* type */
+ args->type = (uint16_t) strtoul(arg, &endp, 0);
+ CHECK_ENDP("T", endp);
+ break;
+ case 'X': /* versionnr */
+ args->version = (uint8_t) strtoul(arg, &endp, 0);
+ CHECK_ENDP("X", endp);
+ break;
+ case 'O': /* offset for volume hdr */
+ args->hdr_offset =
+ (uint32_t) strtoul(arg, &endp, 0);
+ CHECK_ENDP("O", endp);
+ break;
+
+ case 'U': /* broken update */
+ args->action = ACT_BROKEN_UPDATE;
+ args->update_block =
+ (uint32_t) strtoul(arg, &endp, 0);
+ CHECK_ENDP("U", endp);
+ break;
+
+ case ARGP_KEY_ARG:
+ if (!args->fp_in) {
+ args->fp_in = fopen(arg, "rb");
+ if ((args->fp_in) == NULL) {
+ fprintf(stderr,
+ "Cannot open file %s for input\n", arg);
+ exit(1);
+ }
+ }
+ args->arg1 = arg;
+ args->options = &state->argv[state->next];
+ state->next = state->argc;
+ break;
+ case ARGP_KEY_END:
+
+ if (args->id < 0) {
+ err = 1;
+ fprintf(stderr,
+ "Please specify an UBI Volume ID.\n");
+ }
+ if (args->type == 0) {
+ err = 1;
+ fprintf(stderr,
+ "Please specify an UBI Volume type.\n");
+ }
+ if (err) {
+ fprintf(stderr, "\n");
+ argp_usage(state);
+ exit(1);
+ }
+ break;
+ default:
+ return(ARGP_ERR_UNKNOWN);
+ }
+
+ return 0;
+}
+
+static struct argp argp = {
+ options: options,
+ parser: parse_opt,
+ args_doc: 0,
+ doc: doc,
+ children: NULL,
+ help_filter: NULL,
+ argp_domain: NULL,
+};
+
+
+int
+main(int argc, char **argv)
+{
+ int rc = 0;
+ ubi_info_t u;
+ struct stat file_info;
+ off_t input_len = 0; /* only used in static volumes */
+
+ myargs args = {
+ .action = ACT_NORMAL,
+ .verbose = 0,
+
+ .id = -1,
+ .type = 0,
+ .eb_size = 0,
+ .update_block = 0,
+ .ec = 0,
+ .version = 0,
+ .hdr_offset = (DEFAULT_PAGESIZE) - (UBI_VID_HDR_SIZE),
+ .alignment = 1,
+
+ .fp_in = NULL,
+ .fp_out = stdout,
+ /* arguments */
+ .arg1 = NULL,
+ .options = NULL,
+ };
+
+ ubigen_init(); /* Init CRC32 table in ubigen */
+
+ /* parse arguments */
+ argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, &args);
+
+ if (fstat(fileno(args.fp_in), &file_info) != 0) {
+ fprintf(stderr, "Cannot fetch file size "
+ "from input file.\n");
+ }
+ input_len = file_info.st_size;
+
+ rc = ubigen_create(&u, (uint32_t)args.id, args.type,
+ args.eb_size, args.ec, args.alignment,
+ args.version, args.hdr_offset, 0 ,input_len,
+ args.fp_in, args.fp_out);
+
+ if (rc != 0) {
+ fprintf(stderr, "Cannot create UBI info handler rc: %d\n", rc);
+ exit(EXIT_FAILURE);
+ }
+
+ if (!args.fp_in || !args.fp_out) {
+ fprintf(stderr, "Input/Output error.\n");
+ exit(EXIT_FAILURE);
+
+ }
+
+ if (args.action & ACT_NORMAL) {
+ rc = ubigen_write_complete(u);
+ }
+ else if (args.action & ACT_BROKEN_UPDATE) {
+ rc = ubigen_write_broken_update(u, args.update_block);
+ }
+ if (rc != 0) {
+ fprintf(stderr, "Error converting input data.\n");
+ exit(EXIT_FAILURE);
+ }
+
+ rc = ubigen_destroy(&u);
+ return rc;
+}
diff --git a/ubi-utils/src/ubiinfo/ubiflash.h b/ubi-utils/src/ubiinfo/ubiflash.h
new file mode 100644
index 0000000..6883879
--- /dev/null
+++ b/ubi-utils/src/ubiinfo/ubiflash.h
@@ -0,0 +1,185 @@
+#ifndef _UBI_FLASH_H
+#define _UBI_FLASH_H
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * FLASH related data structures and constants for UBI.
+ * UBI scan analysis.
+ *
+ * IPL Initial Program Loader
+ * SPL Secondary Program Loader
+ */
+
+#include <stdint.h>
+#include <asm/byteorder.h>
+#include <mtd/ubi-header.h>
+
+#define UBI_BLOCK_IDENT_MAX 16
+
+/* Block status information constants */
+enum blockstat {
+ /* IO Error */
+ STAT_IO_FAILED = 1, /* 0xffffffff */
+ /* Block is bad */
+ STAT_BLOCK_BAD = 2, /* 0xfffffffe */
+ /* ECC unrecoverable error */
+ STAT_ECC_ERROR = 3, /* 0xfffffffd */
+ /* CRC checksum failed */
+ STAT_CRC_ERROR = 4, /* 0xfffffffc */
+ /* Magic number not available */
+ STAT_NO_MAGIC = 5, /* 0xfffffffb */
+ /* No image available */
+ STAT_NO_IMAGE = 6,
+ /* Image is invalid */
+ STAT_INVALID_IMAGE = 7,
+ /* Image is defect */
+ STAT_DEFECT_IMAGE = 8,
+};
+
+/*
+ * Flash types
+ */
+enum flashtypes {
+ FLASH_TYPE_NAND = 1,
+ FLASH_TYPE_NOR,
+};
+
+/* Nand read buffer size: 2KiB + 64byte spare */
+#define NAND_READ_BUF_SIZE (2048 + 64)
+
+/* Size of the CRC table */
+#define CRC32_TABLE_SIZE 256
+
+/* Image is not available marker for image offs */
+#define UBI_IMAGE_NOT_AVAILABLE 0xFFFFFFFF
+
+/* Increment this number, whenever you change the structure */
+#define UBI_SCAN_INFO_VERSION 2
+
+/* Time measurement as far as the code size allows us to do this */
+#define UBI_TIMESTAMPS 16
+
+/**
+ * struct ubi_scan_info - RAM table filled by IPL scan
+ *
+ * @version: Version of the structure
+ * @bootstatus: Boot status of the current boot
+ * @flashtype: Flash type (NAND/NOR)
+ * @flashid: ID of the flash chip
+ * @flashmfr: Manufacturer ID of the flash chip
+ * @flashsize: Size of the FLASH
+ * @blocksize: Eraseblock size
+ * @blockshift: Shift count to calc block number from offset
+ * @nrblocks: Number of erase blocks on flash
+ * @pagesize: Pagesize (NAND)
+ * @blockinfo: Pointer to an array of block status information
+ * filled by FLASH scan
+ * @images: Pointer to FLASH block translation table sorted
+ * by image type and load order
+ * @imageblocks: Number of blocks found per image
+ * @imageoffs: Offset per imagetype to the first
+ * block in the translation table
+ * @imagedups duplicate blocks (max. one per volume)
+ * @imagelen: Length of the loaded image
+ * @crc32_table: CRC32 table buffer
+ * @page_buf: Page buffer for NAND FLASH
+ */
+struct ubi_scan_info {
+ int version;
+ unsigned int bootstatus;
+ unsigned int flashtype;
+ unsigned int flashid;
+ unsigned int flashmfr;
+ unsigned int flashsize;
+ unsigned int blocksize;
+ unsigned int blockshift;
+ unsigned int nrblocks;
+ unsigned int pagesize;
+
+ struct ubi_vid_hdr *blockinfo;
+ struct ubi_vid_hdr **images;
+ unsigned int imageblocks[UBI_BLOCK_IDENT_MAX];
+ unsigned int imageoffs[UBI_BLOCK_IDENT_MAX];
+ struct ubi_vid_hdr *imagedups[UBI_BLOCK_IDENT_MAX];
+ unsigned int imagelen;
+ uint32_t crc32_table[CRC32_TABLE_SIZE];
+ uint8_t page_buf[NAND_READ_BUF_SIZE];
+ unsigned int times[UBI_TIMESTAMPS];
+};
+
+/* External function definition */
+extern int flash_read(void *buf, unsigned int offs, int len);
+extern int flash_read_slice(struct ubi_scan_info *fi, void *buf,
+ unsigned int offs, int len);
+extern void ipl_main(struct ubi_scan_info *fi);
+
+#ifndef CFG_EXAMPLE_IPL
+extern int ipl_scan(struct ubi_scan_info *fi);
+extern int ipl_load(struct ubi_scan_info *fi, int nr, uint8_t *loadaddr);
+
+#define IPL_STATIC
+
+#else
+#define IPL_STATIC static
+#endif
+
+/**
+ * get_boot_status - get the boot status register
+ *
+ * Shift the lower 16 bit into the upper 16 bit and return
+ * the result.
+ */
+uint32_t get_boot_status(void);
+
+/**
+ * set_boot_status - Set the boot status register
+ *
+ * @status: The status value to set
+ *
+ */
+void set_boot_status(uint32_t status);
+
+static inline unsigned int ubi_vid_offset(struct ubi_scan_info *fi)
+{
+ if (fi->flashtype == FLASH_TYPE_NOR)
+ return UBI_EC_HDR_SIZE;
+ else
+ return fi->pagesize - UBI_VID_HDR_SIZE;
+}
+
+static inline unsigned int ubi_data_offset(struct ubi_scan_info *fi)
+{
+ if (fi->flashtype == FLASH_TYPE_NOR)
+ return UBI_EC_HDR_SIZE + UBI_VID_HDR_SIZE;
+ else
+ return fi->pagesize;
+}
+
+/**
+ * IPL checkpoints
+ */
+#define CHKP_HWINIT 0x3030
+#define CHKP_IPLSCAN_FAILED 0x3034
+#define CHKP_SPL_START 0x3037
+#define CHKP_SPLLOAD_STATUS 0x3130
+
+extern void checkpoint(uint32_t cpoint);
+extern void switch_watchdog(void);
+
+#endif
diff --git a/ubi-utils/src/ubiinfo/ubiinfo.c b/ubi-utils/src/ubiinfo/ubiinfo.c
new file mode 100644
index 0000000..6f7443b
--- /dev/null
+++ b/ubi-utils/src/ubiinfo/ubiinfo.c
@@ -0,0 +1,406 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * Print out information about the UBI table this IPL is using. This
+ * can be used afterwards to analyze misbehavior of the IPL code. The
+ * input this program requires is the last 1 MiB DDRAM of our system
+ * where the scanning table is placed into.
+ *
+ * Author: Frank Haverkamp <haver@vnet.ibm.com>
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <time.h>
+#include <argp.h>
+#include <getopt.h>
+#include <stdint.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+
+#define __unused __attribute__((unused))
+
+/* This should hopefully be constant and the same in all
+ * configurations.
+ */
+#define CFG_IPLSIZE 512
+#define CFG_SPLCODE 512
+#define MEMTOP 0x06600000 /* Sunray 102 MiB */
+#define MEMSIZE 0x00100000 /* 1 MiB */
+#define CODE_SIZE (64 * 1024)
+
+/* FIXME Except of the memory size this should be defined via
+ * parameters
+ *
+ * CFG_MEMTOP_BAMBOO 0x02000000
+ * CFG_MEMTOP_SUNRAY 0x06600000
+ */
+
+#include "ubiipl.h"
+#include "ubiflash.h"
+
+#define MIN(x,y) ((x)<(y)?(x):(y))
+
+#define ERR_RET(rc) { \
+ fprintf(stderr, "%s:%d failed rc=%d\n", __func__, \
+ __LINE__, (rc)); \
+ return (rc); \
+ }
+
+#define VERSION "1.3"
+
+static error_t parse_opt (int key, char *arg, struct argp_state *state);
+const char *argp_program_version = VERSION;
+const char *argp_program_bug_address = "<haver@vnet.ibm.com>";
+
+static char doc[] = "\nVersion: " VERSION "\n\t"
+ " at "__DATE__" "__TIME__"\n"
+ "\n"
+ "Test program\n";
+
+static struct argp_option options[] = {
+ /* common settings */
+ { .name = "verbose",
+ .key = 'v',
+ .arg = "<level>",
+ .flags = 0,
+ .doc = "Set verbosity level to <level>",
+ .group = OPTION_ARG_OPTIONAL },
+
+ { .name = "memtop",
+ .key = 'm',
+ .arg = "<memtop>",
+ .flags = 0,
+ .doc = "Set top of memory, 102 MiB for Sunray and 16 MiB for Bamboo",
+ .group = OPTION_ARG_OPTIONAL },
+
+ { .name = NULL,
+ .key = 0,
+ .arg = NULL,
+ .flags = 0,
+ .doc = NULL,
+ .group = 0 },
+};
+
+typedef struct test_args {
+ int verbose;
+ unsigned long memtop;
+ char *arg1;
+ char **options;
+} test_args;
+
+static struct test_args g_args = {
+ .memtop = MEMTOP,
+ .verbose = 0,
+ .arg1 = NULL,
+ .options = NULL,
+};
+
+static struct argp argp = {
+ options: options,
+ parser: parse_opt,
+ args_doc: "[last_1MiB_memory.bin]",
+ doc: doc,
+ children: NULL,
+ help_filter: NULL,
+ argp_domain: NULL,
+};
+
+static int verbose = 0;
+
+/**
+ * @brief Parse the arguments passed into the test case.
+ *
+ * @param key The parameter.
+ * @param arg Argument passed to parameter.
+ * @param state Location to put information on parameters.
+ *
+ * @return error_t
+ */
+static error_t
+parse_opt(int key, char *arg, struct argp_state *state)
+{
+ /* Get the `input' argument from `argp_parse', which we
+ know is a pointer to our arguments structure. */
+ test_args *args = state->input;
+
+ switch (key) {
+ /* common settings */
+ case 'v': /* --verbose=<level> */
+ verbose = args->verbose = strtoul(arg, (char **)NULL, 0);
+ break;
+
+ case 'm': /* --memtop */
+ args->memtop = strtoul(arg, (char **)NULL, 0);
+ break;
+
+ case ARGP_KEY_NO_ARGS:
+ /* argp_usage(state); */
+ break;
+
+ case ARGP_KEY_ARG:
+ args->arg1 = arg;
+ /* Now we consume all the rest of the arguments.
+ `state->next' is the index in `state->argv' of the
+ next argument to be parsed, which is the first STRING
+ we're interested in, so we can just use
+ `&state->argv[state->next]' as the value for
+ arguments->strings.
+
+ _In addition_, by setting `state->next' to the end
+ of the arguments, we can force argp to stop parsing
+ here and return. */
+
+ args->options = &state->argv[state->next];
+ state->next = state->argc;
+ break;
+
+ case ARGP_KEY_END:
+ /* print out message if no arguments are given but PFI
+ write should be done */
+ break;
+
+ default:
+ return(ARGP_ERR_UNKNOWN);
+ }
+ return 0;
+}
+
+static void
+hexdump(const char *buf, int len)
+{
+ char line[16];
+ char str[256];
+ char dummy[256];
+ int j = 0;
+
+ while (len > 0) {
+ int i;
+
+ strcpy(str, " ");
+
+ for (j = 0; j < MIN(16, len); j++)
+ line[j] = *buf++;
+
+ for (i = 0; i < j; i++) {
+ if (!(i & 3)) {
+ sprintf(dummy, " %.2x", line[i] & 0xff);
+ strcat(str, dummy);
+ } else {
+ sprintf(dummy, "%.2x", line[i] & 0xff);
+ strcat(str, dummy);
+ }
+ }
+
+ /* Print empty space */
+ for (; i < 16; i++)
+ if (!(i & 1))
+ strcat(str, " ");
+ else
+ strcat(str, " ");
+
+ strcat(str, " ");
+ for (i = 0; i < j; i++) {
+ if (isprint(line[i])) {
+ sprintf(dummy, "%c", line[i]);
+ strcat(str, dummy);
+ } else {
+ strcat(str, ".");
+ }
+ }
+ printf("%s\n", str);
+ len -= 16;
+ }
+}
+
+static void
+print_status_help(void)
+{
+ printf("Error Codes from IPL\n");
+ printf(" IO Error %d\n", STAT_IO_FAILED);
+ printf(" Block is bad %d\n", STAT_BLOCK_BAD);
+ printf(" ECC unrec error %d\n", STAT_ECC_ERROR);
+ printf(" CRC csum failed %d\n", STAT_CRC_ERROR);
+ printf(" Magic not avail %d\n", STAT_NO_MAGIC);
+ printf(" No image avail %d\n", STAT_NO_IMAGE);
+ printf(" Image is invalid %d\n", STAT_INVALID_IMAGE);
+ printf(" Image is defect %d\n\n", STAT_DEFECT_IMAGE);
+
+}
+
+static void
+print_ubi_scan_info(struct ubi_scan_info *fi)
+{
+ int i;
+
+ printf("ubi_scan_info\n");
+ printf(" version %08x\n", ntohl(fi->version));
+ printf(" bootstatus %08x\n", ntohl(fi->bootstatus));
+ printf(" flashtype %08x\n", ntohl(fi->flashtype));
+ printf(" flashid %08x\n", ntohl(fi->flashid));
+ printf(" flashmfgr %08x\n", ntohl(fi->flashmfr));
+ printf(" flashsize %d bytes (%dM)\n",
+ ntohl(fi->flashsize), ntohl(fi->flashsize) / (1024 * 1024));
+ printf(" blocksize %d bytes\n", ntohl(fi->blocksize));
+ printf(" blockshift %d\n", ntohl(fi->blockshift));
+ printf(" nrblocks %d\n", ntohl(fi->nrblocks));
+ printf(" pagesize %d\n", ntohl(fi->pagesize));
+ printf(" imagelen %d\n", ntohl(fi->imagelen));
+ printf(" blockinfo %08x\n", ntohl((int)fi->blockinfo));
+
+ printf(" nr imageblocks imageoffs\n");
+ for (i = 0; i < UBI_BLOCK_IDENT_MAX; i++)
+ printf(" [%2d] %08x %08x\n", i,
+ ntohl(fi->imageblocks[i]),
+ ntohl(fi->imageoffs[i]));
+
+ for (i = 0; i < UBI_TIMESTAMPS; i++) {
+ if (!ntohl(fi->times[i]))
+ continue;
+ printf("time[%3d] = %08x %.3f sec\n", i, ntohl(fi->times[i]),
+ (double)ntohl(fi->times[i]) / 500000000.0);
+ }
+
+ printf("crc32_table\n");
+ hexdump((char *)&fi->crc32_table, sizeof(fi->crc32_table));
+ printf("\npage_buf\n");
+ hexdump((char *)&fi->page_buf, sizeof(fi->page_buf));
+
+ printf("\n");
+
+}
+
+static void
+print_ubi_block_info(struct ubi_scan_info *fi,
+ struct ubi_vid_hdr *bi, int nr)
+{
+ int i;
+ int unknown = 0;
+
+ printf("\nBINFO\n");
+
+ for (i = 0; i < nr; i++) {
+ if ((int)ubi32_to_cpu(bi[i].magic) != UBI_VID_HDR_MAGIC) {
+ printf("block=%d %08x\n",
+ i, i * ntohl(fi->blocksize));
+#if 0
+ printf(".");
+ if ((unknown & 0x3f) == 0x3f)
+ printf("\n");
+ unknown++;
+#else
+ hexdump((char *)&bi[i],
+ sizeof(struct ubi_vid_hdr));
+#endif
+ } else {
+ if (unknown)
+ printf("\n");
+ printf("block=%d %08x\n"
+ " leb_ver=0x%x data_size=%d "
+ "lnum=%d used_ebs=0x%x\n"
+ " data_crc=%08x hdr_crc=%08x\n",
+ i, i * ntohl(fi->blocksize),
+ ubi32_to_cpu(bi[i].leb_ver),
+ ubi32_to_cpu(bi[i].data_size),
+ ubi32_to_cpu(bi[i].lnum),
+ ubi32_to_cpu(bi[i].used_ebs),
+ ubi32_to_cpu(bi[i].data_crc),
+ ubi32_to_cpu(bi[i].hdr_crc));
+ hexdump((char *)&bi[i],
+ sizeof(struct ubi_vid_hdr));
+ unknown = 0;
+ }
+ }
+}
+
+static int do_read(unsigned int memtop, char *buf, int buf_len __unused)
+{
+ unsigned long finfo_addr;
+ unsigned long binfo_addr;
+ unsigned long images_addr;
+ unsigned long nrblocks;
+ unsigned long bi_size;
+ unsigned long images_size;
+ struct ubi_scan_info *fi;
+ struct ubi_vid_hdr *bi;
+ char *images;
+ unsigned long memaddr = memtop - MEMSIZE;
+
+ print_status_help();
+
+ /* Read and print FINFO */
+ finfo_addr = MEMSIZE - CFG_IPLSIZE * 1024;
+
+ printf("read info at addr %08lx\n", finfo_addr);
+ fi = (struct ubi_scan_info *)(buf + finfo_addr);
+
+ binfo_addr = ntohl((unsigned long)fi->blockinfo) - memaddr;
+ images_addr = ntohl((unsigned long)fi->images) - memaddr;
+ nrblocks = ntohl(fi->nrblocks);
+
+ printf("BINFO %08lx\n", binfo_addr);
+
+ bi_size = nrblocks * sizeof(struct ubi_vid_hdr);
+ images_size = nrblocks * sizeof(unsigned int);
+
+ printf("FINFO\n");
+ print_ubi_scan_info(fi);
+ /* hexdump((char *)fi, sizeof(*fi)); */
+
+ /* Read and print BINFO */
+ bi = (struct ubi_vid_hdr *)(buf + binfo_addr);
+ print_ubi_block_info(fi, bi, nrblocks);
+
+ /* Read and print IMAGES */
+ images = buf + images_addr;
+ printf("\nIMAGES\n");
+ hexdump(images, images_size);
+
+ return 0;
+}
+
+int main(int argc, char *argv[])
+{
+ char buf[MEMSIZE];
+ FILE *fp;
+ int rc;
+
+ argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, &g_args);
+
+ if (!g_args.arg1) {
+ fprintf(stderr, "Please specify a file "
+ "name for memory dump!\n");
+ exit(EXIT_FAILURE);
+ }
+
+ memset(buf, 0xAB, sizeof(buf));
+
+ fp = fopen(g_args.arg1, "r");
+ if (!fp)
+ exit(EXIT_FAILURE);
+ rc = fread(buf, 1, sizeof(buf), fp);
+ if (rc != sizeof(buf))
+ exit(EXIT_FAILURE);
+ fclose(fp);
+ do_read(g_args.memtop, buf, sizeof(buf));
+
+ exit(EXIT_SUCCESS);
+}
diff --git a/ubi-utils/src/ubiinfo/ubiipl.h b/ubi-utils/src/ubiinfo/ubiipl.h
new file mode 100644
index 0000000..3a8b900
--- /dev/null
+++ b/ubi-utils/src/ubiinfo/ubiipl.h
@@ -0,0 +1,87 @@
+#ifndef _UBI_IPL_H
+#define _UBI_IPL_H
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * Constants calculated from the CFG_XXX defines
+ *
+ * Declaration of the loader function which is invoked by the
+ * assembler part of the IPL
+ */
+
+/* Size of IPL - is 4K for NAND and can also be 4K for NOR */
+#define IPL_SIZE 4096
+
+/* Needed in asm code to upload the data, needed in C-code for CRC32 */
+#define IPL_RAMADDR (CFG_MEMTOP - IPL_SIZE)
+
+#if !defined(__ASSEMBLY__)
+
+#include <stdint.h>
+#include <mtd/ubi-header.h>
+
+/* Address of the flash info structure */
+#define FINFO_ADDR (struct ubi_scan_info *) (CFG_MEMTOP - CFG_IPLSIZE * 1024)
+
+/* Size of the flash info structure */
+#define FINFO_SIZE sizeof(struct ubi_scan_info)
+
+/* Blockinfo array address */
+#define BINFO_ADDR (struct ubi_vid_hdr *) ((void *)FINFO_ADDR + FINFO_SIZE)
+
+/* Number of erase blocks */
+#define NR_ERASE_BLOCKS ((CFG_FLASHSIZE * 1024) / CFG_BLOCKSIZE)
+
+/* Blockinfo size */
+#define BINFO_SIZE (NR_ERASE_BLOCKS * sizeof(struct ubi_vid_hdr))
+
+/* Images array address */
+#define IMAGES_ADDR (struct ubi_vid_hdr **) ((void *)BINFO_ADDR + BINFO_SIZE)
+
+/* Images array size */
+#define IMAGES_SIZE (NR_ERASE_BLOCKS * sizeof(unsigned int))
+
+/* Total size of flash info + blockinfo + images */
+#define INFO_SIZE ((FINFO_SIZE + BINFO_SIZE + IMAGES_SIZE) / sizeof(uint32_t))
+
+/* Load address of the SPL */
+#define SPL_ADDR (void *) ((void *)FINFO_ADDR - CFG_SPLCODE * 1024)
+
+#define IPL_SIZE_CRC32 (IPL_SIZE - sizeof(uint32_t))
+#define IPL_RAMADDR_CRC32 ((void *)(IPL_RAMADDR + sizeof(uint32_t)))
+
+/*
+ * Linker script magic to ensure that load_spl() is linked to the
+ * right place
+ */
+#define __crc32 __attribute__((__section__(".crc32")))
+#define __entry __attribute__((__section__(".entry.text")))
+#define __unused __attribute__((unused))
+
+#define MIN(x,y) ((x)<(y)?(x):(y))
+
+#define stop_on_error(x) \
+ { while (1); }
+
+void __entry load_spl(void);
+void hardware_init(void);
+
+#endif /* __ASSEMBLY__ */
+
+#endif
diff --git a/ubi-utils/src/ubimirror/ubimirror.c b/ubi-utils/src/ubimirror/ubimirror.c
new file mode 100644
index 0000000..e43ba10
--- /dev/null
+++ b/ubi-utils/src/ubimirror/ubimirror.c
@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Oliver Lohmann
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <getopt.h>
+#include <argp.h>
+#include <unistd.h>
+#include <errno.h>
+#include <mtd/ubi-header.h>
+
+#include "config.h"
+#include "error.h"
+#include "example_ubi.h"
+#include "ubimirror.h"
+
+typedef enum action_t {
+ ACT_NORMAL = 0,
+ ACT_ARGP_ABORT,
+ ACT_ARGP_ERR,
+} action_t;
+
+#define ABORT_ARGP do { \
+ state->next = state->argc; \
+ args->action = ACT_ARGP_ABORT; \
+} while (0)
+
+#define ERR_ARGP do { \
+ state->next = state->argc; \
+ args->action = ACT_ARGP_ERR; \
+} while (0)
+
+#define VOL_ARGS_MAX 2
+
+
+const char *argp_program_version = PACKAGE_VERSION;
+const char *argp_program_bug_address = PACKAGE_BUGREPORT;
+static char doc[] = "\nVersion: " PACKAGE_VERSION "\n\tBuilt on "
+ BUILD_CPU" "BUILD_OS" at "__DATE__" "__TIME__"\n"
+ "\n"
+ "ubimirror - mirrors ubi volumes.\n";
+
+static const char copyright [] __attribute__((unused)) =
+ "(C) IBM Coorporation 2007";
+
+
+static struct argp_option options[] = {
+ { name: "copyright", key: 'c', arg: NULL, flags: 0,
+ doc: "Print copyright information.",
+ group: 1 },
+
+ { name: "side", key: 's', arg: "<seqnum>", flags: 0,
+ doc: "Use the side <seqnum> as source.",
+ group: 1 },
+
+ { name: NULL, key: 0, arg: NULL, flags: 0, doc: NULL, group: 0 },
+};
+
+typedef struct myargs {
+ action_t action;
+ int side;
+ int vol_no; /* index of current volume */
+ /* @FIXME replace by bootenv_list, makes live easier */
+ /* @FIXME remove the constraint of two entries in the array */
+ const char* vol[VOL_ARGS_MAX]; /* comma separated list of src/dst
+ volumes */
+ char *arg1;
+ char **options; /* [STRING...] */
+} myargs;
+
+static int
+get_update_side(const char* str)
+{
+ uint32_t i = strtoul(str, NULL, 0);
+
+ if ((i != 0) && (i != 1)) {
+ return -1;
+ }
+ return i;
+}
+
+
+static error_t
+parse_opt(int key, char *arg, struct argp_state *state)
+{
+ int err = 0;
+
+ myargs *args = state->input;
+
+ switch (key) {
+ case 'c':
+ err_msg("%s\n", copyright);
+ ABORT_ARGP;
+ break;
+ case 's':
+ args->side = get_update_side(arg);
+ if (args->side < 0) {
+ err_msg("Unsupported seqnum: %s.\n"
+ "Supported seqnums are '0' and '1'\n", arg);
+ ERR_ARGP;
+ }
+ break;
+ case ARGP_KEY_ARG:
+ /* only two entries allowed */
+ if (args->vol_no >= VOL_ARGS_MAX) {
+ err_msg("\n");
+ argp_usage(state);
+ ERR_ARGP;
+ }
+ args->vol[(args->vol_no)++] = arg;
+ break;
+ case ARGP_KEY_END:
+ if (err) {
+ err_msg("\n");
+ argp_usage(state);
+ ERR_ARGP;
+ }
+ break;
+ default:
+ return(ARGP_ERR_UNKNOWN);
+ }
+
+ return 0;
+}
+
+static struct argp argp = {
+ options: options,
+ parser: parse_opt,
+ args_doc: "<source> <destination>",
+ doc: doc,
+ children: NULL,
+ help_filter: NULL,
+ argp_domain: NULL,
+};
+
+
+int
+main(int argc, char **argv) {
+ int rc = 0;
+ unsigned int ids[VOL_ARGS_MAX];
+ char err_buf[1024];
+
+ myargs args = {
+ .action = ACT_NORMAL,
+ .side = -1,
+ .vol_no = 0,
+ .vol = {"", ""},
+ .options = NULL,
+ };
+
+ argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, &args);
+ if (args.action == ACT_ARGP_ERR) {
+ rc = 127;
+ goto err;
+ }
+ if (args.action == ACT_ARGP_ABORT) {
+ rc = 126;
+ goto out;
+ }
+ if (args.vol_no < VOL_ARGS_MAX) {
+ fprintf(stderr, "missing volume number for %s\n",
+ args.vol_no == 0 ? "source and target" : "target");
+ rc = 125;
+ goto out;
+ }
+ for( rc = 0; rc < args.vol_no; ++rc){
+ char *endp;
+ ids[rc] = strtoul(args.vol[rc], &endp, 0);
+ if( *endp != '\0' ){
+ fprintf(stderr, "invalid volume number %s\n",
+ args.vol[rc]);
+ rc = 125;
+ goto out;
+ }
+ }
+ rc = ubimirror(EXAMPLE_UBI_DEVICE, args.side, ids, args.vol_no,
+ err_buf, sizeof(err_buf));
+ if( rc ){
+ err_buf[sizeof err_buf - 1] = '\0';
+ fprintf(stderr, err_buf);
+ if( rc < 0 )
+ rc = -rc;
+ }
+ out:
+ err:
+ return rc;
+}
diff --git a/ubi-utils/src/ubimkvol/ubimkvol.c b/ubi-utils/src/ubimkvol/ubimkvol.c
new file mode 100644
index 0000000..f929252
--- /dev/null
+++ b/ubi-utils/src/ubimkvol/ubimkvol.c
@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * An utility to create UBI volumes.
+ *
+ * Author: Artem B. Bityutskiy <dedekind@oktetlabs.ru>
+ *
+ * 1.0 Initial release
+ * 1.1 Does not support erase blocks anymore. This is replaced by
+ * the number of bytes.
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <getopt.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include <libubi.h>
+
+#define VERSION "1.1"
+
+static void usage(void);
+static int param_sanity_check(ubi_lib_t lib);
+static int parse_options(int argc, char * const argv[]);
+
+/*
+ * The variables below are set by command line arguments.
+ */
+static int vol_type = UBI_DYNAMIC_VOLUME;
+static int devn = -1;
+static long long bytes = 0;
+static int alignment = 1;
+static int vol_id = UBI_VOL_NUM_AUTO;
+static char *name = NULL;
+static int nlen = 0;
+
+int main(int argc, char * const argv[])
+{
+ int err;
+ ubi_lib_t lib;
+
+ err = parse_options(argc, argv);
+ if (err) {
+ fprintf(stderr, "Wrong options ...\n");
+ return err == 1 ? 0 : -1;
+ }
+
+ if (devn == -1) {
+ fprintf(stderr, "Device number was not specified\n");
+ fprintf(stderr, "Use -h option for help\n");
+ return -1;
+ }
+
+ err = ubi_open(&lib);
+ if (err) {
+ perror("Cannot open libubi");
+ return -1;
+ }
+
+ err = param_sanity_check(lib);
+ if (err) {
+ perror("Input parameters check");
+ fprintf(stderr, "Use -h option for help\n");
+ goto out_libubi;
+ }
+
+ err = ubi_mkvol(lib, devn, vol_id, vol_type, bytes, alignment, name);
+ if (err < 0) {
+ perror("Cannot create volume");
+ fprintf(stderr, " err=%d\n", err);
+ goto out_libubi;
+ }
+
+ /* printf("Created volume %d, %lld bytes, type %s, name %s\n",
+ vol_id, bytes, vol_type == UBI_DYNAMIC_VOLUME ?
+ "dynamic" : "static", name); */
+
+ vol_id = err;
+ ubi_close(&lib);
+ return 0;
+
+out_libubi:
+ ubi_close(&lib);
+ return -1;
+}
+
+/* 'getopt()' option string */
+static const char *optstring = "ht:s:n:N:d:a:";
+
+static int parse_options(int argc, char * const argv[])
+{
+ int opt = 0;
+
+ while (opt != -1) {
+ char *endp;
+
+ opt = getopt(argc, argv, optstring);
+
+ switch (opt) {
+ case 'h':
+ usage();
+ return 1;
+ case 't':
+ if (!strcmp(optarg, "dynamic"))
+ vol_type = UBI_DYNAMIC_VOLUME;
+ else if (!strcmp(optarg, "static"))
+ vol_type = UBI_STATIC_VOLUME;
+ else {
+ fprintf(stderr, "Bad volume type: \"%s\"\n",
+ optarg);
+ goto out;
+ }
+ break;
+ case 's':
+ bytes = strtoull(optarg, &endp, 0);
+ if (endp == optarg || bytes < 0) {
+ fprintf(stderr, "Bad volume size: \"%s\"\n",
+ optarg);
+ goto out;
+ }
+ if (endp != '\0') {
+ if (strcmp(endp, "KiB") == 0)
+ bytes *= 1024;
+ else if (strcmp(endp, "MiB") == 0)
+ bytes *= 1024*1024;
+ }
+ break;
+ case 'a':
+ alignment = strtoul(optarg, &endp, 0);
+ if (*endp != '\0' || endp == optarg ||
+ alignment <= 0) {
+ fprintf(stderr, "Bad volume alignment: "
+ "\"%s\"\n", optarg);
+ goto out;
+ }
+ break;
+ case 'd':
+ devn = strtoul(optarg, &endp, 0);
+ if (*endp != '\0' || endp == optarg || devn < 0) {
+ fprintf(stderr, "Bad UBI device number: "
+ "\"%s\"\n", optarg);
+ goto out;
+ }
+ break;
+ case 'n':
+ vol_id = strtoul(optarg, &endp, 0);
+ if (*endp != '\0' || endp == optarg ||
+ (vol_id < 0 && vol_id != UBI_DYNAMIC_VOLUME)) {
+ fprintf(stderr, "Bad volume ID: "
+ "\"%s\"\n", optarg);
+ goto out;
+ }
+ break;
+ case 'N':
+ name = optarg;
+ nlen = strlen(name);
+ break;
+
+ case ':':
+ fprintf(stderr, "Parameter is missing\n");
+ goto out;
+ case '?':
+ fprintf(stderr, "Unknown parameter\n");
+ goto out;
+ case -1:
+ break;
+ default:
+ fprintf(stderr, "Internal error\n");
+ goto out;
+ }
+ }
+
+ return 0;
+
+ out:
+ errno = EINVAL;
+ return -1;
+}
+
+static int param_sanity_check(ubi_lib_t lib)
+{
+ int err, len;
+ struct ubi_info ubi;
+
+ if (bytes == 0) {
+ fprintf(stderr, "Volume size was not specified\n");
+ goto out;
+ }
+
+ if (name == NULL) {
+ fprintf(stderr, "Volume name was not specified\n");
+ goto out;
+ }
+
+ err = ubi_get_info(lib, &ubi);
+ if (err)
+ return -1;
+
+ if (devn >= ubi.dev_count) {
+ fprintf(stderr, "Device %d does not exist\n", devn);
+ goto out;
+ }
+
+ len = strlen(name);
+ if (len > ubi.nlen_max) {
+ fprintf(stderr, "Too long name (%d symbols), max is %d\n",
+ len, ubi.nlen_max);
+ goto out;
+ }
+
+ return 0;
+
+out:
+ errno = EINVAL;
+ return -1;
+}
+
+static void usage(void)
+{
+ printf("Usage: ubi_mkvol OPTIONS\n"
+ "Version: " VERSION "\n"
+ "The command line options:\n"
+ "\t-h - this help message\n"
+ "\t-d - UBI device number\n"
+ "\t-t TYPE - volume type (dynamic, static) "
+ "(default is dynamic)\n"
+ "\t-n VOLID - volume ID to assign to the new volume. If not"
+ "specified, \n"
+ "\t the volume ID will be assigned automatically\n"
+ "\t-s BYTES - volume size in bytes, "
+ "kilobytes (KiB) or megabytes (MiB)\n"
+ "\t-N NAME - volume name\n"
+ "\t-a ALIGNMENT - volume alignment (default is 1)\n");
+}
diff --git a/ubi-utils/src/ubirmvol/ubirmvol.c b/ubi-utils/src/ubirmvol/ubirmvol.c
new file mode 100644
index 0000000..fc5ada5
--- /dev/null
+++ b/ubi-utils/src/ubirmvol/ubirmvol.c
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * An utility to create UBI volumes.
+ *
+ * Autor: Artem B. Bityutskiy <dedekind@oktetlabs.ru>
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <getopt.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <libubi.h>
+
+static void usage(void);
+static int param_sanity_check(ubi_lib_t lib);
+static int parse_options(int argc, char * const argv[]);
+
+/*
+ * The below variables are set by command line options.
+ */
+static int vol_id = -1;
+static int devn = -1;
+
+int main(int argc, char * const argv[])
+{
+ int err, old_errno;
+ ubi_lib_t lib;
+
+ err = parse_options(argc, argv);
+ if (err)
+ return err == 1 ? 0 : -1;
+
+ if (devn == -1) {
+ fprintf(stderr, "Device number was not specified\n");
+ fprintf(stderr, "Use -h option for help\n");
+ return -1;
+ }
+
+ err = ubi_open(&lib);
+ if (err) {
+ perror("Cannot open libubi");
+ return -1;
+ }
+
+ err = param_sanity_check(lib);
+ if (err) {
+ perror("Input parameters check");
+ fprintf(stderr, "Use -h option for help\n");
+ goto out_libubi;
+ }
+
+ err = ubi_rmvol(lib, devn, vol_id);
+ old_errno = errno;
+ if (err < 0) {
+ perror("Cannot remove volume");
+ fprintf(stderr, " err=%d errno=%d\n", err, old_errno);
+ goto out_libubi;
+ }
+
+ return 0;
+
+out_libubi:
+ ubi_close(&lib);
+ return -1;
+}
+
+/* 'getopt()' option string */
+static const char *optstring = "hd:n:";
+
+static int parse_options(int argc, char * const argv[])
+{
+ int opt = 0;
+
+ while (opt != -1) {
+ char *endp;
+
+ opt = getopt(argc, argv, optstring);
+
+ switch (opt) {
+ case 'h':
+ usage();
+ return 1;
+ case 'n':
+ vol_id = strtoul(optarg, &endp, 0);
+ if (*endp != '\0' || endp == optarg || vol_id < 0) {
+ fprintf(stderr, "Bad volume "
+ "number: \"%s\"\n", optarg);
+ goto out;
+ }
+ break;
+ case 'd':
+ devn = strtoul(optarg, &endp, 0);
+ if (*endp != '\0' || endp == optarg || devn < 0) {
+ fprintf(stderr, "Bad UBI device "
+ "number: \"%s\"\n", optarg);
+ goto out;
+ }
+ break;
+ case ':':
+ fprintf(stderr, "Parameter is missing\n");
+ goto out;
+ case '?':
+ fprintf(stderr, "Unknown parameter\n");
+ goto out;
+ case -1:
+ break;
+ default:
+ fprintf(stderr, "Internal error\n");
+ goto out;
+ }
+ }
+
+ return 0;
+
+out:
+ errno = EINVAL;
+ return -1;
+}
+
+static int param_sanity_check(ubi_lib_t lib)
+{
+ int err;
+ struct ubi_info ubi;
+
+ if (vol_id == -1) {
+ fprintf(stderr, "Volume ID was not specified\n");
+ goto out;
+ }
+
+ err = ubi_get_info(lib, &ubi);
+ if (err)
+ return -1;
+
+ if (devn >= ubi.dev_count) {
+ fprintf(stderr, "Device %d does not exist\n", devn);
+ goto out;
+ }
+
+ return 0;
+
+out:
+ errno = EINVAL;
+ return -1;
+}
+
+static void usage(void)
+{
+ printf("Usage: ubi_rmvol OPTIONS\n"
+ "Command line options:\n"
+ "\t-h - this help message\n"
+ "\t-d - UBI device number\n"
+ "\t-n VOLNUM - volume number to remove\n");
+}
diff --git a/ubi-utils/src/ubiwritevol/ubiwritevol.c b/ubi-utils/src/ubiwritevol/ubiwritevol.c
new file mode 100644
index 0000000..8fdbe37
--- /dev/null
+++ b/ubi-utils/src/ubiwritevol/ubiwritevol.c
@@ -0,0 +1,352 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Frank Haverkamp
+ *
+ * An utility to update UBI volumes.
+ */
+
+#include <config.h>
+
+#include <argp.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <getopt.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <libubi.h>
+
+#define MAXPATH 1024
+#define BUFSIZE 128 * 1024
+#define MIN(x,y) ((x)<(y)?(x):(y))
+
+struct args {
+ int device;
+ int volume;
+ int truncate;
+ int broken_update;
+ int bufsize;
+
+ /* special stuff needed to get additional arguments */
+ char *arg1;
+ char **options; /* [STRING...] */
+};
+
+static struct args myargs = {
+ .device = -1,
+ .volume = -1,
+ .truncate = 0,
+ .broken_update = 0,
+ .bufsize = BUFSIZE,
+ .arg1 = NULL,
+ .options = NULL,
+};
+
+static int verbose = 0;
+
+static error_t parse_opt (int key, char *arg, struct argp_state *state);
+
+const char *argp_program_bug_address = "<haver@vnet.ibm.com>";
+
+static char doc[] = "\nVersion: " VERSION "\n\t"
+ HOST_OS" "HOST_CPU" at "__DATE__" "__TIME__"\n"
+ "\nWrite to UBI Volume.\n";
+
+static struct argp_option options[] = {
+ { .name = "device",
+ .key = 'd',
+ .arg = "<device number>",
+ .flags = 0,
+ .doc = "UBI device",
+ .group = OPTION_ARG_OPTIONAL },
+
+ { .name = "volume",
+ .key = 'n',
+ .arg = "<volume id>",
+ .flags = 0,
+ .doc = "UBI volume id",
+ .group = OPTION_ARG_OPTIONAL },
+
+ { .name = "truncate",
+ .key = 't',
+ .arg = NULL,
+ .flags = 0,
+ .doc = "truncate volume",
+ .group = OPTION_ARG_OPTIONAL },
+
+ { .name = "broken-update",
+ .key = 'B',
+ .arg = NULL,
+ .flags = 0,
+ .doc = "broken update, this is for testing",
+ .group = OPTION_ARG_OPTIONAL },
+
+ { .name = NULL, .key = 0, .arg = NULL, .flags = 0,
+ .doc = NULL, .group = 0 },
+};
+
+static struct argp argp = {
+ .options = options,
+ .parser = parse_opt,
+ .args_doc = 0,
+ .doc = doc,
+ .children = NULL,
+ .help_filter = NULL,
+ .argp_domain = NULL,
+};
+
+/*
+ * @brief Parse the arguments passed into the test case.
+ *
+ * @param key The parameter.
+ * @param arg Argument passed to parameter.
+ * @param state Location to put information on parameters.
+ *
+ * @return error
+ *
+ * Get the `input' argument from `argp_parse', which we know is a
+ * pointer to our arguments structure.
+ */
+static error_t
+parse_opt(int key, char *arg, struct argp_state *state)
+{
+ struct args *args = state->input;
+
+ switch (key) {
+ case 'v': /* --verbose=<level> */
+ verbose = strtoul(arg, (char **)NULL, 0);
+ break;
+
+ case 'd': /* --device=<device number> */
+ args->device = strtol(arg, (char **)NULL, 0);
+ break;
+
+ case 'b': /* --bufsize=<bufsize> */
+ args->bufsize = strtol(arg, (char **)NULL, 0);
+ if (args->bufsize <= 0)
+ args->bufsize = BUFSIZE;
+ break;
+
+ case 't': /* --truncate */
+ args->truncate = 1;
+ break;
+
+ case 'B': /* --broken-update */
+ args->broken_update = 1;
+ break;
+
+ case 'n': /* --volume=<volume id> */
+ args->volume = strtol(arg, (char **)NULL, 0);
+ break;
+
+ case ARGP_KEY_NO_ARGS:
+ /* argp_usage(state); */
+ break;
+
+ case ARGP_KEY_ARG:
+ args->arg1 = arg;
+ /* Now we consume all the rest of the arguments.
+ `state->next' is the index in `state->argv' of the
+ next argument to be parsed, which is the first STRING
+ we're interested in, so we can just use
+ `&state->argv[state->next]' as the value for
+ arguments->strings.
+
+ _In addition_, by setting `state->next' to the end
+ of the arguments, we can force argp to stop parsing here and
+ return. */
+
+ args->options = &state->argv[state->next];
+ state->next = state->argc;
+ break;
+
+ case ARGP_KEY_END:
+ /* argp_usage(state); */
+ break;
+
+ default:
+ return(ARGP_ERR_UNKNOWN);
+ }
+
+ return 0;
+}
+
+/**
+ * @bytes bytes must be always 0, if not 0 this is a testcase for a
+ * broken volume update where data is promissed to be written, but for
+ * some reason nothing is written. The volume is unusable after this.
+ */
+static int
+ubi_truncate_volume(struct args *args, int64_t bytes)
+{
+ int rc, ofd;
+ char path[MAXPATH];
+ int old_errno;
+
+ snprintf(path, MAXPATH-1, "/dev/ubi%d_%d", args->device, args->volume);
+ path[MAXPATH-1] = '\0';
+
+ ofd = open(path, O_RDWR);
+ if (ofd < 0) {
+ fprintf(stderr, "Cannot open volume %s\n", path);
+ exit(EXIT_FAILURE);
+ }
+ rc = ioctl(ofd, UBI_IOCVOLUP, &bytes);
+ old_errno = errno;
+ if (rc < 0) {
+ perror("UBI volume update ioctl");
+ fprintf(stderr, " rc=%d errno=%d\n", rc, old_errno);
+ exit(EXIT_FAILURE);
+ }
+ close(ofd);
+ return 0;
+}
+
+static ssize_t ubi_write(int fd, const void *buf, size_t count)
+{
+ int rc;
+ int len = count;
+
+ while (len) {
+ rc = write(fd, buf, len);
+ if (rc == -1) {
+ if (errno == EINTR)
+ continue; /* try again */
+ perror("write error");
+ return rc;
+ }
+
+ len -= rc;
+ buf += rc;
+ }
+ return count;
+}
+
+static int
+ubi_update_volume(struct args *args)
+{
+ int rc, ofd;
+ FILE *ifp = NULL;
+ struct stat st;
+ int size = 0;
+ char *fname = args->arg1;
+ char path[MAXPATH];
+ char *buf;
+ int64_t bytes = 0;
+ int old_errno;
+
+ buf = malloc(args->bufsize);
+ if (!buf) {
+ perror("Out of memory");
+ exit(EXIT_FAILURE);
+ }
+
+ if (fname == NULL) {
+ fprintf(stderr, "Please specify an existing file.\n");
+ exit(EXIT_FAILURE);
+ }
+
+ rc = stat(fname, &st);
+ if (rc < 0) {
+ fprintf(stderr, "Cannot stat input file %s\n", fname);
+ exit(EXIT_FAILURE);
+ }
+ bytes = size = st.st_size;
+
+ ifp = fopen(fname, "r");
+ if (!ifp)
+ exit(EXIT_FAILURE);
+
+ snprintf(path, MAXPATH-1, "/dev/ubi%d_%d", args->device, args->volume);
+ path[MAXPATH-1] = '\0';
+
+ ofd = open(path, O_RDWR);
+ if (ofd < 0) {
+ fprintf(stderr, "Cannot open UBI volume %s\n", path);
+ exit(EXIT_FAILURE);
+ }
+
+ rc = ioctl(ofd, UBI_IOCVOLUP, &bytes);
+ old_errno = errno;
+ if (rc < 0) {
+ perror("UBI volume update ioctl");
+ fprintf(stderr, " rc=%d errno=%d\n", rc, old_errno);
+ exit(EXIT_FAILURE);
+ }
+
+ while (size > 0) {
+ ssize_t tocopy = MIN(args->bufsize, size);
+
+ rc = fread(buf, tocopy, 1, ifp);
+ if (rc != 1) {
+ perror("Could not read everything.");
+ exit(EXIT_FAILURE);
+ }
+
+ rc = ubi_write(ofd, buf, tocopy);
+ old_errno = errno;
+ if (rc != tocopy) {
+ perror("Could not write to device");
+ fprintf(stderr, " rc=%d errno=%d\n", rc, old_errno);
+ exit(EXIT_FAILURE);
+ }
+ size -= tocopy;
+ }
+
+ free(buf);
+ fclose(ifp);
+ rc = close(ofd);
+ if (rc != 0) {
+ perror("UBI volume close failed");
+ exit(EXIT_FAILURE);
+ }
+ return 0;
+}
+
+int
+main(int argc, char *argv[])
+{
+ int rc;
+
+ argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, &myargs);
+
+ if (myargs.truncate) {
+ rc = ubi_truncate_volume(&myargs, 0LL);
+ if (rc < 0)
+ exit(EXIT_FAILURE);
+ exit(EXIT_SUCCESS);
+ }
+ if (myargs.broken_update) {
+ rc = ubi_truncate_volume(&myargs, 1LL);
+ if (rc < 0)
+ exit(EXIT_FAILURE);
+ exit(EXIT_SUCCESS);
+ }
+ rc = ubi_update_volume(&myargs);
+ if (rc < 0)
+ exit(EXIT_FAILURE);
+
+ exit(EXIT_SUCCESS);
+}
diff --git a/ubi-utils/src/unubi/unubi.c b/ubi-utils/src/unubi/unubi.c
new file mode 100644
index 0000000..9cb1354
--- /dev/null
+++ b/ubi-utils/src/unubi/unubi.c
@@ -0,0 +1,391 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Frank Haverkamp
+ *
+ * An utility to decompose UBI images. Not yet finished ...
+ */
+
+#include <config.h>
+#include <argp.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <getopt.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include "crc32.h"
+#include <mtd/ubi-header.h>
+
+#define MAXPATH 1024
+#define MIN(x,y) ((x)<(y)?(x):(y))
+
+static uint32_t crc32_table[256];
+
+struct args {
+ const char *output_dir;
+ uint32_t hdr_offs;
+ uint32_t data_offs;
+ uint32_t blocksize;
+
+ /* special stuff needed to get additional arguments */
+ char *arg1;
+ char **options; /* [STRING...] */
+};
+
+static struct args myargs = {
+ .output_dir = "unubi",
+ .hdr_offs = 64,
+ .data_offs = 128,
+ .blocksize = 128 * 1024,
+ .arg1 = NULL,
+ .options = NULL,
+};
+
+static error_t parse_opt (int key, char *arg, struct argp_state *state);
+
+const char *argp_program_bug_address = "<haver@vnet.ibm.com>";
+
+static char doc[] = "\nVersion: " VERSION "\n\t"
+ HOST_OS" "HOST_CPU" at "__DATE__" "__TIME__"\n"
+ "\nWrite to UBI Volume.\n";
+
+static struct argp_option options[] = {
+ { .name = "dir",
+ .key = 'd',
+ .arg = "<output-dir>",
+ .flags = 0,
+ .doc = "output directory",
+ .group = OPTION_ARG_OPTIONAL },
+
+ { .name = "blocksize",
+ .key = 'b',
+ .arg = "<blocksize>",
+ .flags = 0,
+ .doc = "blocksize",
+ .group = OPTION_ARG_OPTIONAL },
+
+ { .name = "data-offs",
+ .key = 'x',
+ .arg = "<data-offs>",
+ .flags = 0,
+ .doc = "data offset",
+ .group = OPTION_ARG_OPTIONAL },
+
+ { .name = "hdr-offs",
+ .key = 'x',
+ .arg = "<hdr-offs>",
+ .flags = 0,
+ .doc = "hdr offset",
+ .group = OPTION_ARG_OPTIONAL },
+
+ { .name = NULL, .key = 0, .arg = NULL, .flags = 0,
+ .doc = NULL, .group = 0 },
+};
+
+static struct argp argp = {
+ .options = options,
+ .parser = parse_opt,
+ .args_doc = "image-file",
+ .doc = doc,
+ .children = NULL,
+ .help_filter = NULL,
+ .argp_domain = NULL,
+};
+
+/*
+ * str_to_num - Convert string into number and cope with endings like
+ * k, K, kib, KiB for kilobyte
+ * m, M, mib, MiB for megabyte
+ */
+uint32_t str_to_num(char *str)
+{
+ char *s = str;
+ ulong num = strtoul(s, &s, 0);
+
+ if (*s != '\0') {
+ if (strcmp(s, "KiB") == 0)
+ num *= 1024;
+ else if (strcmp(s, "MiB") == 0)
+ num *= 1024*1024;
+ else {
+ fprintf(stderr, "WARNING: Wrong number format "
+ "\"%s\", check your paramters!\n", str);
+ }
+ }
+ return num;
+}
+
+/*
+ * @brief Parse the arguments passed into the test case.
+ *
+ * @param key The parameter.
+ * @param arg Argument passed to parameter.
+ * @param state Location to put information on parameters.
+ *
+ * @return error
+ *
+ * Get the `input' argument from `argp_parse', which we know is a
+ * pointer to our arguments structure.
+ */
+static error_t
+parse_opt(int key, char *arg, struct argp_state *state)
+{
+ struct args *args = state->input;
+
+ switch (key) {
+ case 'b': /* --blocksize<blocksize> */
+ args->blocksize = str_to_num(arg);
+ break;
+
+ case 'x': /* --data-offs=<data-offs> */
+ args->data_offs = str_to_num(arg);
+ break;
+
+ case 'y': /* --hdr-offs=<hdr-offs> */
+ args->hdr_offs = str_to_num(arg);
+ break;
+
+ case 'd': /* --dir=<output-dir> */
+ args->output_dir = arg;
+ break;
+
+ case ARGP_KEY_NO_ARGS:
+ /* argp_usage(state); */
+ break;
+
+ case ARGP_KEY_ARG:
+ args->arg1 = arg;
+ /* Now we consume all the rest of the arguments.
+ `state->next' is the index in `state->argv' of the
+ next argument to be parsed, which is the first STRING
+ we're interested in, so we can just use
+ `&state->argv[state->next]' as the value for
+ arguments->strings.
+
+ _In addition_, by setting `state->next' to the end
+ of the arguments, we can force argp to stop parsing
+ here and return. */
+
+ args->options = &state->argv[state->next];
+ state->next = state->argc;
+ break;
+
+ case ARGP_KEY_END:
+ /* argp_usage(state); */
+ break;
+
+ default:
+ return(ARGP_ERR_UNKNOWN);
+ }
+
+ return 0;
+}
+
+static inline void
+hexdump(FILE *fp, const void *p, size_t size)
+{
+ int k;
+ const uint8_t *buf = p;
+
+ for (k = 0; k < size; k++) {
+ fprintf(fp, "%02x ", buf[k]);
+ if ((k & 15) == 15)
+ fprintf(fp, "\n");
+ }
+}
+
+/*
+ * This was put together in 1.5 hours and this is exactly how it looks
+ * like! FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
+ * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
+ * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
+ * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
+ * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
+ * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
+ * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
+ * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
+ * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
+ * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
+ * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
+ * FIXME FIXME FIXME FIXME FIXME FIXME!
+ */
+static int extract_volume(struct args *args, const uint8_t *buf,
+ int len, int volume, FILE *fp)
+{
+ int i, rc;
+ int nrblocks = len / args->blocksize;
+ int max_lnum = -1, lnum = 0;
+ const uint8_t *ptr;
+ uint8_t **vol_tab;
+ int *vol_len;
+
+ vol_tab = calloc(nrblocks, sizeof(uint8_t *));
+ vol_len = calloc(nrblocks, sizeof(int));
+
+ if (!buf || !vol_tab || !vol_len)
+ exit(EXIT_FAILURE);
+
+ for (i = 0, ptr = buf; i < nrblocks; i++, ptr += args->blocksize) {
+ uint32_t crc;
+ struct ubi_ec_hdr *ec_hdr = (struct ubi_ec_hdr *)ptr;
+ struct ubi_vid_hdr *vid_hdr = NULL;
+ uint8_t *data;
+
+ /* default */
+ vol_len[lnum] = args->blocksize - (2 * 1024);
+
+ /* Check UBI EC header */
+ crc = clc_crc32(crc32_table, UBI_CRC32_INIT, ec_hdr,
+ UBI_EC_HDR_SIZE_CRC);
+ if (crc != ubi32_to_cpu(ec_hdr->hdr_crc))
+ continue;
+
+ vid_hdr = (struct ubi_vid_hdr *)
+ (ptr + ubi32_to_cpu(ec_hdr->vid_hdr_offset));
+ data = (uint8_t *)(ptr + ubi32_to_cpu(ec_hdr->data_offset));
+
+ crc = clc_crc32(crc32_table, UBI_CRC32_INIT, vid_hdr,
+ UBI_VID_HDR_SIZE_CRC);
+ if (crc != ubi32_to_cpu(vid_hdr->hdr_crc))
+ continue;
+
+ if (volume == ubi32_to_cpu(vid_hdr->vol_id)) {
+
+ printf("****** block %4d volume %2d **********\n",
+ i, volume);
+
+ hexdump(stdout, ptr, 64);
+
+ printf("--- vid_hdr\n");
+ hexdump(stdout, vid_hdr, 64);
+
+ printf("--- data\n");
+ hexdump(stdout, data, 64);
+
+ lnum = ubi32_to_cpu(vid_hdr->lnum);
+ vol_tab[lnum] = data;
+ if (max_lnum < lnum)
+ max_lnum = lnum;
+ if (vid_hdr->vol_type == UBI_VID_STATIC)
+ vol_len[lnum] =
+ ubi32_to_cpu(vid_hdr->data_size);
+
+ }
+ }
+
+ for (lnum = 0; lnum <= max_lnum; lnum++) {
+ if (vol_tab[lnum]) {
+ rc = fwrite(vol_tab[lnum], 1, vol_len[lnum], fp);
+ if (ferror(fp) || (vol_len[lnum] != rc)) {
+ perror("could not write file");
+ exit(EXIT_FAILURE);
+ }
+ } else {
+ /* Fill up empty areas by 0xff, for static
+ * volumes this means they are broken!
+ */
+ for (i = 0; i < vol_len[lnum]; i++) {
+ if (fputc(0xff, fp) == EOF) {
+ perror("could not write char");
+ exit(EXIT_FAILURE);
+ }
+ }
+ }
+ }
+
+ free(vol_tab);
+ free(vol_len);
+ return 0;
+}
+
+int
+main(int argc, char *argv[])
+{
+ int len, rc;
+ FILE *fp;
+ struct stat file_info;
+ uint8_t *buf;
+ int i;
+
+ init_crc32_table(crc32_table);
+
+ argp_parse(&argp, argc, argv, ARGP_IN_ORDER, 0, &myargs);
+
+ if (!myargs.arg1) {
+ fprintf(stderr, "Please specify input file!\n");
+ exit(EXIT_FAILURE);
+ }
+
+ fp = fopen(myargs.arg1, "r");
+ if (!fp) {
+ perror("Cannot open file");
+ exit(EXIT_FAILURE);
+ }
+ if (fstat(fileno(fp), &file_info) != 0) {
+ fprintf(stderr, "Cannot fetch file size "
+ "from input file.\n");
+ }
+ len = file_info.st_size;
+ buf = malloc(len);
+ if (!buf) {
+ perror("out of memory!");
+ exit(EXIT_FAILURE);
+ }
+ rc = fread(buf, 1, len, fp);
+ if (ferror(fp) || (len != rc)) {
+ perror("could not read file");
+ exit(EXIT_FAILURE);
+ }
+ if (!myargs.output_dir) {
+ fprintf(stderr, "No output directory specified!\n");
+ exit(EXIT_FAILURE);
+ }
+
+ rc = mkdir(myargs.output_dir, 0777);
+ if (rc && errno != EEXIST) {
+ perror("Cannot create output directory");
+ exit(EXIT_FAILURE);
+ }
+ for (i = 0; i < 32; i++) {
+ char fname[1024];
+ FILE *fpout;
+
+ printf("######### VOLUME %d ############################\n",
+ i);
+
+ sprintf(fname, "%s/ubivol_%d.bin", myargs.output_dir, i);
+ fpout = fopen(fname, "w+");
+ if (!fpout) {
+ perror("Cannot open file");
+ exit(EXIT_FAILURE);
+ }
+ extract_volume(&myargs, buf, len, i, fpout);
+ fclose(fpout);
+ }
+
+ fclose(fp);
+ free(buf);
+ exit(EXIT_SUCCESS);
+}
diff --git a/ubi-utils/testcases.txt b/ubi-utils/testcases.txt
new file mode 100644
index 0000000..dcc1c35
--- /dev/null
+++ b/ubi-utils/testcases.txt
@@ -0,0 +1,9 @@
+1. Start some large update, but write there byte-by-byte
+
+2. start update for N bytes, write N-x bytes, then write y bytes, y>x.
+ You have to see that at the last write only x bytes were written,
+ but y-x bytes were not. we may vary x a bit. good number would be
+ 1, 128, 128Ki-128...
+
+3. Try to start update for x bytes, write x bytes, then try to write more.
+ Check that it is impossible to write more.