File 0001-add-ext2-support.patch of Package x-loader-omap3beagle

From 363abcfd9e28f09cf40d8b46d77a7d92b529488e Mon Sep 17 00:00:00 2001
From: Alexander Graf <agraf@suse.de>
Date: Fri, 3 Feb 2012 01:01:09 +0100
Subject: [PATCH] Add support for fatless boot

This patch adds ext2 loading support for u-boot.bin and enables CH data
in front of the MLO binary so we can load off a raw location on SD. That
way we can get rid of all the FAT cruft in the OMAP3 bootstrap process.

Signed-off-by: Alexander Graf <agraf@suse.de>

diff --git a/Makefile b/Makefile
index 7f836e2..b7e713a 100644
--- a/Makefile
+++ b/Makefile
@@ -130,6 +130,7 @@ LIBS += board/$(BOARDDIR)/lib$(BOARD).a
 LIBS += cpu/$(CPU)/lib$(CPU).a
 LIBS += lib/lib$(ARCH).a
 LIBS += fs/fat/libfat.a
+LIBS += fs/ext2/libext2fs.a
 LIBS += disk/libdisk.a
 LIBS += drivers/libdrivers.a
 LIBS += common/libcommon.a
@@ -153,7 +154,7 @@ ALL = $(obj)x-load.bin.ift $(obj)System.map
 all ift:	$(ALL)
 
 $(obj)x-load.bin.ift: $(obj)signGP $(obj)System.map $(obj)x-load.bin
-	$(obj)./signGP $(obj)x-load.bin $(TEXT_BASE) $(CONFIG_HEADER)
+	$(obj)./signGP $(obj)x-load.bin $(TEXT_BASE) 1
 	cp $(obj)x-load.bin.ift $(obj)MLO
  
 $(obj)x-load.bin:	$(obj)x-load
diff --git a/cpu/omap3/mmc.c b/cpu/omap3/mmc.c
index e0c63b0..a16ee06 100644
--- a/cpu/omap3/mmc.c
+++ b/cpu/omap3/mmc.c
@@ -543,6 +543,7 @@ int mmc_init(int verbose)
 		mmc_blk_dev.block_read = mmc_bread;
 
 		fat_register_device(&mmc_blk_dev, 1);
+		ext2fs_set_blk_dev(&mmc_blk_dev, 1);
 		return 1;
 	}
 	else 
diff --git a/fs/Makefile b/fs/Makefile
index a2f61e7..3eb33df 100644
--- a/fs/Makefile
+++ b/fs/Makefile
@@ -22,7 +22,7 @@
 #
 #
 
-SUBDIRS	:= fat
+SUBDIRS	:= fat ext2
 
 $(obj).depend all:
 	@for dir in $(SUBDIRS) ; do \
