[PATCH 5/5] add-ext2-fs.patch
Andy Green
andy at openmoko.com
Fri Aug 22 01:17:48 CEST 2008
This adds ext2 support from U-Boot and stitches it into the
partition stuff. It also upgrades the board definitions so they
can define the path to look for in the ext2 filesystem being
mounted. I used /boot/uImage.bin because this is already in use
by the packaged kernel.
We now mount, open and pull the kernel from ext2 in phase2.c if
the kernel source defines it.
Signed-off-by: Andy Green <andy at openmoko.com>
---
Makefile | 3
include/ext2.h | 80 ++++
include/image.h | 6
include/qi.h | 11 -
src/drivers/glamo-mmc.c | 25 +
src/fs/dev.c | 115 ++++++
src/fs/ext2.c | 867 +++++++++++++++++++++++++++++++++++++++++++++++
src/gta02/gta02.c | 5
src/gta03/gta03.c | 2
src/phase2.c | 146 ++++++--
src/start_qi.c | 1
src/utils.c | 81 ++++
12 files changed, 1269 insertions(+), 73 deletions(-)
create mode 100644 include/ext2.h
create mode 100644 src/fs/dev.c
create mode 100644 src/fs/ext2.c
diff --git a/Makefile b/Makefile
index 5276ea3..cdb075e 100644
--- a/Makefile
+++ b/Makefile
@@ -34,7 +34,8 @@ LDFLAGS =
#START = start.o lowlevel_init.o
S_SRCS = src/start.S src/lowlevel_init.S
S_OBJS = $(patsubst %.S,%.o, $(S_SRCS))
-C_SRCS = $(wildcard src/*.c) $(wildcard src/gt*/*.c) $(wildcard src/drivers/*.c)
+C_SRCS = $(wildcard src/*.c) $(wildcard src/gt*/*.c) \
+ $(wildcard src/drivers/*.c) $(wildcard src/fs/*.c)
C_OBJS = $(patsubst %.c,%.o, $(C_SRCS))
#SRCS := $(START: .o=.S) $(COBJS: .o=.c)
diff --git a/include/ext2.h b/include/ext2.h
new file mode 100644
index 0000000..85b0860
--- /dev/null
+++ b/include/ext2.h
@@ -0,0 +1,80 @@
+/*
+ * 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 at 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.
+ */
+
+
+#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_ls(char *dirname);
+extern int ext2fs_open(const char *filename);
+extern int ext2fs_read(char *buf, unsigned len);
+extern int ext2fs_mount(void);
+extern int ext2fs_close(void);
diff --git a/include/image.h b/include/image.h
index 2e3c6ef..af9ecda 100644
--- a/include/image.h
+++ b/include/image.h
@@ -33,8 +33,6 @@
#ifndef __IMAGE_H__
#define __IMAGE_H__
-#include <arpa/inet.h>
-
/*
* Operating System Codes
*/
@@ -204,8 +202,8 @@ typedef struct bootm_headers {
*/
#define CHUNKSZ (64 * 1024)
-#define uimage_to_cpu(x) ntohl(x)
-#define cpu_to_uimage(x) htonl(x)
+#define uimage_to_cpu(x) __be32_to_cpu(x)
+#define cpu_to_uimage(x) __cpu_to_be32(x)
const char *genimg_get_os_name (uint8_t os);
const char *genimg_get_arch_name (uint8_t arch);
diff --git a/include/qi.h b/include/qi.h
index 01cf2fa..3429e9b 100644
--- a/include/qi.h
+++ b/include/qi.h
@@ -23,11 +23,15 @@
#include <stdarg.h>
#include <qi-ctype.h>
+#include <asm/byteorder.h>
+
#define u32 unsigned int
#define u16 unsigned short
#define u8 unsigned char
typedef unsigned int uint32_t;
+typedef unsigned short uint16_t;
+typedef unsigned char uint8_t;
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
@@ -41,11 +45,12 @@ enum filesystem {
struct kernel_source {
const char *name; /* NULL name means invalid */
+ const char *filepath;
int (*block_init)(void);
int (*block_read)(unsigned char * buf, unsigned long start512,
int blocks512);
int partition_index; /* -1 means no partition table */
- int offset_if_no_partition; /* used if partition_index is -1 */
+ int offset_blocks512_if_no_partition; /* used if partition_index is -1 */
enum filesystem filesystem;
const char * commandline;
};
@@ -75,6 +80,7 @@ struct board_api {
/* this is the board we are running on */
extern struct board_api const * this_board;
+extern struct kernel_source const * this_kernel;
int printk(const char *fmt, ...);
int vsprintf(char *buf, const char *fmt, va_list args);
@@ -84,8 +90,7 @@ void print8(unsigned char u);
void print32(unsigned int u);
void printdec(int n);
void hexdump(unsigned char *start, int len);
-unsigned int _ntohl(unsigned int n);
-unsigned int _letocpu(unsigned int n);
+
unsigned long crc32(unsigned long crc, const unsigned char *buf,
unsigned int len);
int nand_read_ll(unsigned char *buf, unsigned long start512, int blocks512);
diff --git a/src/drivers/glamo-mmc.c b/src/drivers/glamo-mmc.c
index 4f383dd..051c810 100644
--- a/src/drivers/glamo-mmc.c
+++ b/src/drivers/glamo-mmc.c
@@ -316,6 +316,7 @@ static int mmc_cmd(int opcode, int arg, int flags,
return 0;
if (error) {
+#if 0
puts("cmd 0x");
print8(opcode);
puts(", arg 0x");
@@ -323,7 +324,6 @@ static int mmc_cmd(int opcode, int arg, int flags,
puts(", flags 0x");
print32(flags);
puts("\n");
-#if 1
puts("Error after cmd: 0x");
print32(error);
puts("\n");
@@ -366,7 +366,7 @@ static int mmc_cmd(int opcode, int arg, int flags,
error = -5;
if (error) {
// printf("cmd 0x%x, arg 0x%x flags 0x%x\n", opcode, arg, flags);
-#if 1
+#if 0
puts("Error after resp: 0x");
print32(status);
puts("\n");
@@ -530,43 +530,42 @@ static void print_sd_cid(const struct sd_cid *cid)
puts(" Card Type: ");
switch (card_type) {
case CARDTYPE_NONE:
- puts("(None)\n");
+ puts("(None) / ");
break;
case CARDTYPE_MMC:
- puts("MMC\n");
+ puts("MMC / ");
break;
case CARDTYPE_SD:
- puts("SD\n");
+ puts("SD / ");
break;
case CARDTYPE_SD20:
- puts("SD 2.0\n");
+ puts("SD 2.0 / ");
break;
case CARDTYPE_SDHC:
- puts("SD 2.0 SDHC\n");
+ puts("SD 2.0 SDHC / ");
break;
}
- puts(" Manufacturer: 0x");
+ puts("Mfr: 0x");
print8(cid->mid);
puts(", OEM \"");
this_board->putc(cid->oid_0);
this_board->putc(cid->oid_1);
- puts("\"\n");
+ puts("\" / ");
- puts(" Product name: \"");
this_board->putc(cid->pnm_0);
this_board->putc(cid->pnm_1);
this_board->putc(cid->pnm_2);
this_board->putc(cid->pnm_3);
this_board->putc(cid->pnm_4);
- puts("\", revision ");
+ puts("\", rev ");
printdec(cid->prv >> 4);
puts(".");
printdec(cid->prv & 15);
- puts("\nSerial number: ");
+ puts(" / s/n: ");
printdec(cid->psn_0 << 24 | cid->psn_1 << 16 | cid->psn_2 << 8 |
cid->psn_3);
- puts("\n Manf. date: ");
+ puts(" / date: ");
printdec(cid->mdt_1 & 15);
puts("/");
printdec(2000 + ((cid->mdt_0 & 15) << 4)+((cid->mdt_1 & 0xf0) >> 4));
diff --git a/src/fs/dev.c b/src/fs/dev.c
new file mode 100644
index 0000000..ebe8d6e
--- /dev/null
+++ b/src/fs/dev.c
@@ -0,0 +1,115 @@
+/*
+ * (C) Copyright 2004
+ * esd gmbh <www.esd-electronics.com>
+ * Reinhard Arlt <reinhard.arlt at esd-electronics.com>
+ *
+ * based on code of fs/reiserfs/dev.c by
+ *
+ * (C) Copyright 2003 - 2004
+ * Sysgo AG, <www.elinos.com>, Pavel Bartusek <pba at 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 <qi.h>
+#include <ext2.h>
+#include <string.h>
+
+extern unsigned long partition_offset_blocks;
+extern unsigned long partition_length_blocks;
+
+
+int ext2fs_devread(int sector, int byte_offset, int byte_len, u8 *buf)
+{
+ unsigned char sec_buf[SECTOR_SIZE];
+ unsigned block_len;
+
+/*
+ * Check partition boundaries
+ */
+ if ((sector < 0)
+ || ((sector + ((byte_offset + byte_len - 1) >> SECTOR_BITS)) >=
+ partition_length_blocks)) {
+ /* errnum = ERR_OUTSIDE_PART; */
+ puts(" ** ext2fs_devread() read outside partition sector ");
+ printdec(sector);
+ puts("\n");
+ return 0;
+ }
+
+/*
+ * Get the read to the beginning of a partition.
+ */
+ sector += byte_offset >> SECTOR_BITS;
+ byte_offset &= SECTOR_SIZE - 1;
+
+ if (byte_offset) {
+ int minimum = SECTOR_SIZE - byte_offset;
+
+ if (byte_len < minimum)
+ minimum = byte_len;
+
+ /* read first part which isn't aligned with start of sector */
+ if ((this_kernel->block_read)(sec_buf,
+ partition_offset_blocks + sector, 1) < 0) {
+ puts(" ** ext2fs_devread() read error **\n");
+ return 0;
+ }
+ memcpy(buf, sec_buf + byte_offset,
+ minimum);
+ buf += minimum;
+ byte_len -= minimum;
+ sector++;
+ }
+
+ if (!byte_len)
+ return 1;
+
+ /* read sector aligned part */
+ block_len = byte_len & ~(SECTOR_SIZE - 1);
+
+ if (block_len == 0) {
+ u8 p[SECTOR_SIZE];
+
+ block_len = SECTOR_SIZE;
+ this_kernel->block_read(p,
+ partition_offset_blocks + sector, 1);
+ memcpy(buf, p, byte_len);
+ return 1;
+ }
+
+ if (this_kernel->block_read(buf, partition_offset_blocks + sector,
+ block_len / SECTOR_SIZE) < 0) {
+ puts(" ** ext2fs_devread() read error - block\n");
+ return 0;
+ }
+ block_len = byte_len & ~(SECTOR_SIZE - 1);
+ buf += block_len;
+ byte_len -= block_len;
+ sector += block_len / SECTOR_SIZE;
+
+ if (byte_len) {
+ /* read rest of data which are not in whole sector */
+ if (this_kernel->block_read(sec_buf,
+ partition_offset_blocks + sector, 1) != 1) {
+ puts(" ** ext2fs_devread() read error - last part\n");
+ return 0;
+ }
+ memcpy (buf, sec_buf, byte_len);
+ }
+ return 1;
+}
+
diff --git a/src/fs/ext2.c b/src/fs/ext2.c
new file mode 100644
index 0000000..25616e5
--- /dev/null
+++ b/src/fs/ext2.c
@@ -0,0 +1,867 @@
+/*
+ *(C) Copyright 2004
+ * esd gmbh <www.esd-electronics.com>
+ * Reinhard Arlt <reinhard.arlt at 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 <qi.h>
+
+#include <ext2.h>
+#include <malloc.h>
+#include <string.h>
+
+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 pad;
+ 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 int ext2fs_blockgroup
+ (struct ext2_data *data, int group, struct ext2_block_group *blkgrp) {
+#ifdef DEBUG
+ puts("ext2fs read blockgroup\n");
+#endif
+ return ext2fs_devread
+ (((__le32_to_cpu(data->sblock.first_data_block) +
+ 1) << LOG2_EXT2_BLOCK_SIZE(data)),
+ group * sizeof(struct ext2_block_group),
+ 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;
+
+ /* It is easier to calculate if the first inode is 0. */
+ ino--;
+#ifdef DEBUG
+ puts("ext2fs read inode %d\n", ino);
+#endif
+ 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) / 128;
+ blkno =(ino % __le32_to_cpu(sblock->inodes_per_group)) /
+ inodes_per_block;
+ blkoff =(ino % __le32_to_cpu(sblock->inodes_per_group)) %
+ inodes_per_block;
+#ifdef DEBUG
+ puts("ext2fs read inode blkno %d blkoff %d\n", blkno, blkoff);
+#endif
+ /* Read the inode. */
+ status = ext2fs_devread(((__le32_to_cpu(blkgrp.inode_table_id) +
+ blkno) << LOG2_EXT2_BLOCK_SIZE(data)),
+ sizeof(struct ext2_inode) * blkoff,
+ sizeof(struct ext2_inode),(char *) inode);
+
+ return !!status;
+}
+
+
+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) {
+ puts("** 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) {
+ puts("** 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) {
+ puts("** 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) {
+ puts("** 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) {
+ puts("** 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) {
+ puts("** 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) {
+ puts("** 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) {
+ puts("** ext2fs read block(indir 2 2) malloc failed. **\n");
+ return -1;
+ }
+ indir2_size = blksz;
+ }
+ if ((__le32_to_cpu(indir1_block[rblock / perblock]) <<
+ log2_blksz) != indir1_blkno) {
+ status = ext2fs_devread(__le32_to_cpu(indir1_block[rblock / perblock]) << log2_blksz,
+ 0, blksz,
+ (char *) indir2_block);
+ if (status == 0) {
+ puts("** 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 {
+ puts("** 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[256];
+ 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:
+ puts("<DIR> ");
+ break;
+ case FILETYPE_SYMLINK:
+ puts("<SYM> ");
+ break;
+ case FILETYPE_REG:
+ puts(" ");
+ break;
+ default:
+ puts("< ? > ");
+ break;
+ }
+ printdec(__le32_to_cpu(fdiro->inode.size));
+ puts(" ");
+ puts(filename);
+ puts("\n");
+ }
+ 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(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) {
+ puts("** 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(void) {
+ 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)
+ goto fail;
+
+ /* Make sure this is an ext2 filesystem. */
+ if (__le16_to_cpu(data->sblock.magic) != EXT2_MAGIC)
+ goto fail;
+
+ 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:
+ puts("Failed to mount ext2 filesystem...\n");
+ free(data);
+ ext2fs_root = NULL;
+
+ return 0;
+}
+
diff --git a/src/gta02/gta02.c b/src/gta02/gta02.c
index cda7a2b..fd84329 100644
--- a/src/gta02/gta02.c
+++ b/src/gta02/gta02.c
@@ -310,11 +310,12 @@ const struct board_api board_api_gta02 = {
/* these are the ways we could boot GTA02 in order to try */
.kernel_source = {
[0] = {
- .name = "SD Card FAT Kernel",
+ .name = "SD Card EXT2 Kernel",
.block_init = sd_card_init_gta02,
.block_read = sd_card_block_read_gta02,
.partition_index = 1,
.filesystem = FS_EXT2,
+ .filepath = "boot/uImage.bin",
.commandline = "mtdparts=physmap-flash:-(nor);" \
"neo1973-nand:" \
"0x00040000(qi)," \
@@ -333,7 +334,7 @@ const struct board_api board_api_gta02 = {
[1] = {
.name = "NAND Kernel",
.block_read = nand_read_ll,
- .offset_if_no_partition = 0x80000 / 512,
+ .offset_blocks512_if_no_partition = 0x80000 / 512,
.filesystem = FS_RAW,
.commandline = "mtdparts=physmap-flash:-(nor);" \
"neo1973-nand:" \
diff --git a/src/gta03/gta03.c b/src/gta03/gta03.c
index 90f5908..778fda5 100644
--- a/src/gta03/gta03.c
+++ b/src/gta03/gta03.c
@@ -234,7 +234,7 @@ const struct board_api board_api_gta03 = {
[0] = {
.name = "NAND Kernel",
.block_read = nand_read_ll,
- .offset_if_no_partition = 0x80000 / 512,
+ .offset_blocks512_if_no_partition = 0x80000 / 512,
.filesystem = FS_RAW,
.commandline = "neo1973-nand:" \
"0x00040000(qi)," \
diff --git a/src/phase2.c b/src/phase2.c
index 7543e49..fe8b0ec 100644
--- a/src/phase2.c
+++ b/src/phase2.c
@@ -27,9 +27,14 @@
#include <string.h>
#define __ARM__
#include <image.h>
-
#include <setup.h>
#include "nand_read.h"
+#include <ext2.h>
+
+unsigned long partition_offset_blocks = 0;
+unsigned long partition_length_blocks = 0;
+
+struct kernel_source const * this_kernel = 0;
void bootloader_second_phase(void)
@@ -41,52 +46,57 @@ void bootloader_second_phase(void)
/* we try the possible kernels for this board in order */
- while (this_board->kernel_source[kernel].name) {
- const char * cmdline = this_board->kernel_source[kernel].commandline;
- const char *p = cmdline;
+ this_kernel = &this_board->kernel_source[kernel++];
+
+ while (this_kernel->name) {
+ const char *p;
struct tag *params = (struct tag *)this_board->linux_tag_placement;
void * kernel_dram = (void *)(TEXT_BASE - (8 * 1024 * 1024));
unsigned long crc;
image_header_t *hdr;
- unsigned long partition_offset_blocks = 0;
- unsigned long partition_length_blocks = 0;
+ u32 kernel_size;
+
+ partition_offset_blocks = 0;
+ partition_length_blocks = 0;
/* eat leading white space */
- for (p = cmdline; *p == ' '; p++);
+ for (p = this_kernel->commandline; *p == ' '; p++);
- puts("\nTrying kernel: ");
- puts(this_board->kernel_source[kernel].name);
+ puts("\n\nTrying kernel: ");
+ puts(this_kernel->name);
puts("\n");
/* if this device needs initializing, try to init it */
- if (this_board->kernel_source[kernel].block_init)
- if ((this_board->kernel_source[kernel].block_init)()) {
+ if (this_kernel->block_init)
+ if ((this_kernel->block_init)()) {
puts("block device init failed\n");
- kernel++;
+ this_kernel = &this_board->
+ kernel_source[kernel++];
continue;
}
/* if there's a partition table implied, parse it, otherwise
* just use a fixed offset
*/
- if (this_board->kernel_source[kernel].partition_index) {
+ if (this_kernel->partition_index) {
unsigned char *p = kernel_dram;
- if (this_board->kernel_source[kernel].block_read(
- kernel_dram, 0, 4) < 0) {
+ if (this_kernel->block_read(kernel_dram, 0, 4) < 0) {
puts("Bad partition read\n");
- kernel++;
+ this_kernel = &this_board->
+ kernel_source[kernel++];
continue;
}
if ((p[0x1fe] != 0x55) || (p[0x1ff] != 0xaa)) {
puts("partition signature missing\n");
- kernel++;
+ this_kernel = &this_board->
+ kernel_source[kernel++];
continue;
}
- p += 0x1be + 8 + (0x10 * (this_board->
- kernel_source[kernel].partition_index - 1));
+ p += 0x1be + 8 + (0x10 *
+ (this_kernel->partition_index - 1));
partition_offset_blocks = (((u32)p[3]) << 24) |
(((u32)p[2]) << 16) |
@@ -97,39 +107,89 @@ void bootloader_second_phase(void)
(((u32)p[5]) << 8) |
p[4];
- } else
- partition_offset_blocks = this_board->
- kernel_source[kernel].offset_if_no_partition;
+ puts(" Partition: ");
+ printdec(this_kernel->partition_index);
+ puts(" start +");
+ printdec(partition_offset_blocks);
+ puts(" 512-byte blocks, size ");
+ printdec(partition_length_blocks / 2048);
+ puts(" MiB\n");
- if (this_board->kernel_source[kernel].block_read(
- kernel_dram, partition_offset_blocks, 8) < 0) {
- puts ("Bad kernel header\n");
- kernel++;
- continue;
+ } else
+ partition_offset_blocks =
+ this_kernel->offset_blocks512_if_no_partition;
+
+ switch (this_kernel->filesystem) {
+ case FS_EXT2:
+ if (!ext2fs_mount()) {
+ puts("Unable to mount ext2 filesystem\n");
+ this_kernel = &this_board->
+ kernel_source[kernel++];
+ continue;
+ }
+ puts(" EXT2 open: ");
+ puts(this_kernel->filepath);
+ puts("\n");
+ if (ext2fs_open(this_kernel->filepath) < 0) {
+ puts("Open failed\n");
+ this_kernel = &this_board->
+ kernel_source[kernel++];
+ continue;
+ }
+ ext2fs_read(kernel_dram, 4096);
+ break;
+ case FS_FAT:
+ /* FIXME */
+ case FS_RAW:
+ puts(" RAW open: +");
+ printdec(partition_offset_blocks);
+ puts(" 512-byte blocks\n");
+ if (this_kernel->block_read(kernel_dram,
+ partition_offset_blocks, 8) < 0) {
+ puts ("Bad kernel header\n");
+ this_kernel = &this_board->
+ kernel_source[kernel++];
+ continue;
+ }
+ break;
}
hdr = (image_header_t *)kernel_dram;
- if (_ntohl(hdr->ih_magic) != IH_MAGIC) {
+ if (__be32_to_cpu(hdr->ih_magic) != IH_MAGIC) {
puts("bad magic ");
print32(hdr->ih_magic);
- kernel++;
+ puts("\n");
+ this_kernel = &this_board->kernel_source[kernel++];
continue;
}
- puts(" Found: ");
+ puts(" Found: \"");
puts((const char *)hdr->ih_name);
- puts("\n Size: ");
- printdec(_ntohl(hdr->ih_size) >> 10);
+ puts("\"\n Size: ");
+ printdec(__be32_to_cpu(hdr->ih_size) >> 10);
puts(" KiB\n");
- if ((this_board->kernel_source[kernel].block_read)(
- kernel_dram, partition_offset_blocks,
- ((_ntohl(hdr->ih_size) + sizeof(image_header_t) +
- 2048) & ~(2048 - 1)) >> 9) < 0) {
- puts ("Bad kernel read\n");
- kernel++;
- continue;
+ kernel_size = ((__be32_to_cpu(hdr->ih_size) +
+ sizeof(image_header_t) + 2048) & ~(2048 - 1));
+
+ switch (this_kernel->filesystem) {
+ case FS_EXT2:
+ /* This read API always restarts from beginning */
+ ext2fs_read(kernel_dram, kernel_size);
+ break;
+ case FS_FAT:
+ /* FIXME */
+ case FS_RAW:
+ if ((this_kernel->block_read)(
+ kernel_dram, partition_offset_blocks,
+ kernel_size >> 9) < 0) {
+ puts ("Bad kernel read\n");
+ this_kernel = &this_board->
+ kernel_source[kernel++];
+ continue;
+ }
+ break;
}
puts(" Cmdline: ");
@@ -142,14 +202,14 @@ void bootloader_second_phase(void)
* even though it costs us some time
*/
crc = crc32(0, kernel_dram + sizeof(image_header_t),
- _ntohl(hdr->ih_size));
- if (crc != _ntohl(hdr->ih_dcrc)) {
+ __be32_to_cpu(hdr->ih_size));
+ if (crc != __be32_to_cpu(hdr->ih_dcrc)) {
puts("\nKernel CRC ERROR: read 0x");
print32(crc);
puts(" vs hdr CRC 0x");
- print32(_ntohl(hdr->ih_dcrc));
+ print32(__be32_to_cpu(hdr->ih_dcrc));
puts("\n");
- kernel++;
+ this_kernel = &this_board->kernel_source[kernel++];
continue;
}
diff --git a/src/start_qi.c b/src/start_qi.c
index 3d993fd..d4f4905 100644
--- a/src/start_qi.c
+++ b/src/start_qi.c
@@ -98,7 +98,6 @@ void start_qi(void)
puts(", ");
board_variant = (this_board->get_board_variant)();
puts(board_variant->name);
- puts("\n");
/*
* jump to bootloader_second_phase() running from DRAM copy
diff --git a/src/utils.c b/src/utils.c
index 62f7c17..3d72ec2 100644
--- a/src/utils.c
+++ b/src/utils.c
@@ -23,6 +23,9 @@
#include <qi.h>
#include <string.h>
+static u8 malloc_pool[100 * 1024];
+void * malloc_pointer = &malloc_pool[0];
+
int raise(int n)
{
return 0;
@@ -49,15 +52,39 @@ char *strcpy(char *dest, const char *src)
return dest_orig;
}
-unsigned int _ntohl(unsigned int n) {
- return ((n & 0xff) << 24) | ((n & 0xff00) << 8) |
- ((n & 0xff0000) >> 8) | ((n & 0xff000000) >> 24);
+char *strncpy(char *dest, const char *src, size_t n)
+{
+ char * dest_orig = dest;
+
+ while (*src && n--)
+ *dest++ = *src++;
+
+ return dest_orig;
}
-unsigned int _letocpu(unsigned int n) {
- return n;
+
+int strcmp(const char *s1, const char *s2)
+{
+ while (1) {
+ if (*s1 != *s2)
+ return *s1 - *s2;
+ if (!*s1)
+ return 0;
+ s1++;
+ s2++;
+ }
}
+char *strchr(const char *s, int c)
+{
+ while ((*s) && (*s != c))
+ s++;
+
+ if (*s == c)
+ return (char *)s;
+
+ return NULL;
+}
int puts(const char *string)
{
@@ -214,3 +241,47 @@ unsigned long crc32(unsigned long crc, const unsigned char *buf,
return crc ^ 0xffffffffL;
}
+
+void *memcpy(void *dest, const void *src, size_t n)
+{
+ u8 const * ps = src;
+ u8 * pd = dest;
+
+ while (n--)
+ *pd++ = *ps++;
+
+ return dest;
+}
+
+void *memset(void *s, int c, size_t n)
+{
+ u8 * p = s;
+
+ while (n--)
+ *p++ = c;
+
+ return s;
+}
+
+/* improbably simple malloc and free for small and non-intense allocation
+ * just moves the allocation ptr forward each time and ignores free
+ */
+
+void *malloc(size_t size)
+{
+ void *p = malloc_pointer;
+
+ malloc_pointer += size;
+
+ if (((u8 *)malloc_pointer - &malloc_pool[0]) > sizeof(malloc_pool)) {
+ puts("Ran out of malloc pool\n");
+ while (1)
+ ;
+ }
+
+ return p;
+}
+
+void free(void *ptr)
+{
+}
More information about the openmoko-kernel
mailing list
