Add realtek target files

Signed-off-by: Roman Yeryomin <roman@advem.lv>

1 files changed, 387 insertions, 0 deletions

diff --git a/target/linux/realtek/files/rtkload/misc.c b/target/linux/realtek/files/rtkload/misc.c
new file mode 100644
index 000000000..11bc20830
--- /dev/null
+++ b/target/linux/realtek/files/rtkload/misc.c
@@ -0,0 +1,387 @@
+/*
+ * 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
+ *
+ * Modified for ARM Linux by Russell King
+ *
+ * Nicolas Pitre <nico@visuaide.com>  1999/04/14 :
+ *  For this code to run directly from Flash, all constant variables must
+ *  be marked with 'const' and all other variables initialized at run-time 
+ *  only.  This way all non constant variables will end up in the bss segment,
+ *  which should point to addresses in RAM and cleared to 0 on start.
+ *  This allows for a much quicker boot time.
+ *
+ * Stolen for mips loader to handle decompression by Jay Carlson
+ * <nop@nop.com> 2000/04/17
+ */
+#include <linux/autoconf.h>
+
+// david ------------------
+#ifdef BZ2_COMPRESS
+#define  __DO_QUIET__
+#endif
+//-------------------------
+
+extern unsigned long kernelStartAddr;
+unsigned int __machine_arch_type;
+
+#ifndef __DO_QUIET__
+#define puts prom_printf
+#else
+#define puts
+#endif
+#define arch_decomp_wdog()
+#define arch_decomp_setup()
+#define proc_decomp_setup()  /* this is where cache flushing, clock, etc lived */
+
+#define memzero(d, count) (memset((d), 0, (count)))
+
+#define __ptr_t void *
+#define NULL ((void *) 0)
+
+typedef unsigned long  __u32;
+#define ___swab32(x) \
+ 	({ \
+		__u32 __x = (x); \
+		((__u32)( \
+		(((__u32)(__x) & (__u32)0x000000ffUL) << 24) | \
+			(((__u32)(__x) & (__u32)0x0000ff00UL) <<  8) | \
+			(((__u32)(__x) & (__u32)0x00ff0000UL) >>  8) | \
+			(((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); \
+	})
+
+#define le32_to_cpu(x) ___swab32(x)
+
+
+/*
+ * gzip declarations
+ */
+#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 __vmlinux_start[];
+extern char __vmlinux_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" */
+/* #include "../lib/inflate.c"*/
+
+// david ----------------
+//#include <inflate.c>
+
+#ifndef BZ2_COMPRESS
+#include "inflate.c"
+#else
+#include "../lib/bzip2_inflate.c"
+#endif
+//----------------------
+
+#ifdef CONFIG_RTL8197B_PANA
+int is_vmlinux_checksum_ok(void)
+{
+	unsigned long sum = 0;
+	//unsigned long *buf = (unsigned long *)(((long)__vmlinux_start)+4);
+	//unsigned long image_len = (unsigned long)(__vmlinux_end -__vmlinux_start-4);
+	unsigned long *buf = (unsigned long *)(((long)__vmlinux_start)+8);
+	unsigned long image_len = (unsigned long)(__vmlinux_end -__vmlinux_start-8);
+	
+	for (; ((unsigned long)buf)<((unsigned long)__vmlinux_end);  buf++)
+		sum += *buf;
+	
+	return ((sum == 0) ? 1 : 0);
+}
+#endif
+
+#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)
+{
+	arch_decomp_wdog();
+	*ptr = (void *) free_mem_ptr;
+}
+
+static void gzip_release(void **ptr)
+{
+	arch_decomp_wdog();
+	free_mem_ptr = (long) *ptr;
+}
+#else
+static void gzip_mark(void **ptr)
+{
+}
+
+static void gzip_release(void **ptr)
+{
+}
+#endif
+
+// david
+#ifndef BZ2_COMPRESS
+/* ===========================================================================
+ * Fill the input buffer. This is called only when the buffer is empty
+ * and at least one byte is really needed.
+ */
+int fill_inbuf(void)
+{
+	if (insize != 0)
+		error("ran out of input data\n");
+
+	inbuf = __vmlinux_start;
+	insize = &__vmlinux_end[0] - &__vmlinux_start[0];
+
+	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(void)
+{
+	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;
+	//puts(".");
+}
+#endif // BZ2_COMPRESS, david
+
+
+static void error(char *x)
+{
+	int ptr;
+
+	puts("\n\n");
+	puts(x);
+	puts("\n\n -- System halted");
+
+	while(1);	/* Halt */
+}
+
+#ifndef STANDALONE_DEBUG
+
+ulg
+decompress_kernel(ulg output_start, ulg free_mem_ptr_p, ulg free_mem_ptr_end_p,
+		  int arch_id)
+{
+	output_data		= (uch *)output_start;	/* Points to kernel start */
+	free_mem_ptr		= free_mem_ptr_p;
+	free_mem_ptr_end	= free_mem_ptr_end_p;
+	__machine_arch_type	= arch_id;
+
+	proc_decomp_setup();
+	arch_decomp_setup();
+
+// david
+//	makecrc();
+	puts("Uncompressing Linux...");
+// david ---------------------------------
+// 	gunzip();
+#ifdef LZMA_COMPRESS
+{
+	#include "LzmaDecode.h"
+	
+	unsigned char *startBuf=__vmlinux_start;
+	unsigned char *outBuf = (unsigned char *)output_start;
+	unsigned int inLen=__vmlinux_end - __vmlinux_start;	
+
+	SizeT compressedSize;
+	unsigned char *inStream; 
+	UInt32 outSize = 0;
+	UInt32 outSizeHigh = 0;	
+	SizeT outSizeFull;
+	int res;
+    SizeT inProcessed;
+    SizeT outProcessed;
+	char tmpbuf[100];
+	CLzmaDecoderState state;  /* it's about 24-80 bytes structure, if int is 32-bit */
+	unsigned char properties[LZMA_PROPERTIES_SIZE];
+	
+//#ifdef CONFIG_RTL8197B_PANA	
+//	unsigned long pending_len = *((unsigned long *)__vmlinux_start);
+//	startBuf += 4;
+//	inLen -= (4+pending_len);
+//#else
+	unsigned long pending_len = *((unsigned long *)__vmlinux_start);
+	kernelStartAddr = *((unsigned long *)(startBuf+4));
+	startBuf += 8;
+	inLen -= (8+pending_len);
+//#endif
+
+	compressedSize = (SizeT)(inLen - (LZMA_PROPERTIES_SIZE + 8));
+
+	memcpy(properties, startBuf, sizeof(properties));
+	startBuf += sizeof(properties);
+
+	memcpy((char *)&outSize, startBuf, 4);
+	outSize = le32_to_cpu(outSize);	
+
+	memcpy((char *)&outSizeHigh, startBuf+4, 4);	
+	outSizeHigh = le32_to_cpu(outSizeHigh);
+
+    outSizeFull = (SizeT)outSize;
+    if (outSizeHigh != 0 || (UInt32)(SizeT)outSize != outSize) {
+		puts("LZMA: Too big uncompressed stream\n");
+		return 0;
+   	}	
+	startBuf += 8;    
+	
+	/* Decode LZMA properties and allocate memory */  
+	if (LzmaDecodeProperties(&state.Properties, properties, LZMA_PROPERTIES_SIZE) != LZMA_RESULT_OK) {
+		puts("LZMA: Incorrect stream properties\n");
+		return 0;
+	}
+	state.Probs = (CProb *)malloc(LzmaGetNumProbs(&state.Properties) * sizeof(CProb));
+    
+    res = LzmaDecode(&state, startBuf, compressedSize, &inProcessed,
+					      outBuf, outSizeFull, &outProcessed);    
+    if (res != 0) {
+#ifndef __DO_QUIET__
+      sprintf(tmpbuf, "LZMA: Decoding error = %d\n", res);
+#else
+      memcpy(tmpbuf, "LZMA: Decoding error =  ", 23);
+      memcpy((tmpbuf+23), &res, 4);
+#endif
+      puts(tmpbuf);
+      return 0;
+    }    
+}
+
+#else // !LZMA_COMPRESS
+#ifndef BZ2_COMPRESS
+	makecrc();
+	gunzip();
+#else
+
+// david ------------
+{
+        unsigned char *startBuf=__vmlinux_start;
+	unsigned char *outBuf = (unsigned char *)output_start;
+	unsigned int inLen=__vmlinux_end - __vmlinux_start;
+	int outLen=-1;
+
+	BZ2_bzBuffToBuffDecompress(outBuf, &outLen, startBuf, inLen, 0, 0);
+}
+#endif // BZ2_COMPRESS
+//----------------------------------------
+
+#endif // LZMA_COMPRESS
+
+	puts(" done, booting the kernel.\n");
+	return output_ptr;
+}
+#else
+
+char output_buffer[1500*1024];
+
+int main()
+{
+	output_data = output_buffer;
+
+	makecrc();
+	puts("Uncompressing Linux...");
+	gunzip();
+	puts("done.\n");
+	return 0;
+}
+#endif
+