Menu
▾
▴
CVS: blob/src/blob Makefile.am,1.23,1.24 compr_rtime.c,1.1,1.2 compr_rubin.c,1.1,1.2 cramfs.c,1.2,1.3 jffs2.c,1.2,1.3 load_kernel.c,1.2,1.3 main.c,1.33,1.34 mini_inflate.c,1.1,1.2 zImage.c,1.2,1.3 compr_zlib.c,1.2,NONE
Update of /cvsroot/blob/blob/src/blob
In directory usw-pr-cvs1:/tmp/cvs-serv23847/src/blob
Modified Files:
Makefile.am compr_rtime.c compr_rubin.c cramfs.c jffs2.c
load_kernel.c main.c mini_inflate.c zImage.c
Removed Files:
compr_zlib.c
Log Message:
cramfs+JFFS2 cleanup part one (code size got almost 2K smaller)
Index: Makefile.am
===================================================================
RCS file: /cvsroot/blob/blob/src/blob/Makefile.am,v
retrieving revision 1.23
retrieving revision 1.24
diff -u -d -r1.23 -r1.24
--- Makefile.am 14 Feb 2002 09:59:34 -0000 1.23
+++ Makefile.am 16 Feb 2002 00:43:59 -0000 1.24
@@ -135,12 +135,11 @@
reboot.c \
uucodec.c \
xmodem.c \
- load_kernel.c \
+ load_kernel.c \
mini_inflate.c \
jffs2.c \
compr_rtime.c \
compr_rubin.c \
- compr_zlib.c \
cramfs.c \
zImage.c
Index: compr_rtime.c
===================================================================
RCS file: /cvsroot/blob/blob/src/blob/compr_rtime.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- compr_rtime.c 14 Feb 2002 09:59:34 -0000 1.1
+++ compr_rtime.c 16 Feb 2002 00:43:59 -0000 1.2
@@ -45,19 +45,27 @@
*
*/
-#include "blob/types.h"
+#ident "$Id$"
+
+#ifdef HAVE_CONFIG_H
+# include <blob/config.h>
+#endif
+
+#include <blob/types.h>
+#include <blob/util.h>
+
+static int positions[256];
void rtime_decompress(unsigned char *data_in, unsigned char *cpage_out,
- u32 srclen, u32 destlen)
+ u32 srclen, u32 destlen)
{
- int positions[256];
int outpos;
int pos;
int i;
outpos = pos = 0;
- for (i = 0; i < 256; positions[i++] = 0);
+ memset(positions, 0, 256 * sizeof(int));
while (outpos<destlen) {
unsigned char value;
Index: compr_rubin.c
===================================================================
RCS file: /cvsroot/blob/blob/src/blob/compr_rubin.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- compr_rubin.c 14 Feb 2002 09:59:34 -0000 1.1
+++ compr_rubin.c 16 Feb 2002 00:43:59 -0000 1.2
@@ -38,12 +38,18 @@
*
*/
-
-#include "blob/types.h"
-#include "blob/compr_rubin.h"
+#ident "$Id$"
-void rubin_do_decompress(unsigned char *bits, unsigned char *in,
- unsigned char *page_out, u32 destlen)
+#ifdef HAVE_CONFIG_H
+# include <blob/config.h>
+#endif
+
+#include <blob/types.h>
+#include <blob/compr_rubin.h>
+
+
+static void rubin_do_decompress(unsigned char *bits, unsigned char *in,
+ unsigned char *page_out, u32 destlen)
{
register char *curr = page_out;
char *end = page_out + destlen;
Index: cramfs.c
===================================================================
RCS file: /cvsroot/blob/blob/src/blob/cramfs.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- cramfs.c 14 Feb 2002 10:17:59 -0000 1.2
+++ cramfs.c 16 Feb 2002 00:43:59 -0000 1.3
@@ -26,10 +26,16 @@
/* note: this module doesn't currently support symlinks, but because of the
* nature of cramfs, this shouldn't be a big deal */
-#include "blob/types.h"
-#include "blob/main.h"
-#include "blob/load_kernel.h"
-#include "blob/mini_inflate.h"
+#ident "$Id$"
+
+#ifdef HAVE_CONFIG_H
+# include <blob/config.h>
+#endif
+
+#include <blob/types.h>
+#include <blob/load_kernel.h>
+#include <blob/mini_inflate.h>
+#include <blob/util.h>
#define CRAMFS_MAGIC 0x28cd3d45 /* some random number */
@@ -74,7 +80,7 @@
src++; /* *src == 0x78 method */
src++; /* *src == 0x9C flags (!PRESET_DICT) */
- size = decompress_block(dest, src, ldr_memcpy);
+ size = decompress_block(dest, src);
return size;
}
@@ -84,7 +90,7 @@
{
long int curr_block;
- unsigned long *block_ptrs;
+ u32 *block_ptrs;
long size, total_size = 0;
int i;
@@ -128,7 +134,7 @@
/* does it have 5 to 8 characters? */
if (!inode->namelen == 2) continue;
name = (char *) (inode + 1);
- if (!ldr_strncmp("linux\0\0", name, 8)) {
+ if (!strncmp("linux\0\0", name, 8)) {
size = cramfs_load_file(dest, part, inode);
break;
}
Index: jffs2.c
===================================================================
RCS file: /cvsroot/blob/blob/src/blob/jffs2.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- jffs2.c 14 Feb 2002 10:17:59 -0000 1.2
+++ jffs2.c 16 Feb 2002 00:43:59 -0000 1.3
@@ -63,21 +63,29 @@
*
*/
+#ident "$Id$"
+
+#ifdef HAVE_CONFIG_H
+# include <blob/config.h>
+#endif
+
+#include <blob/crc32.h>
+#include <blob/compr_rubin.h>
+#include <blob/jffs2.h>
+#include <blob/load_kernel.h>
+#include <blob/main.h>
+#include <blob/mini_inflate.h>
+#include <blob/types.h>
+#include <blob/util.h>
+
+
-#include "blob/types.h"
-#include "blob/main.h"
-#include "blob/load_kernel.h"
-#include "blob/jffs2.h"
-#include "blob/crc32.h"
static struct jffs2_raw_dirent *find_inode(struct part_info *part, char *name,
u32 pino);
-void rtime_decompress (unsigned char *data_in, unsigned char *cpage_out,
- u32 srclen, u32 destlen);
-void dynrubin_decompress(unsigned char *data_in, unsigned char *cpage_out,
- u32 srclen, u32 destlen);
-void zlib_decompress (unsigned char *data_in, unsigned char *cpage_out,
- u32 srclen, u32 destlen);
+extern void rtime_decompress(unsigned char *data_in, unsigned char *cpage_out,
+ u32 srclen, u32 destlen);
+
struct data_strip {
struct jffs2_raw_inode *inode;
@@ -87,14 +95,25 @@
struct data_strip *next;
};
-inline int hdr_crc(struct jffs2_unknown_node *node)
+
+static inline void zlib_decompress(unsigned char *data_in,
+ unsigned char *cpage_out,
+ u32 srclen, u32 destlen)
+{
+ /* FIXME: we *totally* ignore the srclen and destlen
+ * parameters over here -- Erik */
+ decompress_block(cpage_out, data_in + 2);
+}
+
+
+static int hdr_crc(struct jffs2_unknown_node *node)
{
if(node->hdr_crc != crc32(0, node, sizeof(struct jffs2_unknown_node) - 4))
return 0;
else return 1;
}
-inline int dirent_crc(struct jffs2_raw_dirent *node)
+static int dirent_crc(struct jffs2_raw_dirent *node)
{
if (node->node_crc != crc32(0, node, sizeof(struct jffs2_raw_dirent) - 8)) {
UDEBUG("bad dirent_crc\n");
@@ -102,7 +121,7 @@
} else return 1;
}
-inline int dirent_name_crc(struct jffs2_raw_dirent *node)
+static int dirent_name_crc(struct jffs2_raw_dirent *node)
{
if (node->name_crc != crc32(0, &(node->name), node->nsize)) {
UDEBUG("bad dirent_name_crc\n");
@@ -110,7 +129,7 @@
} else return 1;
}
-inline int inode_crc(struct jffs2_raw_inode *node)
+static int inode_crc(struct jffs2_raw_inode *node)
{
if (node->node_crc != crc32(0, node, sizeof(struct jffs2_raw_inode) - 8)) {
UDEBUG("bad inode_crc\n");
@@ -139,13 +158,13 @@
src = ((char *) first->inode) + sizeof(struct jffs2_raw_inode);
if (first->inode->data_crc != crc32(0, src, first->inode->csize)) {
- ldr_output_string("CRC Error!");
+ printf("CRC Error!");
return 0;
}
switch (first->inode->compr) {
case JFFS2_COMPR_NONE:
- ldr_memcpy(dest, src, first->length);
+ memcpy(dest, src, first->length);
break;
case JFFS2_COMPR_ZERO:
for (i = 0; i < first->length; i++) *(dest++) = 0;
@@ -198,7 +217,8 @@
/* Fill the list of nodes pertaining to this file */
while (offset < part->size - sizeof(struct jffs2_raw_inode)) {
inode = (struct jffs2_raw_inode *) (part->offset + offset);
- if (inode->magic == JFFS2_MAGIC_BITMASK && hdr_crc(inode)) {
+ if (inode->magic == JFFS2_MAGIC_BITMASK &&
+ hdr_crc((struct jffs2_unknown_node *)inode)) {
if (inode->nodetype == JFFS2_NODETYPE_INODE &&
inode->ino == inode_num && inode_crc(inode)) {
/* add it in newest first order to our list */
@@ -289,7 +309,7 @@
curr_name[len] = '\0';
/* go up an inode if its a '..' */
- up = (len == 2 && !ldr_strncmp("..", curr_name, 2));
+ up = (len == 2 && !strncmp("..", curr_name, 2));
UDEBUG("\nlooking for '%s' ...", curr_name);
@@ -300,7 +320,7 @@
while (off < part->size - sizeof(struct jffs2_raw_inode)) {
curr = (struct jffs2_raw_dirent *)(part->offset + off);
if (curr->magic == JFFS2_MAGIC_BITMASK &&
- hdr_crc(curr)) {
+ hdr_crc((struct jffs2_unknown_node*)curr)) {
if (curr->nodetype == JFFS2_NODETYPE_DIRENT &&
up && curr->ino == pino && dirent_crc(curr) &&
curr->version > version) {
@@ -310,7 +330,7 @@
!up && curr->pino == pino &&
curr->nsize == len && dirent_crc(curr) &&
dirent_name_crc(curr) &&
- !ldr_strncmp(curr_name, curr->name, len) &&
+ !strncmp(curr_name, curr->name, len) &&
curr->version > version) {
UDEBUG("found matching dirent\n");
version = curr->version;
Index: load_kernel.c
===================================================================
RCS file: /cvsroot/blob/blob/src/blob/load_kernel.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- load_kernel.c 14 Feb 2002 10:17:59 -0000 1.2
+++ load_kernel.c 16 Feb 2002 00:43:59 -0000 1.3
@@ -26,14 +26,16 @@
*
*/
-#include "types.h"
-#include "config.h"
-#include "serial.h"
-#include "util.h"
-#include "main.h"
-#include "load_kernel.h"
+#ident "$Id$"
+
+#ifdef HAVE_CONFIG_H
+# include <blob/config.h>
+#endif
#include <blob/arch.h>
+#include <blob/error.h>
+#include <blob/load_kernel.h>
+#include <blob/util.h>
#ifdef CONFIG_CRAMFS_SUPPORT
extern struct kernel_loader cramfs_load;
@@ -64,36 +66,17 @@
const void *fodder_ram_base = (void *) FODDER_RAM_BASE;
/* function calls for blob */
-inline void ldr_update_progress(void)
+void ldr_update_progress(void)
{
printf(".");
}
-inline int ldr_strncmp(char *a, char *b, size_t n)
-{
- return strncmp(a, b, n);
-}
-inline void *ldr_memcpy(void *dst, void *src, size_t n)
-{
- memcpy(dst, src, n);
- return dst;
-}
-
-inline void ldr_output_string(char *str)
-{
- SerialOutputString(str);
-}
-
-inline void ldr_output_hex(u32 hex)
-{
- SerialOutputHex(hex);
-}
void load_kernel(blob_status_t *blob_status)
{
int i;
- unsigned long size;
+ u32 size;
struct part_info part;
/* FIXME this is hardcoded, should use flash[].size */
@@ -101,26 +84,26 @@
part.erasesize = MAIN_BLOCK_SIZE;
part.size = KERNEL_FLASH_LEN;
part.offset = (char *) KERNEL_FLASH_BASE;
- for (i = 0; loader[i] && !loader[i]->check_magic(&part); i++);
+
+ for (i = 0; loader[i] && !loader[i]->check_magic(&part); i++)
+ ;
+
if (!loader[i]) {
- SerialOutputString("unable to find kernel, loading raw data "
- "and hoping for the best!\rloading");
+ eprintf("unable to find kernel, loading raw data "
+ "and hoping for the best!\n");
size = KERNEL_FLASH_LEN;
MyMemCpy((u32 *)KERNEL_RAM_BASE, (u32 *)KERNEL_FLASH_BASE, size >> 2);
-
} else {
- SerialOutputString("loading kernel from ");
- SerialOutputString(loader[i]->name);
+ printf("loading kernel from %s ...", loader[i]->name);
if ((size = loader[i]->load_kernel((u32 *)KERNEL_RAM_BASE,
&part)) == 0) {
- SerialOutputString(" error loading kernel!\r");
+ eprintf("error loading kernel!\n");
return;
}
}
- SerialOutputString("loaded 0x");
- SerialOutputHex(size);
- SerialOutputString(" bytes\r");
+
blob_status->kernelSize = size;
blob_status->kernelType = fromFlash;
-}
+ printf("loaded 0x%08x (%d) bytes\n", size, size);
+}
Index: main.c
===================================================================
RCS file: /cvsroot/blob/blob/src/blob/main.c,v
retrieving revision 1.33
retrieving revision 1.34
diff -u -d -r1.33 -r1.34
--- main.c 14 Feb 2002 10:17:59 -0000 1.33
+++ main.c 16 Feb 2002 00:43:59 -0000 1.34
@@ -45,6 +45,7 @@
#include <blob/flash.h>
#include <blob/init.h>
#include <blob/led.h>
+#include <blob/load_kernel.h>
#include <blob/main.h>
#include <blob/md5.h>
#include <blob/md5support.h>
@@ -57,7 +58,6 @@
#include <blob/uucodec.h>
#include <blob/xmodem.h>
-#include "load_kernel.h"
static int do_reload(char *what);
Index: mini_inflate.c
===================================================================
RCS file: /cvsroot/blob/blob/src/blob/mini_inflate.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- mini_inflate.c 14 Feb 2002 09:59:34 -0000 1.1
+++ mini_inflate.c 16 Feb 2002 00:43:59 -0000 1.2
@@ -22,25 +22,81 @@
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
-#include "blob/mini_inflate.h"
+#ident "$Id$"
+
+#ifdef HAVE_CONFIG_H
+# include <blob/config.h>
+#endif
+
+#include <blob/mini_inflate.h>
+#include <blob/util.h>
+
+
+
+#define NO_ERROR 0
+#define COMP_UNKNOWN 1 /* The specififed bytype is invalid */
+#define CODE_NOT_FOUND 2 /* a huffman code in the stream could not be decoded */
+#define TOO_MANY_BITS 3 /* pull_bits was passed an argument that is too
+ * large */
+
+/* This struct represents an entire huffman code set. It has various lookup
+ * tables to speed decoding */
+struct huffman_set {
+ int bits; /* maximum bit length */
+ int num_symbols; /* Number of symbols this code can represent */
+ int *lengths; /* The bit length of symbols */
+ int *symbols; /* All of the symbols, sorted by the huffman code */
+ int *count; /* the number of codes of this bit length */
+ int *first; /* the first code of this bit length */
+ int *pos; /* the symbol that first represents (in the symbols
+ * array) */
+};
+
+struct bitstream {
+ unsigned char *data; /* increments as we move from byte to byte */
+ unsigned char bit; /* 0 to 7 */
+ unsigned long decoded; /* The number of bytes decoded */
+ int error;
+
+ int distance_count[16];
+ int distance_first[16];
+ int distance_pos[16];
+ int distance_lengths[32];
+ int distance_symbols[32];
+
+ int code_count[8];
+ int code_first[8];
+ int code_pos[8];
+ int code_lengths[19];
+ int code_symbols[19];
+
+ int length_count[16];
+ int length_first[16];
+ int length_pos[16];
+ int length_lengths[288];
+ int length_symbols[288];
+
+ struct huffman_set codes;
+ struct huffman_set lengths;
+ struct huffman_set distance;
+};
+
+#define NO_COMP 0
+#define FIXED_COMP 1
+#define DYNAMIC_COMP 2
+
+
+
/* The order that the code lengths in section 3.2.7 are in */
static unsigned char huffman_order[] = {16, 17, 18, 0, 8, 7, 9, 6, 10, 5,
11, 4, 12, 3, 13, 2, 14, 1, 15};
-inline void cramfs_memset(int *s, const int c, size n)
-{
- n--;
- for (;n > 0; n--) s[n] = c;
- s[0] = c;
-}
/* associate a stream with a block of data and reset the stream */
-static void init_stream(struct bitstream *stream, unsigned char *data,
- void *(*inflate_memcpy)(void *, void *, size))
+static void init_stream(struct bitstream *stream, unsigned char *data)
{
stream->error = NO_ERROR;
- stream->memcpy = inflate_memcpy;
stream->decoded = 0;
stream->data = data;
stream->bit = 0; /* The first bit of the stream is the lsb of the
@@ -77,7 +133,7 @@
/* pull 'bits' bits out of the stream. The last bit pulled it returned as the
* msb. (section 3.1.1)
*/
-inline unsigned long pull_bits(struct bitstream *stream,
+static unsigned long pull_bits(struct bitstream *stream,
const unsigned int bits)
{
unsigned long ret;
@@ -97,7 +153,7 @@
return ret;
}
-inline int pull_bit(struct bitstream *stream)
+static int pull_bit(struct bitstream *stream)
{
int ret = ((*(stream->data) >> stream->bit) & 1);
if (stream->bit++ == 7) {
@@ -127,7 +183,7 @@
pull_bits(stream, 16); /* throw away the inverse of the size */
stream->decoded += length;
- stream->memcpy(dest, stream->data, length);
+ memcpy(dest, stream->data, length);
stream->data += length;
}
@@ -214,9 +270,9 @@
static void init_code_tables(struct huffman_set *set)
{
- cramfs_memset(set->lengths, 0, set->num_symbols);
- cramfs_memset(set->count, 0, set->bits);
- cramfs_memset(set->first, 0, set->bits);
+ memset(set->lengths, 0, set->num_symbols);
+ memset(set->count, 0, set->bits);
+ memset(set->first, 0, set->bits);
}
/* read in the huffman codes for dynamic decoding (section 3.2.7) */
@@ -332,19 +388,19 @@
struct huffman_set *lengths = &(stream->lengths);
struct huffman_set *distance = &(stream->distance);
- cramfs_memset(lengths->count, 0, 16);
- cramfs_memset(lengths->first, 0, 16);
- cramfs_memset(lengths->lengths, 8, 144);
- cramfs_memset(lengths->lengths + 144, 9, 112);
- cramfs_memset(lengths->lengths + 256, 7, 24);
- cramfs_memset(lengths->lengths + 280, 8, 8);
+ memset(lengths->count, 0, 16);
+ memset(lengths->first, 0, 16);
+ memset(lengths->lengths, 8, 144);
+ memset(lengths->lengths + 144, 9, 112);
+ memset(lengths->lengths + 256, 7, 24);
+ memset(lengths->lengths + 280, 8, 8);
lengths->count[7] = 24;
lengths->count[8] = 152;
lengths->count[9] = 112;
- cramfs_memset(distance->count, 0, 16);
- cramfs_memset(distance->first, 0, 16);
- cramfs_memset(distance->lengths, 5, 32);
+ memset(distance->count, 0, 16);
+ memset(distance->first, 0, 16);
+ memset(distance->lengths, 5, 32);
distance->count[5] = 32;
@@ -358,13 +414,12 @@
/* returns the number of bytes decoded, < 0 if there was an error. Note that
* this function assumes that the block starts on a byte boundry
* (non-compliant, but I don't see where this would happen). section 3.2.3 */
-long decompress_block(unsigned char *dest, unsigned char *source,
- void *(*inflate_memcpy)(void *, void *, size))
+long decompress_block(unsigned char *dest, unsigned char *source)
{
int bfinal, btype;
struct bitstream stream;
- init_stream(&stream, source, inflate_memcpy);
+ init_stream(&stream, source);
do {
bfinal = pull_bit(&stream);
btype = pull_bits(&stream, 2);
Index: zImage.c
===================================================================
RCS file: /cvsroot/blob/blob/src/blob/zImage.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- zImage.c 14 Feb 2002 10:17:59 -0000 1.2
+++ zImage.c 16 Feb 2002 00:43:59 -0000 1.3
@@ -23,9 +23,19 @@
*
*/
-#include "blob/types.h"
-#include "blob/main.h"
-#include "blob/load_kernel.h"
+#ident "$Id$"
+
+#ifdef HAVE_CONFIG_H
+# include <blob/config.h>
+#endif
+
+#include <blob/load_kernel.h>
+#include <blob/main.h>
+#include <blob/types.h>
+#include <blob/util.h>
+
+
+
#define ZIMAGE_MAGIC 0x016f2818
@@ -44,9 +54,9 @@
* ldr_update_progress */
for (i = 0; i <= size - 0x40000; i += 0x40000) {
ldr_update_progress();
- ldr_memcpy((char *) dest + i, part->offset + i, 0x40000);
+ memcpy((char *) dest + i, part->offset + i, 0x40000);
}
- ldr_memcpy((char *) dest + i, part->offset + i, size - i);
+ memcpy((char *) dest + i, part->offset + i, size - i);
return size;
}
--- compr_zlib.c DELETED ---
|
