URL
https://opencores.org/ocsvn/or1k_old/or1k_old/trunk
Subversion Repositories or1k_old
Compare Revisions
- This comparison shows the changes necessary to convert path
/or1k_old/trunk/rc203soc/sw/uClinux/arch/armnommu/boot/compressed
- from Rev 1765 to Rev 1782
- ↔ Reverse comparison
Rev 1765 → Rev 1782
/piggyback.c
0,0 → 1,91
/* |
* linux/zBoot/piggyback.c |
* |
* (C) 1993 Hannu Savolainen |
*/ |
|
/* |
* This program reads the compressed system image from stdin and |
* encapsulates it into an object file written to the stdout. |
*/ |
|
#include <stdio.h> |
#include <unistd.h> |
#include <a.out.h> |
#include <sys/fcntl.h> |
|
int main(int argc, char *argv[]) |
{ |
int n=0, len=0, fd = 0; |
char tmp_buf[640*1024]; |
|
struct exec obj = {0x00670107}; /* object header */ |
char string_names[] = {"_input_data\0_input_end\0"}; |
|
struct nlist var_names[2] = /* Symbol table */ |
{ |
{ /* _input_data */ |
{(char *)4}, 7, 0, 0, 0 |
}, |
{ /* _input_len */ |
{(char *)16}, 7, 0, 0, 0 |
} |
}; |
|
|
if (argc > 1) { |
fd = open (argv[1], O_RDONLY); |
if (fd < 0) { |
fprintf (stderr, "%s: ", argv[0]); |
perror (argv[1]); |
exit (1); |
} |
} |
|
len = 0; |
while ((n = read(fd, &tmp_buf[len], sizeof(tmp_buf)-len+1)) > 0) |
len += n; |
|
len = (len + 3) & ~3; |
|
if (n==-1) { |
perror("stdin"); |
exit(-1); |
} |
|
if (len >= sizeof(tmp_buf)) { |
fprintf(stderr, "%s: Input too large\n", argv[0]); |
exit(-1); |
} |
|
if (argc < 2) |
fprintf(stderr, "Compressed size %d.\n", len); |
|
/* |
* Output object header |
*/ |
obj.a_data = len /* + sizeof(long) */; |
obj.a_syms = sizeof(var_names); |
write(1, (char *)&obj, sizeof(obj)); |
|
/* |
* Output data segment (compressed system & len) |
*/ |
write(1, tmp_buf, len); |
|
/* |
* Output symbol table |
*/ |
var_names[1].n_value = len; |
write(1, (char *)&var_names, sizeof(var_names)); |
|
/* |
* Output string table |
*/ |
len = sizeof(string_names) + sizeof(len); |
write(1, (char *)&len, sizeof(len)); |
write(1, string_names, sizeof(string_names)); |
|
exit(0); |
|
} |
/Makefile.debug
0,0 → 1,16
# |
# linux/arch/arm/boot/compressed/Makefile |
# |
# create a compressed vmlinux image from the original vmlinux |
# |
|
COMPRESSED_EXTRA=../../lib/ll_char_wr.o |
OBJECTS=misc-debug.o $(COMPRESSED_EXTRA) |
|
CFLAGS=-D__KERNEL__ -O2 -DSTDC_HEADERS -DSTANDALONE_DEBUG -Wall -I../../../../include -c |
|
test-gzip: piggy.o $(OBJECTS) |
$(CC) -o $@ $(OBJECTS) piggy.o |
|
misc-debug.o: misc.c |
$(CC) $(CFLAGS) -o $@ misc.c |
/head.S
0,0 → 1,102
/* |
* linux/arch/arm/boot/compressed/head.S |
* |
* Copyright (C) 1996 Russell King |
*/ |
.text |
/* |
* sort out different calling conventions |
*/ |
start: teq r0, #0 |
beq newparams |
mov r4, #0x02000000 |
add r4, r4, #0x7C000 |
mov r3, #0x4000 |
sub r3, r3, #4 |
1: ldmia r0!, {r5 - r12} |
stmia r4!, {r5 - r12} |
subs r3, r3, #32 |
bpl 1b |
newparams: adr r2, LC0 |
ldmia r2, {r2, r3, r4, r5, r6, sp} |
adr r7, start |
sub r6, r7, r6 |
/* |
* Relocate pointers |
*/ |
add r2, r2, r6 |
add r3, r3, r6 |
add r5, r5, r6 |
add sp, sp, r6 |
/* |
* Clear zero-init |
*/ |
mov r6, #0 |
1: str r6, [r2], #4 |
cmp r2, r3 |
blt 1b |
str r1, [r5] @ save architecture |
/* |
* Uncompress the kernel |
*/ |
mov r1, #0x8000 |
add r2, r2, r1, lsl #1 @ Add 64k for malloc |
sub r1, r1, #1 |
add r2, r2, r1 |
bic r5, r2, r1 @ decompress kernel to after end of the compressed |
mov r0, r5 |
bl _decompress_kernel |
add r0, r0, #7 |
bic r2, r0, #7 |
/* |
* Now move the kernel to the correct location (r5 -> r4, len r0) |
*/ |
mov r0, r4 @ r0 = start of real kernel |
mov r1, r5 @ r1 = start of kernel image |
add r3, r5, r2 @ r3 = end of kernel |
adr r4, movecode |
adr r5, movecodeend |
1: ldmia r4!, {r6 - r12, lr} |
stmia r3!, {r6 - r12, lr} |
cmp r4, r5 |
blt 1b |
mrc p15, 0, r5, c0, c0 |
eor r5, r5, #0x44 << 24 |
eor r5, r5, #0x01 << 16 |
eor r5, r5, #0xa1 << 8 |
movs r5, r5, lsr #4 |
mov r5, #0 |
mcreq p15, 0, r5, c7, c5, 0 @ flush I cache |
ldr r5, LC0 + 12 @ get architecture |
ldr r5, [r5] |
add pc, r1, r2 @ Call move code |
|
/* |
* r0 = length, r1 = to, r2 = from |
*/ |
movecode: add r3, r1, r2 |
mov r4, r0 |
1: ldmia r1!, {r6 - r12, lr} |
stmia r0!, {r6 - r12, lr} |
cmp r1, r3 |
blt 1b |
mrc p15, 0, r0, c0, c0 |
eor r0, r0, #0x44 << 24 |
eor r0, r0, #0x01 << 16 |
eor r0, r0, #0xa1 << 8 |
movs r0, r0, lsr #4 |
mov r0, #0 |
mcreq p15, 0, r0, c7, c5, 0 @ flush I cache |
mov r1, r5 @ call kernel correctly |
add pc, r4, #0x20 @ call via EXEC entry |
|
movecodeend: |
LC0: .word __edata |
.word __end |
.word LOADADDR |
.word _architecture |
.word start |
.word _user_stack+4096 |
|
.bss |
_architecture: .word 0 |
/xtract.c
0,0 → 1,92
/* |
* linux/zBoot/xtract.c |
* |
* Copyright (C) 1993 Hannu Savolainen |
* |
* Extracts the system image and writes it to the stdout. |
* based on tools/build.c by Linus Torvalds |
*/ |
|
#include <stdio.h> /* fprintf */ |
#include <string.h> |
#include <stdlib.h> /* contains exit */ |
#include <sys/types.h> /* unistd.h needs this */ |
#include <sys/stat.h> |
#include <sys/sysmacros.h> |
#include <unistd.h> /* contains read/write */ |
#include <fcntl.h> |
#include <a.out.h> |
|
#define N_MAGIC_OFFSET 1024 |
|
static int GCC_HEADER = sizeof(struct exec); |
|
#define STRINGIFY(x) #x |
|
void die(char * str) |
{ |
fprintf(stderr,"%s\n",str); |
exit(1); |
} |
|
void usage(void) |
{ |
die("Usage: xtract system [ | gzip | piggyback > piggy.s]"); |
} |
|
int main(int argc, char ** argv) |
{ |
int id, sz; |
char buf[1024]; |
|
struct exec *ex = ((struct exec *)buf) + 1; |
|
if (argc != 2) |
usage(); |
|
if ((id=open(argv[1],O_RDONLY,0))<0) |
die("Unable to open 'system'"); |
if (read(id,ex,GCC_HEADER) != GCC_HEADER) |
die("Unable to read header of 'system'"); |
|
switch (N_MAGIC(*ex)) { |
case ZMAGIC: |
GCC_HEADER = N_MAGIC_OFFSET; |
lseek(id, GCC_HEADER, SEEK_SET); |
break; |
case QMAGIC: |
memset (buf, 0, GCC_HEADER); |
buf[0x14] = 0x20; |
write (1, buf, GCC_HEADER); |
break; |
default: |
die("Non-GCC header of 'system'"); |
} |
|
sz = N_SYMOFF(*ex) - GCC_HEADER + 4; /* +4 to get the same result than tools/build */ |
|
fprintf(stderr, "System size is %d\n", sz); |
|
while (sz) { |
int l, n; |
|
l = sz; |
if (l > sizeof(buf)) l = sizeof(buf); |
|
if ((n=read(id, buf, l)) !=l) |
{ |
if (n == -1) |
perror(argv[1]); |
else |
fprintf(stderr, "Unexpected EOF\n"); |
|
die("Can't read system"); |
} |
|
write(1, buf, l); |
sz -= l; |
} |
|
close(id); |
return(0); |
} |
/misc.c
0,0 → 1,305
/* |
* misc.c |
* |
* This is a collection of several routines from gzip-1.0.3 |
* adapted for Linux. |
* |
* malloc by Hannu Savolainen 1993 and Matthias Urlichs 1994 |
*/ |
|
#include <asm/segment.h> |
#include <asm/arch/uncompress.h> |
#include <asm/proc/uncompress.h> |
|
#ifdef STANDALONE_DEBUG |
#define puts printf |
#endif |
|
#define __ptr_t void * |
|
/* |
* Optimised C version of memzero for the ARM. |
*/ |
extern __inline__ __ptr_t __memzero (__ptr_t s, size_t n) |
{ |
union { void *vp; unsigned long *ulp; unsigned char *ucp; } u; |
int i; |
|
u.vp = s; |
|
for (i = n >> 5; i > 0; i--) { |
*u.ulp++ = 0; |
*u.ulp++ = 0; |
*u.ulp++ = 0; |
*u.ulp++ = 0; |
*u.ulp++ = 0; |
*u.ulp++ = 0; |
*u.ulp++ = 0; |
*u.ulp++ = 0; |
} |
|
if (n & 1 << 4) { |
*u.ulp++ = 0; |
*u.ulp++ = 0; |
*u.ulp++ = 0; |
*u.ulp++ = 0; |
} |
|
if (n & 1 << 3) { |
*u.ulp++ = 0; |
*u.ulp++ = 0; |
} |
|
if (n & 1 << 2) |
*u.ulp++ = 0; |
|
if (n & 1 << 1) { |
*u.ucp++ = 0; |
*u.ucp++ = 0; |
} |
|
if (n & 1) |
*u.ucp++ = 0; |
return s; |
} |
|
#define memzero(s,n) __memzero(s,n) |
|
extern __inline__ __ptr_t memcpy(__ptr_t __dest, __const __ptr_t __src, |
size_t __n) |
{ |
int i = 0; |
unsigned char *d = (unsigned char *)__dest, *s = (unsigned char *)__src; |
|
for (i = __n >> 3; i > 0; i--) { |
*d++ = *s++; |
*d++ = *s++; |
*d++ = *s++; |
*d++ = *s++; |
*d++ = *s++; |
*d++ = *s++; |
*d++ = *s++; |
*d++ = *s++; |
} |
|
if (__n & 1 << 2) { |
*d++ = *s++; |
*d++ = *s++; |
*d++ = *s++; |
*d++ = *s++; |
} |
|
if (__n & 1 << 1) { |
*d++ = *s++; |
*d++ = *s++; |
} |
|
if (__n & 1) |
*d++ = *s++; |
|
return __dest; |
} |
|
/* |
* gzip delarations |
*/ |
#define OF(args) args |
#define STATIC static |
|
typedef unsigned char uch; |
typedef unsigned short ush; |
typedef unsigned long ulg; |
|
#define WSIZE 0x8000 /* Window size must be at least 32k, */ |
/* and a power of two */ |
|
static uch *inbuf; /* input buffer */ |
static uch window[WSIZE]; /* Sliding window buffer */ |
|
static unsigned insize; /* valid bytes in inbuf */ |
static unsigned inptr; /* index of next byte to be processed in inbuf */ |
static unsigned outcnt; /* bytes in output buffer */ |
|
/* gzip flag byte */ |
#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ |
#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */ |
#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ |
#define ORIG_NAME 0x08 /* bit 3 set: original file name present */ |
#define COMMENT 0x10 /* bit 4 set: file comment present */ |
#define ENCRYPTED 0x20 /* bit 5 set: file is encrypted */ |
#define RESERVED 0xC0 /* bit 6,7: reserved */ |
|
#define get_byte() (inptr < insize ? inbuf[inptr++] : fill_inbuf()) |
|
/* Diagnostic functions */ |
#ifdef DEBUG |
# define Assert(cond,msg) {if(!(cond)) error(msg);} |
# define Trace(x) fprintf x |
# define Tracev(x) {if (verbose) fprintf x ;} |
# define Tracevv(x) {if (verbose>1) fprintf x ;} |
# define Tracec(c,x) {if (verbose && (c)) fprintf x ;} |
# define Tracecv(c,x) {if (verbose>1 && (c)) fprintf x ;} |
#else |
# define Assert(cond,msg) |
# define Trace(x) |
# define Tracev(x) |
# define Tracevv(x) |
# define Tracec(c,x) |
# define Tracecv(c,x) |
#endif |
|
static int fill_inbuf(void); |
static void flush_window(void); |
static void error(char *m); |
static void gzip_mark(void **); |
static void gzip_release(void **); |
|
extern char input_data[], input_end[]; |
|
static uch *output_data; |
static ulg output_ptr; |
static ulg bytes_out; |
|
static void *malloc(int size); |
static void free(void *where); |
static void error(char *m); |
static void gzip_mark(void **); |
static void gzip_release(void **); |
|
static void puts(const char *); |
|
extern int end; |
static ulg free_mem_ptr; |
static ulg free_mem_ptr_end; |
|
#define HEAP_SIZE 0x2000 |
|
#include "../../../../lib/inflate.c" |
|
#ifndef STANDALONE_DEBUG |
static void *malloc(int size) |
{ |
void *p; |
|
if (size <0) error("Malloc error\n"); |
if (free_mem_ptr <= 0) error("Memory error\n"); |
|
free_mem_ptr = (free_mem_ptr + 3) & ~3; /* Align */ |
|
p = (void *)free_mem_ptr; |
free_mem_ptr += size; |
|
if (free_mem_ptr >= free_mem_ptr_end) |
error("Out of memory"); |
return p; |
} |
|
static void free(void *where) |
{ /* gzip_mark & gzip_release do the free */ |
} |
|
static void gzip_mark(void **ptr) |
{ |
*ptr = (void *) free_mem_ptr; |
} |
|
static void gzip_release(void **ptr) |
{ |
free_mem_ptr = (long) *ptr; |
} |
#else |
static void gzip_mark(void **ptr) |
{ |
} |
|
static void gzip_release(void **ptr) |
{ |
} |
#endif |
|
/* =========================================================================== |
* Fill the input buffer. This is called only when the buffer is empty |
* and at least one byte is really needed. |
*/ |
int fill_inbuf() |
{ |
if (insize != 0) |
error("ran out of input data\n"); |
|
inbuf = input_data; |
insize = input_end - input_data; |
inptr = 1; |
return inbuf[0]; |
} |
|
/* =========================================================================== |
* Write the output window window[0..outcnt-1] and update crc and bytes_out. |
* (Used for the decompressed data only.) |
*/ |
void flush_window() |
{ |
ulg c = crc; |
unsigned n; |
uch *in, *out, ch; |
|
in = window; |
out = &output_data[output_ptr]; |
for (n = 0; n < outcnt; n++) { |
ch = *out++ = *in++; |
c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8); |
} |
crc = c; |
bytes_out += (ulg)outcnt; |
output_ptr += (ulg)outcnt; |
outcnt = 0; |
} |
|
static void error(char *x) |
{ |
int ptr; |
|
puts("\n\n"); |
puts(x); |
puts("\n\n -- System halted"); |
|
while(1); /* Halt */ |
} |
|
#define STACK_SIZE (4096) |
|
ulg user_stack [STACK_SIZE]; |
|
#ifndef STANDALONE_DEBUG |
|
ulg decompress_kernel(ulg output_start) |
{ |
free_mem_ptr = (ulg)&end; |
free_mem_ptr_end = output_start; |
|
proc_decomp_setup (); |
arch_decomp_setup (); |
|
output_data = (uch *)output_start; /* Points to kernel start */ |
|
makecrc(); |
puts("Uncompressing Linux..."); |
gunzip(); |
puts("done.\nNow booting the kernel\n"); |
return output_ptr; |
} |
#else |
|
char output_buffer[1024*1024]; |
|
int main() |
{ |
output_data = output_buffer; |
|
makecrc(); |
puts("Uncompressing Linux..."); |
gunzip(); |
puts("done.\n"); |
return 0; |
} |
#endif |
|
/Makefile
0,0 → 1,38
# |
# linux/arch/arm/boot/compressed/Makefile |
# |
# create a compressed vmlinuz image from the original vmlinux |
# |
# With this config, max compressed image size = 640k |
# Uncompressed image size = 1.3M (text+data) |
|
|
HEAD = head.o |
SYSTEM = $(TOPDIR)/vmlinux |
OBJS = $(HEAD) misc.o $(COMPRESSED_EXTRA) |
|
CFLAGS = -O2 -DSTDC_HEADERS $(CFLAGS_PROC) |
ARFLAGS = rc |
|
all: vmlinux |
|
vmlinux: piggy.o $(OBJS) |
$(LD) $(ZLINKFLAGS) -o vmlinux $(OBJS) piggy.o |
|
head.o: head.S |
$(CC) -traditional -DLOADADDR=$(ZRELADDR) -c head.S |
|
piggy.o: $(SYSTEM) xtract piggyback |
./xtract $(SYSTEM) | gzip -9 | ./piggyback > $@ |
|
# rules for extracting & piggybacking the kernel |
|
xtract: xtract.c |
$(HOSTCC) $(HOSTCFLAGS) -o xtract xtract.c |
|
piggyback: piggyback.c |
$(HOSTCC) $(HOSTCFLAGS) -o piggyback piggyback.c |
|
clean: |
rm -f xtract piggyback vmlinux core |
|