SPL: Lightweight UBI and UBI fastmap support

Booting a payload out of NAND FLASH from the SPL is a crux today, as it requires hard partioned FLASH. Not a brilliant idea with the reliability of todays NAND FLASH chips.

doc/README.ubispl new file +41 -0

+Usage notes:
+
+In the board config file define for example:
+
+#define CONFIG_SPL_UBI
+#define CONFIG_SPL_UBI_MAX_VOL_LEBS	256
+#define CONFIG_SPL_UBI_MAX_PEB_SIZE	(256*1024)
+#define CONFIG_SPL_UBI_MAX_PEBS		4096
+#define CONFIG_SPL_UBI_VOL_IDS		8
+
+The size requirement is roughly as follows:
+
+    2k for the basic data structure
+  + CONFIG_SPL_UBI_VOL_IDS * CONFIG_SPL_UBI_MAX_VOL_LEBS * 8
+  + CONFIG_SPL_UBI_MAX_PEBS * 64
+  + CONFIG_SPL_UBI_MAX_PEB_SIZE * UBI_FM_MAX_BLOCKS
+
+The last one is big, but I really don't care in that stage. Real world
+implementations only use the first couple of blocks, but the code
+handles up to UBI_FM_MAX_BLOCKS.
+
+Given the above configuration example the requirement is about 5M
+which is usually not a problem to reserve in the RAM along with the
+other areas like the kernel/dts load address.
+
+So something like this will do the trick:
+
+#define SPL_FINFO_ADDR			0x80800000
+#define SPL_DTB_LOAD_ADDR		0x81800000
+#define SPL_KERNEL_LOAD_ADDR		0x82000000
+
+In the board file, implement the following:
+
+static struct ubispl_load myvolumes[] = {
+	{
+		.name		= "Kernel",
+		.vol_id		= 0,
+		.load_addr	= (void *)SPL_KERNEL_LOAD_ADDR,
+	},
+	{
+		.name		= "DTB",

drivers/mtd/ubispl/ubispl.c new file +16 -0

+#ifdef LATER
+		int image_seq;
+		ret = ubi_io_read_ec_hdr(ubi, pnum, ech, 0);
+		if (ret && ret != UBI_IO_BITFLIPS) {
+			ubi_err("unable to read fastmap block# %i EC (PEB: %i)",
+				i, pnum);
+			if (ret > 0)
+				ret = UBI_BAD_FASTMAP;
+			goto free_hdr;
+		} else if (ret == UBI_IO_BITFLIPS)
+			fm->to_be_tortured[i] = 1;
+
+		image_seq = be32_to_cpu(ech->image_seq);
+		if (!ubi->image_seq)
+			ubi->image_seq = image_seq;
+		/*

Quoted 3 lines · Thomas Gleixner

Booting a payload out of NAND FLASH from the SPL is a crux today, as it requires hard partioned FLASH. Not a brilliant idea with the reliability of todays NAND FLASH chips.

[snip]

README FIT uImage format: · line 3461

Quoted 3 lines

README +3 -0

+		CONFIG_SPL_UBI
+		Support for a lightweight UBI (fastmap) scanner and
+		loader

... for the related options, please see doc/README.ubispl

Quoted 48 lines

doc/README.ubispl new file +48 -0

+Usage notes:
+
+In the board config file define for example:
+
+#define CONFIG_SPL_UBI
+#define CONFIG_SPL_UBI_MAX_VOL_LEBS	256
+#define CONFIG_SPL_UBI_MAX_PEB_SIZE	(256*1024)
+#define CONFIG_SPL_UBI_MAX_PEBS		4096
+#define CONFIG_SPL_UBI_VOL_IDS		8
+
+The size requirement is roughly as follows:
+
+    2k for the basic data structure
+  + CONFIG_SPL_UBI_VOL_IDS * CONFIG_SPL_UBI_MAX_VOL_LEBS * 8
+  + CONFIG_SPL_UBI_MAX_PEBS * 64
+  + CONFIG_SPL_UBI_MAX_PEB_SIZE * UBI_FM_MAX_BLOCKS
+
+The last one is big, but I really don't care in that stage. Real world
+implementations only use the first couple of blocks, but the code
+handles up to UBI_FM_MAX_BLOCKS.
+
+Given the above configuration example the requirement is about 5M
+which is usually not a problem to reserve in the RAM along with the
+other areas like the kernel/dts load address.
+
+So something like this will do the trick:
+
+#define SPL_FINFO_ADDR			0x80800000
+#define SPL_DTB_LOAD_ADDR		0x81800000
+#define SPL_KERNEL_LOAD_ADDR		0x82000000
+
+In the board file, implement the following:
+
+static struct ubispl_load myvolumes[] = {
+	{
+		.name		= "Kernel",
+		.vol_id		= 0,
+		.load_addr	= (void *)SPL_KERNEL_LOAD_ADDR,
+	},
+	{
+		.name		= "DTB",
+		.vol_id		= 1,
+		.load_addr	= (void *)SPL_DTB_LOAD_ADDR,
+	}
+};
+
+int spl_start_uboot(void)
+{

doc/README.ubispl line 83

Quoted 3 lines

doc/README.ubispl new file +3 -0

+	struct ubispl_info info;
+
+	info.ubi = (struct ubi_scan_info *) SPL_FINFO_ADDR;

OK, so here's some problems with the example. First, we can / should (and OK, after you posted the patch this went in) moved stack into DDR in some cases, so in the case of wanting to use this, DDR would have to be up in time for that to be a valid option, so we shoudl just do that.

Second, we have CONFIG_SYS_SPL_ARGS_ADDR for where the DT would go and since Falcon supports uImages only (And if/when zImage is added, we'll have to sort something out generically) we don't need to hard-code in a load address for the kernel.

drivers/mtd/ubispl/ubispl.c line 68

Quoted 5 lines

drivers/mtd/ubispl/ubispl.c new file +5 -0

+	/*
+	 * Bad block, unrecoverable ECC error, skip the block
+	 */
+	if (res) {
+		ubi_dbg("Skipping bad or unreadable block %d", pnum);

Here and everywhere else, we have debug() please use that.

Quoted 5 lines

drivers/mtd/ubispl/ubispl.c new file +5 -0

+#ifdef CHECKME
+	/*
+	 * If fastmap is leaking PEBs (must not happen), raise a
+	 * fat warning and fall back to scanning mode.
+	 * We do this here because in ubi_wl_init() it's too late

drivers/mtd/ubispl/ubispl.c line 476

Quoted 6 lines

drivers/mtd/ubispl/ubispl.c new file +6 -0

+	 * and we cannot fall back to scanning.
+	 */
+	if (WARN_ON(count_fastmap_pebs(ai) != ubi->peb_count -
+		    ai->bad_peb_count - fm->used_blocks))
+		goto fail_bad;
+#endif

Use DEBUG here?

Quoted 20 lines

drivers/mtd/ubispl/ubispl.c new file +20 -0

+#ifdef LATER
+		int image_seq;
+		ret = ubi_io_read_ec_hdr(ubi, pnum, ech, 0);
+		if (ret && ret != UBI_IO_BITFLIPS) {
+			ubi_err("unable to read fastmap block# %i EC (PEB: %i)",
+				i, pnum);
+			if (ret > 0)
+				ret = UBI_BAD_FASTMAP;
+			goto free_hdr;
+		} else if (ret == UBI_IO_BITFLIPS)
+			fm->to_be_tortured[i] = 1;
+
+		image_seq = be32_to_cpu(ech->image_seq);
+		if (!ubi->image_seq)
+			ubi->image_seq = image_seq;
+		/*
+		 * Older UBI implementations have image_seq set to zero, so
+		 * we shouldn't fail if image_seq == 0.
+		 */
+		if (image_seq && (image_seq != ubi->image_seq)) {

drivers/mtd/ubispl/ubispl.c line 572

Quoted 6 lines

drivers/mtd/ubispl/ubispl.c new file +6 -0

+			ubi_err("wrong image seq:%d instead of %d",
+				be32_to_cpu(ech->image_seq), ubi->image_seq);
+			ret = UBI_BAD_FASTMAP;
+			goto free_hdr;
+		}
+#endif

What is LATER in this context? Missing functionality? Or debug code?

drivers/mtd/ubispl/ubispl.c new file +7 -0

+/**
+ * ubi_calc_fm_size - calculates the fastmap size in bytes for an UBI device.
+ * @ubi: UBI device description object
+ */
+static size_t ubi_calc_fm_size(struct ubi_scan_info *ubi)
+{
+	size_t size;

Am 05.07.2014 11:48, schrieb Thomas Gleixner:

Quoted 12 lines

drivers/mtd/ubispl/ubispl.c new file +12 -0

+/**
+ * ubi_calc_fm_size - calculates the fastmap size in bytes for an UBI device.
+ * @ubi: UBI device description object
+ */
+static size_t ubi_calc_fm_size(struct ubi_scan_info *ubi)
+{
+	size_t size;
+
+	size = sizeof(struct ubi_fm_hdr) + \
+		sizeof(struct ubi_fm_scan_pool) + \
+		sizeof(struct ubi_fm_scan_pool) + \
+		(ubi->peb_count * sizeof(struct ubi_fm_ec)) + \

drivers/mtd/ubispl/ubispl.c line 34

Quoted 5 lines

drivers/mtd/ubispl/ubispl.c new file +5 -0

+		(sizeof(struct ubi_fm_eba) + \
+		(ubi->peb_count * sizeof(__be32))) + \
+		sizeof(struct ubi_fm_volhdr) * UBI_MAX_VOLUMES;
+	return roundup(size, ubi->leb_size);
+}

The size calculation misses sizeof(struct ubi_fm_sb). I've found this issue while working on Linux fastmap support.

Utilizing NAND FLASH requires proper wear leveling and bitflip management. Linux choice for this is UBI. The upstream UBI implementation is far too big for a SPL, but it is desired to load arbitrary payload including u-boot itself from a UBI managed NAND FLASH. That restricts the non-UBI managed part of the NAND flash to the first few eraseblocks which are reserved for the SoC boot ROM to load the SPL.

The following patches provide a lightweight and fast UBI attach and load code, which supports fastmap and full scan mode.

The text foot print on the board which I used for development is:

6854 0 0 6854 1abd drivers/mtd/ubispl/built-in.o

Attaching a NAND chip with 4096 physical eraseblocks (4 blocks are reserved for the SPL) takes:

In full scan mode: 1172ms
In fastmap mode: 95ms

With that and a moderate sized kernel image, I'm able to hand off to the kernel within less than 500ms.

The scan and logical to physical block mapping code is developed from scratch, while the fastmap functions are lifted from the linux kernel source and adjusted to fit the SPL needs.

The implementation is paranoid and carefully preserves the UBI robustness.

For now I keep a private copy of ubi-media.h which should be shared with the drivers/mtd/ubi/ one once Heiko has synced it to the 3.14 source.

There is room for more boot time optimizations:

- Implement sub page reads for nand_spl_simple

- Hand the UBI data from SPL to kernel to avoid rescan of the fastmap/flash