qi-hardware/xburst-tools
1
0
Fork 0
mirror of git://projects.qi-hardware.com/xburst-tools.git synced 2024-11-22 13:04:04 +02:00
Code

add-ext2-fs.patch

Browse Source 
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@openmoko.com>
This commit is contained in:
Andy Green 2008-11-28 10:16:37 +00:00 committed by Andy Green
parent 935ef0e12d
commit ec8ea0c281
12 changed files with 1269 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
qiboot/Makefile
View File

@ -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)

80
qiboot/include/ext2.h Normal file
View File

@ -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@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);

6
qiboot/include/image.h
View File

@ -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);

11
qiboot/include/qi.h
View File

@ -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);

25
qiboot/src/drivers/glamo-mmc.c
View File

@ -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));

115
qiboot/src/fs/dev.c Normal file
View File

@ -0,0 +1,115 @@
/*
* (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 <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;
}

867
qiboot/src/fs/ext2.c Normal file
View File

@ -0,0 +1,867 @@
/*
*(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 <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;
}

5
qiboot/src/gta02/gta02.c
View File

@ -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:" \

2
qiboot/src/gta03/gta03.c
View File

@ -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)," \

146
qiboot/src/phase2.c
View File

@ -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;
}

1
qiboot/src/start_qi.c
View File

@ -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

81
qiboot/src/utils.c
View File

@ -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)
{
}