diff --git a/fs/ext2/Makefile b/fs/ext2/Makefile
new file mode 100644
index 0000000..cdafd92
--- /dev/null
+++ b/fs/ext2/Makefile
@@ -0,0 +1,52 @@
+#
+# (C) Copyright 2006
+# Wolfgang Denk, DENX Software Engineering, wd@denx.de.
+#
+# (C) Copyright 2003
+# Pavel Bartusek, Sysgo Real-Time Solutions AG, pba@sysgo.de
+#
+#
+# See file CREDITS for list of people who contributed to this
+# project.
+#
+# 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., 59 Temple Place, Suite 330, Boston,
+# MA 02111-1307 USA
+#
+
+include $(TOPDIR)/config.mk
+
+LIB	= $(obj)libext2fs.a
+
+AOBJS	=
+COBJS-y := ext2fs.o dev.o
+
+SRCS	:= $(AOBJS:.o=.S) $(COBJS-y:.o=.c)
+OBJS	:= $(addprefix $(obj),$(AOBJS) $(COBJS-y))
+
+#CPPFLAGS +=
+
+all:	$(LIB) $(AOBJS)
+
+$(LIB):	$(obj).depend $(OBJS)
+	$(AR) crv $@ $(OBJS)
+
+#########################################################################
+
+# defines $(obj).depend target
+include $(SRCTREE)/rules.mk
+
+sinclude $(obj).depend
+
+#########################################################################
diff --git a/fs/ext2/dev.c b/fs/ext2/dev.c
new file mode 100644
index 0000000..a110c2e
--- /dev/null
+++ b/fs/ext2/dev.c
@@ -0,0 +1,159 @@
+/*
+ * (C) Copyright 2004
+ *  esd gmbh <www.esd-electronics.com>
+ *  Reinhard Arlt <reinhard.arlt@esd-electronics.com>
+ *
+ *  based on code of fs/reiserfs/dev.c by
+ *
+ *  (C) Copyright 2003 - 2004
+ *  Sysgo AG, <www.elinos.com>, Pavel Bartusek <pba@sysgo.com>
+ *
+ *  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 <common.h>
+#include <config.h>
+#include <ext2fs.h>
+
+#define min(a,b) (a < b ? a : b)
+#define debug(a,...)
+static block_dev_desc_t *ext2fs_block_dev_desc;
+static disk_partition_t part_info;
+
+int get_partition_info (block_dev_desc_t * dev_desc, int part, disk_partition_t *info);
+
+#define DOS_PART_TBL_OFFSET	0x1be
+int ext2fs_set_blk_dev(block_dev_desc_t *rbdd, int part)
+{
+	ext2fs_block_dev_desc = rbdd;
+	unsigned char buffer[SECTOR_SIZE];
+
+	if (rbdd->block_read(rbdd->dev, 0, 1, (ulong *) buffer) != 1) {
+		printf ("** Can't read from device %d **\n", rbdd->dev);
+		return -1;
+	}
+
+	ext2fs_block_dev_desc = rbdd;
+
+	if (part == 0) {
+		/* disk doesn't use partition table */
+		part_info.start = 0;
+		part_info.size = rbdd->lba;
+		part_info.blksz = rbdd->blksz;
+	} else {
+		part_info.start = buffer[DOS_PART_TBL_OFFSET+8]      |
+		                  buffer[DOS_PART_TBL_OFFSET+9] <<8  |
+		                  buffer[DOS_PART_TBL_OFFSET+10]<<16 |
+		                  buffer[DOS_PART_TBL_OFFSET+11]<<24;
+		part_info.size = 0x7fffffff;
+		part_info.blksz = 512;
+	}
+
+	if (!ext2fs_mount(-1))
+		return -1;
+
+	return 0;
+}
+
+
+int ext2fs_devread(int sector, int byte_offset, int byte_len, char *buf)
+{
+	char sec_buf[SECTOR_SIZE];
+	unsigned sectors;
+
+	/*
+	 *  Check partition boundaries
+	 */
+	if ((sector < 0) ||
+	    ((sector + ((byte_offset + byte_len - 1) >> SECTOR_BITS)) >=
+		part_info.size)) {
+		/* errnum = ERR_OUTSIDE_PART; */
+		printf(" ** %s read outside partition sector %x\n",
+		       __func__,
+		       sector);
+		return 0;
+	}
+
+	/*
+	 *  Get the read to the beginning of a partition.
+	 */
+	sector += byte_offset >> SECTOR_BITS;
+	byte_offset &= SECTOR_SIZE - 1;
+
+	debug(" <%d, %d, %d>\n", sector, byte_offset, byte_len);
+
+	if (ext2fs_block_dev_desc == NULL) {
+		printf(" ** %s Invalid Block Device Descriptor (NULL)\n",
+		       __func__);
+		return 0;
+	}
+
+	if (byte_offset != 0) {
+		/* read first part which isn't aligned with start of sector */
+		if (ext2fs_block_dev_desc->
+		    block_read(ext2fs_block_dev_desc->dev,
+			       part_info.start + sector, 1,
+			       (unsigned long *) sec_buf) != 1) {
+			printf(" ** %s read error **\n", __func__);
+			return 0;
+		}
+		memcpy(buf, sec_buf + byte_offset,
+		       min(SECTOR_SIZE - byte_offset, byte_len));
+		buf += min(SECTOR_SIZE - byte_offset, byte_len);
+		byte_len -= min(SECTOR_SIZE - byte_offset, byte_len);
+		sector++;
+	}
+
+	/*  read sector aligned part */
+	sectors = byte_len / SECTOR_SIZE;
+
+	if (sectors > 0) {
+		int r;
+		int i;
+
+		for (i = 0; i < sectors; i++) {
+		r = ext2fs_block_dev_desc->block_read(
+			ext2fs_block_dev_desc->dev,
+			part_info.start + sector,
+			sectors,
+			(unsigned long *) buf);
+		if (r != 1) {
+			printf(" ** %s read error - block %x-%x\n", __func__,
+				part_info.start + sector, part_info.start +
+				sector + sectors);
+			printf(" ** %s buf: %p\n", __func__, buf);
+			printf(" ** %s r: %d\n", __func__, r);
+			return 0;
+		}
+		buf += SECTOR_SIZE;
+		byte_len -= SECTOR_SIZE;
+		sector ++;
+		}
+	}
+
+	if (byte_len != 0) {
+		/* read rest of data which are not in whole sector */
+		if (ext2fs_block_dev_desc->
+		    block_read(ext2fs_block_dev_desc->dev,
+			       part_info.start + sector, 1,
+			       (unsigned long *) sec_buf) != 1) {
+			printf(" ** %s read error - last part\n", __func__);
+			return 0;
+		}
+		memcpy(buf, sec_buf, byte_len);
+	}
+	return 1;
+}
diff --git a/fs/ext2/ext2fs.c b/fs/ext2/ext2fs.c
new file mode 100644
index 0000000..23c5d79
--- /dev/null
+++ b/fs/ext2/ext2fs.c
@@ -0,0 +1,952 @@
+/*
+ * (C) Copyright 2004
+ *  esd gmbh <www.esd-electronics.com>
+ *  Reinhard Arlt <reinhard.arlt@esd-electronics.com>
+ *
+ *  based on code from grub2 fs/ext2.c and fs/fshelp.c by
+ *
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2003, 2004  Free Software Foundation, Inc.
+ *
+ *  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 <common.h>
+#include <ext2fs.h>
+#include <asm/byteorder.h>
+
+/* compat stuff */
+
+void *free_buf;
+void *topmost_entry;
+int topmost_size;
+
+static inline void memset(char *p, char c, int len)
+{
+	int i;
+	for (i = 0; i < len; i++)
+		p[i] = c;
+}
+
+char heap[10240];
+
+static inline void *malloc(int size)
+{
+	void *r;
+	if (!free_buf)
+		free_buf = heap;
+	memset(free_buf, 0, size);
+	r = free_buf;
+	free_buf += size;
+	topmost_entry = r;
+	topmost_size = size;
+	return r;
+}
+
+static inline void free(void *p)
+{
+	if (p == topmost_entry) {
+		free_buf -= topmost_size;
+		topmost_entry = 0;
+	} else {
+		printf("leaked %d bytes\n", topmost_size);
+	}
+}
+
+static inline void strncpy(char *a, const char *b, int x)
+{
+	strcpy(a, b);
+}
+
+static inline void *strchr(const char *p, char n)
+{
+	int i;
+	char *s = (char*)p;
+	while(*s) {
+		if (*s == n)
+			return s;
+		i++;
+		s++;
+	}
+	return NULL;
+}
+
+static inline int strlen(const char *s)
+{
+	return ((long)strchr(s, 0) - (long)s);
+}
+
+#define min(a,b) (a < b ? a : b)
+
+extern int ext2fs_devread (int sector, int byte_offset, int byte_len,
+			   char *buf);
+
+/* Magic value used to identify an ext2 filesystem.  */
+#define	EXT2_MAGIC		0xEF53
+/* Amount of indirect blocks in an inode.  */
+#define INDIRECT_BLOCKS		12
+/* Maximum lenght of a pathname.  */
+#define EXT2_PATH_MAX		4096
+/* Maximum nesting of symlinks, used to prevent a loop.  */
+#define	EXT2_MAX_SYMLINKCNT	8
+
+/* Filetype used in directory entry.  */
+#define	FILETYPE_UNKNOWN	0
+#define	FILETYPE_REG		1
+#define	FILETYPE_DIRECTORY	2
+#define	FILETYPE_SYMLINK	7
+
+/* Filetype information as used in inodes.  */
+#define FILETYPE_INO_MASK	0170000
+#define FILETYPE_INO_REG	0100000
+#define FILETYPE_INO_DIRECTORY	0040000
+#define FILETYPE_INO_SYMLINK	0120000
+
+/* Bits used as offset in sector */
+#define DISK_SECTOR_BITS        9
+
+/* Log2 size of ext2 block in 512 blocks.  */
+#define LOG2_EXT2_BLOCK_SIZE(data) (__le32_to_cpu (data->sblock.log2_block_size) + 1)
+
+/* Log2 size of ext2 block in bytes.  */
+#define LOG2_BLOCK_SIZE(data)	   (__le32_to_cpu (data->sblock.log2_block_size) + 10)
+
+/* The size of an ext2 block in bytes.  */
+#define EXT2_BLOCK_SIZE(data)	   (1 << LOG2_BLOCK_SIZE(data))
+
+/* The ext2 superblock.  */
+struct ext2_sblock {
+	uint32_t total_inodes;
+	uint32_t total_blocks;
+	uint32_t reserved_blocks;
+	uint32_t free_blocks;
+	uint32_t free_inodes;
+	uint32_t first_data_block;
+	uint32_t log2_block_size;
+	uint32_t log2_fragment_size;
+	uint32_t blocks_per_group;
+	uint32_t fragments_per_group;
+	uint32_t inodes_per_group;
+	uint32_t mtime;
+	uint32_t utime;
+	uint16_t mnt_count;
+	uint16_t max_mnt_count;
+	uint16_t magic;
+	uint16_t fs_state;
+	uint16_t error_handling;
+	uint16_t minor_revision_level;
+	uint32_t lastcheck;
+	uint32_t checkinterval;
+	uint32_t creator_os;
+	uint32_t revision_level;
+	uint16_t uid_reserved;
+	uint16_t gid_reserved;
+	uint32_t first_inode;
+	uint16_t inode_size;
+	uint16_t block_group_number;
+	uint32_t feature_compatibility;
+	uint32_t feature_incompat;
+	uint32_t feature_ro_compat;
+	uint32_t unique_id[4];
+	char volume_name[16];
+	char last_mounted_on[64];
+	uint32_t compression_info;
+};
+
+/* The ext2 blockgroup.  */
+struct ext2_block_group {
+	uint32_t block_id;
+	uint32_t inode_id;
+	uint32_t inode_table_id;
+	uint16_t free_blocks;
+	uint16_t free_inodes;
+	uint16_t used_dir_cnt;
+	uint32_t reserved[3];
+};
+
+/* The ext2 inode.  */
+struct ext2_inode {
+	uint16_t mode;
+	uint16_t uid;
+	uint32_t size;
+	uint32_t atime;
+	uint32_t ctime;
+	uint32_t mtime;
+	uint32_t dtime;
+	uint16_t gid;
+	uint16_t nlinks;
+	uint32_t blockcnt;	/* Blocks of 512 bytes!! */
+	uint32_t flags;
+	uint32_t osd1;
+	union {
+		struct datablocks {
+			uint32_t dir_blocks[INDIRECT_BLOCKS];
+			uint32_t indir_block;
+			uint32_t double_indir_block;
+			uint32_t tripple_indir_block;
+		} blocks;
+		char symlink[60];
+	} b;
+	uint32_t version;
+	uint32_t acl;
+	uint32_t dir_acl;
+	uint32_t fragment_addr;
+	uint32_t osd2[3];
+};
+
+/* The header of an ext2 directory entry.  */
+struct ext2_dirent {
+	uint32_t inode;
+	uint16_t direntlen;
+	uint8_t namelen;
+	uint8_t filetype;
+};
+
+struct ext2fs_node {
+	struct ext2_data *data;
+	struct ext2_inode inode;
+	int ino;
+	int inode_read;
+};
+
+/* Information about a "mounted" ext2 filesystem.  */
+struct ext2_data {
+	struct ext2_sblock sblock;
+	struct ext2_inode *inode;
+	struct ext2fs_node diropen;
+};
+
+
+typedef struct ext2fs_node *ext2fs_node_t;
+
+struct ext2_data *ext2fs_root = NULL;
+ext2fs_node_t ext2fs_file = NULL;
+int symlinknest = 0;
+uint32_t *indir1_block = NULL;
+int indir1_size = 0;
+int indir1_blkno = -1;
+uint32_t *indir2_block = NULL;
+int indir2_size = 0;
+int indir2_blkno = -1;
+static unsigned int inode_size;
+
+static int ext2fs_blockgroup
+	(struct ext2_data *data, int group, struct ext2_block_group *blkgrp) {
+	unsigned int blkno;
+	unsigned int blkoff;
+	unsigned int desc_per_blk;
+
+	desc_per_blk = EXT2_BLOCK_SIZE(data) / sizeof(struct ext2_block_group);
+
+	blkno = __le32_to_cpu(data->sblock.first_data_block) + 1 +
+	group / desc_per_blk;
+	blkoff = (group % desc_per_blk) * sizeof(struct ext2_block_group);
+#ifdef DEBUG
+	printf ("ext2fs read %d group descriptor (blkno %d blkoff %d)\n",
+		group, blkno, blkoff);
+#endif
+	return (ext2fs_devread (blkno << LOG2_EXT2_BLOCK_SIZE(data),
+		blkoff, sizeof(struct ext2_block_group), (char *)blkgrp));
+
+}
+
+
+static int ext2fs_read_inode
+	(struct ext2_data *data, int ino, struct ext2_inode *inode) {
+	struct ext2_block_group blkgrp;
+	struct ext2_sblock *sblock = &data->sblock;
+	int inodes_per_block;
+	int status;
+
+	unsigned int blkno;
+	unsigned int blkoff;
+
+#ifdef DEBUG
+	printf ("ext2fs read inode %d, inode_size %d\n", ino, inode_size);
+#endif
+	/* It is easier to calculate if the first inode is 0.  */
+	ino--;
+	status = ext2fs_blockgroup (data, ino / __le32_to_cpu
+				    (sblock->inodes_per_group), &blkgrp);
+	if (status == 0) {
+		return (0);
+	}
+
+	inodes_per_block = EXT2_BLOCK_SIZE(data) / inode_size;
+
+	blkno = __le32_to_cpu (blkgrp.inode_table_id) +
+		(ino % __le32_to_cpu (sblock->inodes_per_group))
+		/ inodes_per_block;
+	blkoff = (ino % inodes_per_block) * inode_size;
+#ifdef DEBUG
+	printf ("ext2fs read inode blkno %d blkoff %d\n", blkno, blkoff);
+#endif
+	/* Read the inode.  */
+	status = ext2fs_devread (blkno << LOG2_EXT2_BLOCK_SIZE (data), blkoff,
+				 sizeof (struct ext2_inode), (char *) inode);
+	if (status == 0) {
+		return (0);
+	}
+
+	return (1);
+}
+
+
+void ext2fs_free_node (ext2fs_node_t node, ext2fs_node_t currroot) {
+	if ((node != &ext2fs_root->diropen) && (node != currroot)) {
+		free (node);
+	}
+}
+
+
+static int ext2fs_read_block (ext2fs_node_t node, int fileblock) {
+	struct ext2_data *data = node->data;
+	struct ext2_inode *inode = &node->inode;
+	int blknr;
+	int blksz = EXT2_BLOCK_SIZE (data);
+	int log2_blksz = LOG2_EXT2_BLOCK_SIZE (data);
+	int status;
+
+	/* Direct blocks.  */
+	if (fileblock < INDIRECT_BLOCKS) {
+		blknr = __le32_to_cpu (inode->b.blocks.dir_blocks[fileblock]);
+	}
+	/* Indirect.  */
+	else if (fileblock < (INDIRECT_BLOCKS + (blksz / 4))) {
+		if (indir1_block == NULL) {
+			indir1_block = (uint32_t *) malloc (blksz);
+			if (indir1_block == NULL) {
+				printf ("** ext2fs read block (indir 1) malloc failed. **\n");
+				return (-1);
+			}
+			indir1_size = blksz;
+			indir1_blkno = -1;
+		}
+		if (blksz != indir1_size) {
+			free (indir1_block);
+			indir1_block = NULL;
+			indir1_size = 0;
+			indir1_blkno = -1;
+			indir1_block = (uint32_t *) malloc (blksz);
+			if (indir1_block == NULL) {
+				printf ("** ext2fs read block (indir 1) malloc failed. **\n");
+				return (-1);
+			}
+			indir1_size = blksz;
+		}
+		if ((__le32_to_cpu (inode->b.blocks.indir_block) <<
+		     log2_blksz) != indir1_blkno) {
+			status = ext2fs_devread (__le32_to_cpu(inode->b.blocks.indir_block) << log2_blksz,
+						 0, blksz,
+						 (char *) indir1_block);
+			if (status == 0) {
+				printf ("** ext2fs read block (indir 1) failed. **\n");
+				return (0);
+			}
+			indir1_blkno =
+				__le32_to_cpu (inode->b.blocks.
+					       indir_block) << log2_blksz;
+		}
+		blknr = __le32_to_cpu (indir1_block
+				       [fileblock - INDIRECT_BLOCKS]);
+	}
+	/* Double indirect.  */
+	else if (fileblock <
+		 (INDIRECT_BLOCKS + (blksz / 4 * (blksz / 4 + 1)))) {
+		unsigned int perblock = blksz / 4;
+		unsigned int rblock = fileblock - (INDIRECT_BLOCKS
+						   + blksz / 4);
+
+		if (indir1_block == NULL) {
+			indir1_block = (uint32_t *) malloc (blksz);
+			if (indir1_block == NULL) {
+				printf ("** ext2fs read block (indir 2 1) malloc failed. **\n");
+				return (-1);
+			}
+			indir1_size = blksz;
+			indir1_blkno = -1;
+		}
+		if (blksz != indir1_size) {
+			free (indir1_block);
+			indir1_block = NULL;
+			indir1_size = 0;
+			indir1_blkno = -1;
+			indir1_block = (uint32_t *) malloc (blksz);
+			if (indir1_block == NULL) {
+				printf ("** ext2fs read block (indir 2 1) malloc failed. **\n");
+				return (-1);
+			}
+			indir1_size = blksz;
+		}
+		if ((__le32_to_cpu (inode->b.blocks.double_indir_block) <<
+		     log2_blksz) != indir1_blkno) {
+			status = ext2fs_devread (__le32_to_cpu(inode->b.blocks.double_indir_block) << log2_blksz,
+						0, blksz,
+						(char *) indir1_block);
+			if (status == 0) {
+				printf ("** ext2fs read block (indir 2 1) failed. **\n");
+				return (-1);
+			}
+			indir1_blkno =
+				__le32_to_cpu (inode->b.blocks.double_indir_block) << log2_blksz;
+		}
+
+		if (indir2_block == NULL) {
+			indir2_block = (uint32_t *) malloc (blksz);
+			if (indir2_block == NULL) {
+				printf ("** ext2fs read block (indir 2 2) malloc failed. **\n");
+				return (-1);
+			}
+			indir2_size = blksz;
+			indir2_blkno = -1;
+		}
+		if (blksz != indir2_size) {
+			free (indir2_block);
+			indir2_block = NULL;
+			indir2_size = 0;
+			indir2_blkno = -1;
+			indir2_block = (uint32_t *) malloc (blksz);
+			if (indir2_block == NULL) {
+				printf ("** ext2fs read block (indir 2 2) malloc failed. **\n");
+				return (-1);
+			}
+			indir2_size = blksz;
+		}
+		if ((__le32_to_cpu (indir1_block[rblock / perblock]) <<
+		     log2_blksz) != indir2_blkno) {
+			status = ext2fs_devread (__le32_to_cpu(indir1_block[rblock / perblock]) << log2_blksz,
+						 0, blksz,
+						 (char *) indir2_block);
+			if (status == 0) {
+				printf ("** ext2fs read block (indir 2 2) failed. **\n");
+				return (-1);
+			}
+			indir2_blkno =
+				__le32_to_cpu (indir1_block[rblock / perblock]) << log2_blksz;
+		}
+		blknr = __le32_to_cpu (indir2_block[rblock % perblock]);
+	}
+	/* Tripple indirect.  */
+	else {
+		printf ("** ext2fs doesn't support tripple indirect blocks. **\n");
+		return (-1);
+	}
+#ifdef DEBUG
+	printf ("ext2fs_read_block %08x\n", blknr);
+#endif
+	return (blknr);
+}
+
+
+int ext2fs_read_file
+	(ext2fs_node_t node, int pos, unsigned int len, char *buf) {
+	int i;
+	int blockcnt;
+	int log2blocksize = LOG2_EXT2_BLOCK_SIZE (node->data);
+	int blocksize = 1 << (log2blocksize + DISK_SECTOR_BITS);
+	unsigned int filesize = __le32_to_cpu(node->inode.size);
+
+	/* Adjust len so it we can't read past the end of the file.  */
+	if (len > filesize) {
+		len = filesize;
+	}
+	blockcnt = ((len + pos) + blocksize - 1) / blocksize;
+
+	for (i = pos / blocksize; i < blockcnt; i++) {
+		int blknr;
+		int blockoff = pos % blocksize;
+		int blockend = blocksize;
+
+		int skipfirst = 0;
+
+		blknr = ext2fs_read_block (node, i);
+		if (blknr < 0) {
+			return (-1);
+		}
+		blknr = blknr << log2blocksize;
+
+		/* Last block.  */
+		if (i == blockcnt - 1) {
+			blockend = (len + pos) % blocksize;
+
+			/* The last portion is exactly blocksize.  */
+			if (!blockend) {
+				blockend = blocksize;
+			}
+		}
+
+		/* First block.  */
+		if (i == pos / blocksize) {
+			skipfirst = blockoff;
+			blockend -= skipfirst;
+		}
+
+		/* If the block number is 0 this block is not stored on disk but
+		   is zero filled instead.  */
+		if (blknr) {
+			int status;
+
+			status = ext2fs_devread (blknr, skipfirst, blockend, buf);
+			if (status == 0) {
+				return (-1);
+			}
+		} else {
+			memset (buf, 0, blocksize - skipfirst);
+		}
+		buf += blocksize - skipfirst;
+	}
+	return (len);
+}
+
+
+static int ext2fs_iterate_dir (ext2fs_node_t dir, char *name, ext2fs_node_t * fnode, int *ftype)
+{
+	unsigned int fpos = 0;
+	int status;
+	struct ext2fs_node *diro = (struct ext2fs_node *) dir;
+
+#ifdef DEBUG
+	if (name != NULL)
+		printf ("Iterate dir %s\n", name);
+#endif /* of DEBUG */
+	if (!diro->inode_read) {
+		status = ext2fs_read_inode (diro->data, diro->ino,
+					    &diro->inode);
+		if (status == 0) {
+			return (0);
+		}
+	}
+	/* Search the file.  */
+	while (fpos < __le32_to_cpu (diro->inode.size)) {
+		struct ext2_dirent dirent;
+
+		status = ext2fs_read_file (diro, fpos,
+					   sizeof (struct ext2_dirent),
+					   (char *) &dirent);
+		if (status < 1) {
+			return (0);
+		}
+		if (dirent.namelen != 0) {
+			char filename[dirent.namelen + 1];
+			ext2fs_node_t fdiro;
+			int type = FILETYPE_UNKNOWN;
+
+			status = ext2fs_read_file (diro,
+						   fpos + sizeof (struct ext2_dirent),
+						   dirent.namelen, filename);
+			if (status < 1) {
+				return (0);
+			}
+			fdiro = malloc (sizeof (struct ext2fs_node));
+			if (!fdiro) {
+				return (0);
+			}
+
+			fdiro->data = diro->data;
+			fdiro->ino = __le32_to_cpu (dirent.inode);
+
+			filename[dirent.namelen] = '\0';
+
+			if (dirent.filetype != FILETYPE_UNKNOWN) {
+				fdiro->inode_read = 0;
+
+				if (dirent.filetype == FILETYPE_DIRECTORY) {
+					type = FILETYPE_DIRECTORY;
+				} else if (dirent.filetype ==
+					   FILETYPE_SYMLINK) {
+					type = FILETYPE_SYMLINK;
+				} else if (dirent.filetype == FILETYPE_REG) {
+					type = FILETYPE_REG;
+				}
+			} else {
+				/* The filetype can not be read from the dirent, get it from inode */
+
+				status = ext2fs_read_inode (diro->data,
+							    __le32_to_cpu(dirent.inode),
+							    &fdiro->inode);
+				if (status == 0) {
+					free (fdiro);
+					return (0);
+				}
+				fdiro->inode_read = 1;
+
+				if ((__le16_to_cpu (fdiro->inode.mode) &
+				     FILETYPE_INO_MASK) ==
+				    FILETYPE_INO_DIRECTORY) {
+					type = FILETYPE_DIRECTORY;
+				} else if ((__le16_to_cpu (fdiro->inode.mode)
+					    & FILETYPE_INO_MASK) ==
+					   FILETYPE_INO_SYMLINK) {
+					type = FILETYPE_SYMLINK;
+				} else if ((__le16_to_cpu (fdiro->inode.mode)
+					    & FILETYPE_INO_MASK) ==
+					   FILETYPE_INO_REG) {
+					type = FILETYPE_REG;
+				}
+			}
+#ifdef DEBUG
+			printf ("iterate >%s<\n", filename);
+#endif /* of DEBUG */
+			if ((name != NULL) && (fnode != NULL)
+			    && (ftype != NULL)) {
+				if (strcmp (filename, name) == 0) {
+					*ftype = type;
+					*fnode = fdiro;
+					return (1);
+				}
+			} else {
+				if (fdiro->inode_read == 0) {
+					status = ext2fs_read_inode (diro->data,
+							    __le32_to_cpu (dirent.inode),
+							    &fdiro->inode);
+					if (status == 0) {
+						free (fdiro);
+						return (0);
+					}
+					fdiro->inode_read = 1;
+				}
+				switch (type) {
+				case FILETYPE_DIRECTORY:
+					printf ("<DIR> ");
+					break;
+				case FILETYPE_SYMLINK:
+					printf ("<SYM> ");
+					break;
+				case FILETYPE_REG:
+					printf ("      ");
+					break;
+				default:
+					printf ("< ? > ");
+					break;
+				}
+				printf ("%10d %s\n",
+					__le32_to_cpu (fdiro->inode.size),
+					filename);
+			}
+			free (fdiro);
+		}
+		fpos += __le16_to_cpu (dirent.direntlen);
+	}
+	return (0);
+}
+
+
+static char *ext2fs_read_symlink (ext2fs_node_t node) {
+	char *symlink;
+	struct ext2fs_node *diro = node;
+	int status;
+
+	if (!diro->inode_read) {
+		status = ext2fs_read_inode (diro->data, diro->ino,
+					    &diro->inode);
+		if (status == 0) {
+			return (0);
+		}
+	}
+	symlink = malloc (__le32_to_cpu (diro->inode.size) + 1);
+	if (!symlink) {
+		return (0);
+	}
+	/* If the filesize of the symlink is bigger than
+	   60 the symlink is stored in a separate block,
+	   otherwise it is stored in the inode.  */
+	if (__le32_to_cpu (diro->inode.size) <= 60) {
+		strncpy (symlink, diro->inode.b.symlink,
+			 __le32_to_cpu (diro->inode.size));
+	} else {
+		status = ext2fs_read_file (diro, 0,
+					   __le32_to_cpu (diro->inode.size),
+					   symlink);
+		if (status == 0) {
+			free (symlink);
+			return (0);
+		}
+	}
+	symlink[__le32_to_cpu (diro->inode.size)] = '\0';
+	return (symlink);
+}
+
+
+int ext2fs_find_file1
+	(const char *currpath,
+	 ext2fs_node_t currroot, ext2fs_node_t * currfound, int *foundtype) {
+	char fpath[strlen (currpath) + 1];
+	char *name = fpath;
+	char *next;
+	int status;
+	int type = FILETYPE_DIRECTORY;
+	ext2fs_node_t currnode = currroot;
+	ext2fs_node_t oldnode = currroot;
+
+	strncpy (fpath, currpath, strlen (currpath) + 1);
+
+	/* Remove all leading slashes.  */
+	while (*name == '/') {
+		name++;
+	}
+	if (!*name) {
+		*currfound = currnode;
+		return (1);
+	}
+
+	for (;;) {
+		int found;
+
+		/* Extract the actual part from the pathname.  */
+		next = strchr (name, '/');
+		if (next) {
+			/* Remove all leading slashes.  */
+			while (*next == '/') {
+				*(next++) = '\0';
+			}
+		}
+
+		/* At this point it is expected that the current node is a directory, check if this is true.  */
+		if (type != FILETYPE_DIRECTORY) {
+			ext2fs_free_node (currnode, currroot);
+			return (0);
+		}
+
+		oldnode = currnode;
+
+		/* Iterate over the directory.  */
+		found = ext2fs_iterate_dir (currnode, name, &currnode, &type);
+		if (found == 0) {
+			return (0);
+		}
+		if (found == -1) {
+			break;
+		}
+
+		/* Read in the symlink and follow it.  */
+		if (type == FILETYPE_SYMLINK) {
+			char *symlink;
+
+			/* Test if the symlink does not loop.  */
+			if (++symlinknest == 8) {
+				ext2fs_free_node (currnode, currroot);
+				ext2fs_free_node (oldnode, currroot);
+				return (0);
+			}
+
+			symlink = ext2fs_read_symlink (currnode);
+			ext2fs_free_node (currnode, currroot);
+
+			if (!symlink) {
+				ext2fs_free_node (oldnode, currroot);
+				return (0);
+			}
+#ifdef DEBUG
+			printf ("Got symlink >%s<\n", symlink);
+#endif /* of DEBUG */
+			/* The symlink is an absolute path, go back to the root inode.  */
+			if (symlink[0] == '/') {
+				ext2fs_free_node (oldnode, currroot);
+				oldnode = &ext2fs_root->diropen;
+			}
+
+			/* Lookup the node the symlink points to.  */
+			status = ext2fs_find_file1 (symlink, oldnode,
+						    &currnode, &type);
+
+			free (symlink);
+
+			if (status == 0) {
+				ext2fs_free_node (oldnode, currroot);
+				return (0);
+			}
+		}
+
+		ext2fs_free_node (oldnode, currroot);
+
+		/* Found the node!  */
+		if (!next || *next == '\0') {
+			*currfound = currnode;
+			*foundtype = type;
+			return (1);
+		}
+		name = next;
+	}
+	return (-1);
+}
+
+
+int ext2fs_find_file
+	(const char *path,
+	 ext2fs_node_t rootnode, ext2fs_node_t * foundnode, int expecttype) {
+	int status;
+	int foundtype = FILETYPE_DIRECTORY;
+
+
+	symlinknest = 0;
+	if (!path) {
+		return (0);
+	}
+
+	status = ext2fs_find_file1 (path, rootnode, foundnode, &foundtype);
+	if (status == 0) {
+		return (0);
+	}
+	/* Check if the node that was found was of the expected type.  */
+	if ((expecttype == FILETYPE_REG) && (foundtype != expecttype)) {
+		return (0);
+	} else if ((expecttype == FILETYPE_DIRECTORY)
+		   && (foundtype != expecttype)) {
+		return (0);
+	}
+	return (1);
+}
+
+
+int ext2fs_ls (const char *dirname) {
+	ext2fs_node_t dirnode;
+	int status;
+
+	if (ext2fs_root == NULL) {
+		return (0);
+	}
+
+	status = ext2fs_find_file (dirname, &ext2fs_root->diropen, &dirnode,
+				   FILETYPE_DIRECTORY);
+	if (status != 1) {
+		printf ("** Can not find directory. **\n");
+		return (1);
+	}
+	ext2fs_iterate_dir (dirnode, NULL, NULL, NULL);
+	ext2fs_free_node (dirnode, &ext2fs_root->diropen);
+	return (0);
+}
+
+
+int ext2fs_open (const char *filename) {
+	ext2fs_node_t fdiro = NULL;
+	int status;
+	int len;
+
+	if (ext2fs_root == NULL) {
+		return (-1);
+	}
+	ext2fs_file = NULL;
+	status = ext2fs_find_file (filename, &ext2fs_root->diropen, &fdiro,
+				   FILETYPE_REG);
+	if (status == 0) {
+		goto fail;
+	}
+	if (!fdiro->inode_read) {
+		status = ext2fs_read_inode (fdiro->data, fdiro->ino,
+					    &fdiro->inode);
+		if (status == 0) {
+			goto fail;
+		}
+	}
+	len = __le32_to_cpu (fdiro->inode.size);
+	ext2fs_file = fdiro;
+	return (len);
+
+fail:
+	ext2fs_free_node (fdiro, &ext2fs_root->diropen);
+	return (-1);
+}
+
+
+int ext2fs_close (void
+	) {
+	if ((ext2fs_file != NULL) && (ext2fs_root != NULL)) {
+		ext2fs_free_node (ext2fs_file, &ext2fs_root->diropen);
+		ext2fs_file = NULL;
+	}
+	if (ext2fs_root != NULL) {
+		free (ext2fs_root);
+		ext2fs_root = NULL;
+	}
+	if (indir1_block != NULL) {
+		free (indir1_block);
+		indir1_block = NULL;
+		indir1_size = 0;
+		indir1_blkno = -1;
+	}
+	if (indir2_block != NULL) {
+		free (indir2_block);
+		indir2_block = NULL;
+		indir2_size = 0;
+		indir2_blkno = -1;
+	}
+	return (0);
+}
+
+
+int ext2fs_read (char *buf, unsigned len) {
+	int status;
+
+	if (ext2fs_root == NULL) {
+		return (0);
+	}
+
+	if (ext2fs_file == NULL) {
+		return (0);
+	}
+
+	status = ext2fs_read_file (ext2fs_file, 0, len, buf);
+	return (status);
+}
+
+
+int ext2fs_mount (unsigned part_length) {
+	struct ext2_data *data;
+	int status;
+
+	data = malloc (sizeof (struct ext2_data));
+	if (!data) {
+		return (0);
+	}
+	/* Read the superblock.  */
+	status = ext2fs_devread (1 * 2, 0, sizeof (struct ext2_sblock),
+				 (char *) &data->sblock);
+	if (status == 0) {
+		goto fail;
+	}
+	/* Make sure this is an ext2 filesystem.  */
+	if (__le16_to_cpu (data->sblock.magic) != EXT2_MAGIC) {
+		goto fail;
+	}
+	if (__le32_to_cpu(data->sblock.revision_level == 0)) {
+		inode_size = 128;
+	} else {
+		inode_size = __le16_to_cpu(data->sblock.inode_size);
+	}
+#ifdef DEBUG
+	printf("EXT2 rev %d, inode_size %d\n",
+			__le32_to_cpu(data->sblock.revision_level), inode_size);
+#endif
+	data->diropen.data = data;
+	data->diropen.ino = 2;
+	data->diropen.inode_read = 1;
+	data->inode = &data->diropen.inode;
+
+	status = ext2fs_read_inode (data, 2, data->inode);
+	if (status == 0) {
+		goto fail;
+	}
+
+	ext2fs_root = data;
+
+	return (1);
+
+fail:
+	printf ("Failed to mount ext2 filesystem...\n");
+	free (data);
+	ext2fs_root = NULL;
+	return (0);
+}
diff --git a/include/ext2fs.h b/include/ext2fs.h
new file mode 100644
index 0000000..294bb18
--- /dev/null
+++ b/include/ext2fs.h
@@ -0,0 +1,82 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2000, 2001  Free Software Foundation, Inc.
+ *
+ *  (C) Copyright 2003 Sysgo Real-Time Solutions, AG <www.elinos.com>
+ *  Pavel Bartusek <pba@sysgo.de>
+ *
+ *  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 implementation for the Ext2FS filesystem ported from GRUB.
+ * Some parts of this code (mainly the structures and defines) are
+ * from the original ext2 fs code, as found in the linux kernel.
+ */
+
+#include <part.h>
+
+#define SECTOR_SIZE		0x200
+#define SECTOR_BITS		9
+
+/* Error codes */
+typedef enum
+{
+  ERR_NONE = 0,
+  ERR_BAD_FILENAME,
+  ERR_BAD_FILETYPE,
+  ERR_BAD_GZIP_DATA,
+  ERR_BAD_GZIP_HEADER,
+  ERR_BAD_PART_TABLE,
+  ERR_BAD_VERSION,
+  ERR_BELOW_1MB,
+  ERR_BOOT_COMMAND,
+  ERR_BOOT_FAILURE,
+  ERR_BOOT_FEATURES,
+  ERR_DEV_FORMAT,
+  ERR_DEV_VALUES,
+  ERR_EXEC_FORMAT,
+  ERR_FILELENGTH,
+  ERR_FILE_NOT_FOUND,
+  ERR_FSYS_CORRUPT,
+  ERR_FSYS_MOUNT,
+  ERR_GEOM,
+  ERR_NEED_LX_KERNEL,
+  ERR_NEED_MB_KERNEL,
+  ERR_NO_DISK,
+  ERR_NO_PART,
+  ERR_NUMBER_PARSING,
+  ERR_OUTSIDE_PART,
+  ERR_READ,
+  ERR_SYMLINK_LOOP,
+  ERR_UNRECOGNIZED,
+  ERR_WONT_FIT,
+  ERR_WRITE,
+  ERR_BAD_ARGUMENT,
+  ERR_UNALIGNED,
+  ERR_PRIVILEGED,
+  ERR_DEV_NEED_INIT,
+  ERR_NO_DISK_SPACE,
+  ERR_NUMBER_OVERFLOW,
+
+  MAX_ERR_NUM
+} ext2fs_error_t;
+
+
+extern int ext2fs_set_blk_dev(block_dev_desc_t *rbdd, int part);
+extern int ext2fs_ls (const char *dirname);
+extern int ext2fs_open (const char *filename);
+extern int ext2fs_read (char *buf, unsigned len);
+extern int ext2fs_mount (unsigned part_length);
+extern int ext2fs_close(void);
diff --git a/lib/board.c b/lib/board.c
index 1947e5a..4b901cc 100644
--- a/lib/board.c
+++ b/lib/board.c
@@ -99,6 +99,12 @@ void start_armboot (void)
 	/* first try mmc */
 	if (mmc_init(1)) {
 		size = file_fat_read("u-boot.bin", buf, 0);
+		if (size <= 0) {
+			printf("fat load failed, trying ext2\n");
+			/* try ext2 */
+			ext2fs_open("u-boot.bin");
+			size = ext2fs_read(buf, 0x7fffffff);
+		}
 		if (size > 0) {
 #ifdef CFG_PRINTF
 			printf("Loading u-boot.bin from mmc\n");
openSUSE Build Service is sponsored by