add a new arm lzma kernel decompressor based on rewritten (and much more readable) unlzma code. backport to 2.6.28 as well. tested on ixp4xx and orion

SVN-Revision: 16939

3 files changed, 1361 insertions, 843 deletions

diff --git a/target/linux/generic-2.6/patches-2.6.28/960-arm_lzma_loader.patch b/target/linux/generic-2.6/patches-2.6.28/960-arm_lzma_loader.patch
new file mode 100644
index 0000000000..986c282713
--- /dev/null
+++ b/target/linux/generic-2.6/patches-2.6.28/960-arm_lzma_loader.patch
@@ -0,0 +1,719 @@
+--- a/arch/arm/boot/compressed/Makefile
++++ b/arch/arm/boot/compressed/Makefile
+@@ -67,7 +67,7 @@ endif
+ 
+ SEDFLAGS	= s/TEXT_START/$(ZTEXTADDR)/;s/BSS_START/$(ZBSSADDR)/
+ 
+-targets       := vmlinux vmlinux.lds piggy.gz piggy.o font.o font.c \
++targets       := vmlinux vmlinux.lds piggy.lzma piggy.o font.o font.c \
+ 		 head.o misc.o $(OBJS)
+ 
+ ifeq ($(CONFIG_FUNCTION_TRACER),y)
+@@ -100,10 +100,10 @@ $(obj)/vmlinux: $(obj)/vmlinux.lds $(obj
+ 	$(call if_changed,ld)
+ 	@:
+ 
+-$(obj)/piggy.gz: $(obj)/../Image FORCE
+-	$(call if_changed,gzip)
++$(obj)/piggy.lzma: $(obj)/../Image FORCE
++	$(call if_changed,lzma)
+ 
+-$(obj)/piggy.o:  $(obj)/piggy.gz FORCE
++$(obj)/piggy.o:  $(obj)/piggy.lzma FORCE
+ 
+ CFLAGS_font.o := -Dstatic=
+ 
+--- a/arch/arm/boot/compressed/misc.c
++++ b/arch/arm/boot/compressed/misc.c
+@@ -166,36 +166,10 @@ static inline __ptr_t memcpy(__ptr_t __d
+ 	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, */
++#define WSIZE 0x20000		/* Window size must be at least 128k, */
+ 				/* 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())
++static u8 window[WSIZE];	/* Sliding window buffer */
+ 
+ /* Diagnostic functions */
+ #ifdef DEBUG
+@@ -214,24 +188,21 @@ static unsigned outcnt;		/* bytes in out
+ #  define Tracecv(c,x)
+ #endif
+ 
+-static int  fill_inbuf(void);
+-static void flush_window(void);
+ static void error(char *m);
+ 
+ extern char input_data[];
+ extern char input_data_end[];
+ 
+-static uch *output_data;
+-static ulg output_ptr;
+-static ulg bytes_out;
++static unsigned long output_ptr;
++static unsigned long bytes_out;
+ 
+ static void error(char *m);
+ 
+ static void putstr(const char *);
+ 
+ extern int end;
+-static ulg free_mem_ptr;
+-static ulg free_mem_end_ptr;
++static unsigned long free_mem_ptr;
++static unsigned long free_mem_end_ptr;
+ 
+ #ifdef STANDALONE_DEBUG
+ #define NO_INFLATE_MALLOC
+@@ -239,50 +210,10 @@ static ulg free_mem_end_ptr;
+ 
+ #define ARCH_HAS_DECOMP_WDOG
+ 
+-#include "../../../../lib/inflate.c"
+-
+-/* ===========================================================================
+- * 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");
+-
+-	inbuf = input_data;
+-	insize = &input_data_end[0] - &input_data[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;
+-	putstr(".");
+-}
+-
+ #ifndef arch_error
+ #define arch_error(x)
+ #endif
++#include "unlzma.c"
+ 
+ static void error(char *x)
+ {
+@@ -297,20 +228,16 @@ static void error(char *x)
+ 
+ #ifndef STANDALONE_DEBUG
+ 
+-ulg
+-decompress_kernel(ulg output_start, ulg free_mem_ptr_p, ulg free_mem_ptr_end_p,
++unsigned long
++decompress_kernel(unsigned long output_start, unsigned long free_mem_ptr_p, unsigned long 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_end_ptr	= free_mem_ptr_end_p;
+ 	__machine_arch_type	= arch_id;
+ 
+ 	arch_decomp_setup();
+ 
+-	makecrc();
+ 	putstr("Uncompressing Linux...");
+-	gunzip();
++	output_ptr += unlzma((u8 *) output_start, input_data, window);
+ 	putstr(" done, booting the kernel.\n");
+ 	return output_ptr;
+ }
+@@ -320,11 +247,8 @@ char output_buffer[1500*1024];
+ 
+ int main()
+ {
+-	output_data = output_buffer;
+-
+-	makecrc();
+ 	putstr("Uncompressing Linux...");
+-	gunzip();
++	unlzma((u8 *) output_buffer, input_data, window);
+ 	putstr("done.\n");
+ 	return 0;
+ }
+--- a/arch/arm/boot/compressed/piggy.S
++++ b/arch/arm/boot/compressed/piggy.S
+@@ -1,6 +1,6 @@
+ 	.section .piggydata,#alloc
+ 	.globl	input_data
+ input_data:
+-	.incbin	"arch/arm/boot/compressed/piggy.gz"
++	.incbin	"arch/arm/boot/compressed/piggy.lzma"
+ 	.globl	input_data_end
+ input_data_end:
+--- /dev/null
++++ b/arch/arm/boot/compressed/unlzma.c
+@@ -0,0 +1,429 @@
++/*
++ * Copyright (c) 2009  Felix Fietkau <nbd@openwrt.org>
++ *
++ * 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,
++ * 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
++ *
++ * uncompress.c
++ */
++
++#include <linux/types.h>
++#include <asm/byteorder.h>
++#include "unlzma.h"
++
++struct unlzma_ctx {
++	const u8 *next_in;
++	u8 *next_out;
++	u8 *outbuf;
++
++	/* reader state */
++	u32 code;
++	u32 range;
++	u32 bound;
++
++	/* writer state */
++	u8 previous_byte;
++	ssize_t pos;
++
++	/* cstate */
++	int state;
++	u32 rep0, rep1, rep2, rep3;
++
++	void *workspace;
++} ctx;
++
++static int inbs = 0;
++static inline u8
++rc_read(void)
++{
++#if 0
++	if (unlikely(++inbs > 16 * 1024)) {
++		putstr(".");
++		inbs = 0;
++	}
++#endif
++	return *(ctx.next_in++);
++}
++
++
++static inline void
++rc_get_code(void)
++{
++	ctx.code = (ctx.code << 8) | rc_read();
++}
++
++static inline void
++rc_normalize(void)
++{
++	if (ctx.range < (1 << RC_TOP_BITS)) {
++		ctx.range <<= 8;
++		rc_get_code();
++	}
++}
++
++static inline int
++rc_is_bit_0(u16 *p)
++{
++	rc_normalize();
++	ctx.bound = *p * (ctx.range >> RC_MODEL_TOTAL_BITS);
++	return ctx.code < ctx.bound;
++}
++
++static inline void
++rc_update_bit_0(u16 *p)
++{
++	ctx.range = ctx.bound;
++	*p += ((1 << RC_MODEL_TOTAL_BITS) - *p) >> RC_MOVE_BITS;
++}
++
++static inline void
++rc_update_bit_1(u16 *p)
++{
++	ctx.range -= ctx.bound;
++	ctx.code -= ctx.bound;
++	*p -= *p >> RC_MOVE_BITS;
++}
++
++static inline bool
++rc_get_bit(u16 *p, int *symbol)
++{
++	if (rc_is_bit_0(p)) {
++		rc_update_bit_0(p);
++		*symbol *= 2;
++		return 0;
++	} else {
++		rc_update_bit_1(p);
++		*symbol = *symbol * 2 + 1;
++		return 1;
++	}
++}
++
++static inline int
++rc_direct_bit(void)
++{
++	rc_normalize();
++	ctx.range >>= 1;
++	if (ctx.code >= ctx.range) {
++		ctx.code -= ctx.range;
++		return 1;
++	}
++	return 0;
++}
++
++static inline void
++rc_bit_tree_decode(u16 *p, int num_levels, int *symbol)
++{
++	int i = num_levels;
++
++	*symbol = 1;
++	while (i--)
++		rc_get_bit(p + *symbol, symbol);
++	*symbol -= 1 << num_levels;
++}
++
++static inline u8
++peek_old_byte(u32 offs)
++{
++	u32 pos = ctx.pos - offs;
++	return ctx.outbuf[pos];
++}
++
++static inline void
++write_byte(u8 byte)
++{
++	ctx.previous_byte = byte;
++	*(ctx.next_out++) = byte;
++	ctx.pos++;
++}
++
++
++static inline void
++copy_byte(u32 offs)
++{
++	write_byte(peek_old_byte(offs));
++}
++
++static inline void
++copy_bytes(u32 rep0, int len)
++{
++	do {
++		copy_byte(rep0);
++		len--;
++	} while (len != 0);
++}
++
++static inline void
++process_bit0(u16 *p, int pos_state, u16 *prob,
++             int lc, u32 literal_pos_mask)
++{
++	int mi = 1;
++	rc_update_bit_0(prob);
++	prob = (p + LZMA_LITERAL +
++		(LZMA_LIT_SIZE
++		 * (((ctx.pos & literal_pos_mask) << lc)
++		    + (ctx.previous_byte >> (8 - lc))))
++		);
++
++	if (ctx.state >= LZMA_NUM_LIT_STATES) {
++		int match_byte = peek_old_byte(ctx.rep0);
++		do {
++			u16 bit;
++			u16 *prob_lit;
++
++			match_byte <<= 1;
++			bit = match_byte & 0x100;
++			prob_lit = prob + 0x100 + bit + mi;
++			if (rc_get_bit(prob_lit, &mi) != !!bit)
++				break;
++		} while (mi < 0x100);
++	}
++	while (mi < 0x100) {
++		u16 *prob_lit = prob + mi;
++		rc_get_bit(prob_lit, &mi);
++	}
++	write_byte(mi);
++	if (ctx.state < 4)
++		ctx.state = 0;
++	else if (ctx.state < 10)
++		ctx.state -= 3;
++	else
++		ctx.state -= 6;
++}
++
++static inline void
++process_bit1(u16 *p, int pos_state, u16 *prob)
++{
++	int offset;
++	u16 *prob_len;
++	int num_bits;
++	int len;
++
++	rc_update_bit_1(prob);
++	prob = p + LZMA_IS_REP + ctx.state;
++	if (rc_is_bit_0(prob)) {
++		rc_update_bit_0(prob);
++		ctx.rep3 = ctx.rep2;
++		ctx.rep2 = ctx.rep1;
++		ctx.rep1 = ctx.rep0;
++		ctx.state = ctx.state < LZMA_NUM_LIT_STATES ? 0 : 3;
++		prob = p + LZMA_LEN_CODER;
++	} else {
++		rc_update_bit_1(prob);
++		prob = p + LZMA_IS_REP_G0 + ctx.state;
++		if (rc_is_bit_0(prob)) {
++			rc_update_bit_0(prob);
++			prob = (p + LZMA_IS_REP_0_LONG
++				+ (ctx.state <<
++				   LZMA_NUM_POS_BITS_MAX) +
++				pos_state);
++			if (rc_is_bit_0(prob)) {
++				rc_update_bit_0(prob);
++
++				ctx.state = ctx.state < LZMA_NUM_LIT_STATES ?
++					9 : 11;
++				copy_byte(ctx.rep0);
++				return;
++			} else {
++				rc_update_bit_1(prob);
++			}
++		} else {
++			u32 distance;
++
++			rc_update_bit_1(prob);
++			prob = p + LZMA_IS_REP_G1 + ctx.state;
++			if (rc_is_bit_0(prob)) {
++				rc_update_bit_0(prob);
++				distance = ctx.rep1;
++			} else {
++				rc_update_bit_1(prob);
++				prob = p + LZMA_IS_REP_G2 + ctx.state;
++				if (rc_is_bit_0(prob)) {
++					rc_update_bit_0(prob);
++					distance = ctx.rep2;
++				} else {
++					rc_update_bit_1(prob);
++					distance = ctx.rep3;
++					ctx.rep3 = ctx.rep2;
++				}
++				ctx.rep2 = ctx.rep1;
++			}
++			ctx.rep1 = ctx.rep0;
++			ctx.rep0 = distance;
++		}
++		ctx.state = ctx.state < LZMA_NUM_LIT_STATES ? 8 : 11;
++		prob = p + LZMA_REP_LEN_CODER;
++	}
++
++	prob_len = prob + LZMA_LEN_CHOICE;
++	if (rc_is_bit_0(prob_len)) {
++		rc_update_bit_0(prob_len);
++		prob_len = (prob + LZMA_LEN_LOW
++			    + (pos_state <<
++			       LZMA_LEN_NUM_LOW_BITS));
++		offset = 0;
++		num_bits = LZMA_LEN_NUM_LOW_BITS;
++	} else {
++		rc_update_bit_1(prob_len);
++		prob_len = prob + LZMA_LEN_CHOICE_2;
++		if (rc_is_bit_0(prob_len)) {
++			rc_update_bit_0(prob_len);
++			prob_len = (prob + LZMA_LEN_MID
++				    + (pos_state <<
++				       LZMA_LEN_NUM_MID_BITS));
++			offset = 1 << LZMA_LEN_NUM_LOW_BITS;
++			num_bits = LZMA_LEN_NUM_MID_BITS;
++		} else {
++			rc_update_bit_1(prob_len);
++			prob_len = prob + LZMA_LEN_HIGH;
++			offset = ((1 << LZMA_LEN_NUM_LOW_BITS)
++				  + (1 << LZMA_LEN_NUM_MID_BITS));
++			num_bits = LZMA_LEN_NUM_HIGH_BITS;
++		}
++	}
++
++	rc_bit_tree_decode(prob_len, num_bits, &len);
++	len += offset;
++
++	if (ctx.state < 4) {
++		int pos_slot;
++
++		ctx.state += LZMA_NUM_LIT_STATES;
++		prob =
++			p + LZMA_POS_SLOT +
++			((len <
++			  LZMA_NUM_LEN_TO_POS_STATES ? len :
++			  LZMA_NUM_LEN_TO_POS_STATES - 1)
++			 << LZMA_NUM_POS_SLOT_BITS);
++		rc_bit_tree_decode(prob,
++				   LZMA_NUM_POS_SLOT_BITS,
++				   &pos_slot);
++		if (pos_slot >= LZMA_START_POS_MODEL_INDEX) {
++			int i, mi;
++			num_bits = (pos_slot >> 1) - 1;
++			ctx.rep0 = 2 | (pos_slot & 1);
++			if (pos_slot < LZMA_END_POS_MODEL_INDEX) {
++				ctx.rep0 <<= num_bits;
++				prob = p + LZMA_SPEC_POS +
++					ctx.rep0 - pos_slot - 1;
++			} else {
++				num_bits -= LZMA_NUM_ALIGN_BITS;
++				while (num_bits--)
++					ctx.rep0 = (ctx.rep0 << 1) |
++						rc_direct_bit();
++				prob = p + LZMA_ALIGN;
++				ctx.rep0 <<= LZMA_NUM_ALIGN_BITS;
++				num_bits = LZMA_NUM_ALIGN_BITS;
++			}
++			i = 1;
++			mi = 1;
++			while (num_bits--) {
++				if (rc_get_bit(prob + mi, &mi))
++					ctx.rep0 |= i;
++				i <<= 1;
++			}
++		} else
++			ctx.rep0 = pos_slot;
++		if (++(ctx.rep0) == 0)
++			return;
++	}
++
++	len += LZMA_MATCH_MIN_LEN;
++
++	copy_bytes(ctx.rep0, len);
++}
++
++
++static int
++do_unlzma(void)
++{
++	u8 hdr_buf[sizeof(struct lzma_header)];
++	struct lzma_header *header = (struct lzma_header *)hdr_buf;
++	u32 pos_state_mask;
++	u32 literal_pos_mask;
++	int lc, pb, lp;
++	int num_probs;
++	int i, mi;
++	u16 *p;
++
++	for (i = 0; i < sizeof(struct lzma_header); i++) {
++		hdr_buf[i] = rc_read();
++	}
++
++	ctx.pos = 0;
++	ctx.state = 0;
++	ctx.rep0 = ctx.rep1 = ctx.rep2 = ctx.rep3 = 1;
++
++	ctx.previous_byte = 0;
++	ctx.code = 0;
++	ctx.range = 0xFFFFFFFF;
++
++	if (header->pos >= (9 * 5 * 5))
++		return -1;
++
++	mi = 0;
++	lc = header->pos;
++	while (lc >= 9) {
++		mi++;
++		lc -= 9;
++	}
++	pb = 0;
++	lp = mi;
++	while (lp >= 5) {
++		pb++;
++		lp -= 5;
++	}
++	pos_state_mask = (1 << pb) - 1;
++	literal_pos_mask = (1 << lp) - 1;
++
++	p = (u16 *) ctx.workspace;
++	if (!p)
++		return -1;
++
++	num_probs = LZMA_LITERAL + (LZMA_LIT_SIZE << (lc + lp));
++	for (i = 0; i < num_probs; i++)
++		p[i] = (1 << RC_MODEL_TOTAL_BITS) >> 1;
++
++	for (i = 0; i < 5; i++)
++		rc_get_code();
++
++	while (1) {
++		int pos_state =	ctx.pos & pos_state_mask;
++		u16 *prob = p + LZMA_IS_MATCH +
++			(ctx.state << LZMA_NUM_POS_BITS_MAX) + pos_state;
++		if (rc_is_bit_0(prob))
++			process_bit0(p, pos_state, prob,
++				     lc, literal_pos_mask);
++		else {
++			process_bit1(p, pos_state, prob);
++			if (ctx.rep0 == 0)
++				break;
++		}
++	}
++
++	return ctx.pos;
++}
++
++
++static int unlzma(unsigned char *dest, const unsigned char *src, unsigned char *workspace)
++{
++	memset(&ctx, 0, sizeof(ctx));
++	ctx.outbuf = dest;
++	ctx.next_in = src;
++	ctx.next_out = dest;
++	ctx.workspace = workspace;
++
++	return do_unlzma();
++}
++
++
+--- /dev/null
++++ b/arch/arm/boot/compressed/unlzma.h
+@@ -0,0 +1,81 @@
++/* LZMA uncompresion module for pcomp
++ * Copyright (C) 2009  Felix Fietkau <nbd@openwrt.org>
++ *
++ * Based on:
++ *  Initial Linux kernel adaptation
++ *  Copyright (C) 2006  Alain < alain@knaff.lu >
++ *
++ *  Based on small lzma deflate implementation/Small range coder
++ *  implementation for lzma.
++ *  Copyright (C) 2006  Aurelien Jacobs < aurel@gnuage.org >
++ *
++ *  Based on LzmaDecode.c from the LZMA SDK 4.22 (http://www.7-zip.org/)
++ *  Copyright (C) 1999-2005  Igor Pavlov
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 as published
++ * by the Free Software Foundation.
++ */
++#ifndef __UNLZMA_H
++#define __UNLZMA_H
++
++struct lzma_header {
++	__u8 pos;
++	__le32 dict_size;
++	__le64 uncompr_size;
++} __attribute__ ((packed));
++
++
++#define RC_TOP_BITS 24
++#define RC_MOVE_BITS 5
++#define RC_MODEL_TOTAL_BITS 11
++
++#define LZMA_BASE_SIZE 1846
++#define LZMA_LIT_SIZE 768
++
++#define LZMA_NUM_POS_BITS_MAX 4
++
++#define LZMA_LEN_NUM_LOW_BITS 3
++#define LZMA_LEN_NUM_MID_BITS 3
++#define LZMA_LEN_NUM_HIGH_BITS 8
++
++#define LZMA_LEN_CHOICE 0
++#define LZMA_LEN_CHOICE_2 (LZMA_LEN_CHOICE + 1)
++#define LZMA_LEN_LOW (LZMA_LEN_CHOICE_2 + 1)
++#define LZMA_LEN_MID (LZMA_LEN_LOW \
++		      + (1 << (LZMA_NUM_POS_BITS_MAX + LZMA_LEN_NUM_LOW_BITS)))
++#define LZMA_LEN_HIGH (LZMA_LEN_MID \
++		       +(1 << (LZMA_NUM_POS_BITS_MAX + LZMA_LEN_NUM_MID_BITS)))
++#define LZMA_NUM_LEN_PROBS (LZMA_LEN_HIGH + (1 << LZMA_LEN_NUM_HIGH_BITS))
++
++#define LZMA_NUM_STATES 12
++#define LZMA_NUM_LIT_STATES 7
++
++#define LZMA_START_POS_MODEL_INDEX 4
++#define LZMA_END_POS_MODEL_INDEX 14
++#define LZMA_NUM_FULL_DISTANCES (1 << (LZMA_END_POS_MODEL_INDEX >> 1))
++
++#define LZMA_NUM_POS_SLOT_BITS 6
++#define LZMA_NUM_LEN_TO_POS_STATES 4
++
++#define LZMA_NUM_ALIGN_BITS 4
++
++#define LZMA_MATCH_MIN_LEN 2
++
++#define LZMA_IS_MATCH 0
++#define LZMA_IS_REP (LZMA_IS_MATCH + (LZMA_NUM_STATES << LZMA_NUM_POS_BITS_MAX))
++#define LZMA_IS_REP_G0 (LZMA_IS_REP + LZMA_NUM_STATES)
++#define LZMA_IS_REP_G1 (LZMA_IS_REP_G0 + LZMA_NUM_STATES)
++#define LZMA_IS_REP_G2 (LZMA_IS_REP_G1 + LZMA_NUM_STATES)
++#define LZMA_IS_REP_0_LONG (LZMA_IS_REP_G2 + LZMA_NUM_STATES)
++#define LZMA_POS_SLOT (LZMA_IS_REP_0_LONG \
++		       + (LZMA_NUM_STATES << LZMA_NUM_POS_BITS_MAX))
++#define LZMA_SPEC_POS (LZMA_POS_SLOT \
++		       +(LZMA_NUM_LEN_TO_POS_STATES << LZMA_NUM_POS_SLOT_BITS))
++#define LZMA_ALIGN (LZMA_SPEC_POS \
++		    + LZMA_NUM_FULL_DISTANCES - LZMA_END_POS_MODEL_INDEX)
++#define LZMA_LEN_CODER (LZMA_ALIGN + (1 << LZMA_NUM_ALIGN_BITS))
++#define LZMA_REP_LEN_CODER (LZMA_LEN_CODER + LZMA_NUM_LEN_PROBS)
++#define LZMA_LITERAL (LZMA_REP_LEN_CODER + LZMA_NUM_LEN_PROBS)
++
++#endif
+--- a/scripts/Makefile.lib
++++ b/scripts/Makefile.lib
+@@ -182,4 +182,6 @@ cmd_objcopy = $(OBJCOPY) $(OBJCOPYFLAGS)
+ quiet_cmd_gzip = GZIP    $@
+ cmd_gzip = gzip -f -9 < $< > $@
+ 
++quiet_cmd_lzma = LZMA    $@
++cmd_lzma = lzma e $< $@ -lc1 -lp2 -pb2 -eos
+ 
diff --git a/target/linux/generic-2.6/patches-2.6.30/960-arm_lzma_loader.patch b/target/linux/generic-2.6/patches-2.6.30/960-arm_lzma_loader.patch
index 7995b5e515..f159898ba8 100644
--- a/target/linux/generic-2.6/patches-2.6.30/960-arm_lzma_loader.patch
+++ b/target/linux/generic-2.6/patches-2.6.30/960-arm_lzma_loader.patch
@@ -1,741 +1,5 @@
---- /dev/null
-+++ b/arch/arm/boot/compressed/LzmaDecode.c
-@@ -0,0 +1,590 @@
-+/*
-+  LzmaDecode.c
-+  LZMA Decoder (optimized for Speed version)
-+  
-+  LZMA SDK 4.22 Copyright (c) 1999-2005 Igor Pavlov (2005-06-10)
-+  http://www.7-zip.org/
-+
-+  LZMA SDK is licensed under two licenses:
-+  1) GNU Lesser General Public License (GNU LGPL)
-+  2) Common Public License (CPL)
-+  It means that you can select one of these two licenses and 
-+  follow rules of that license.
-+
-+  SPECIAL EXCEPTION:
-+  Igor Pavlov, as the author of this Code, expressly permits you to 
-+  statically or dynamically link your Code (or bind by name) to the 
-+  interfaces of this file without subjecting your linked Code to the 
-+  terms of the CPL or GNU LGPL. Any modifications or additions 
-+  to this file, however, are subject to the LGPL or CPL terms.
-+*/
-+
-+#include "LzmaDecode.h"
-+
-+#ifndef Byte
-+#define Byte unsigned char
-+#endif
-+
-+#define kNumTopBits 24
-+#define kTopValue ((UInt32)1 << kNumTopBits)
-+
-+#define kNumBitModelTotalBits 11
-+#define kBitModelTotal (1 << kNumBitModelTotalBits)
-+#define kNumMoveBits 5
-+
-+#define RC_READ_BYTE (*Buffer++)
-+
-+#define RC_INIT2 Code = 0; Range = 0xFFFFFFFF; \
-+  { int i; for(i = 0; i < 5; i++) { RC_TEST; Code = (Code << 8) | RC_READ_BYTE; }}
-+
-+#ifdef _LZMA_IN_CB
-+
-+#define RC_TEST { if (Buffer == BufferLim) \
-+  { SizeT size; int result = InCallback->Read(InCallback, &Buffer, &size); if (result != LZMA_RESULT_OK) return result; \
-+  BufferLim = Buffer + size; if (size == 0) return LZMA_RESULT_DATA_ERROR; }}
-+
-+#define RC_INIT Buffer = BufferLim = 0; RC_INIT2
-+
-+#else
-+
-+#define RC_TEST { if (Buffer == BufferLim) return LZMA_RESULT_DATA_ERROR; }
-+
-+#define RC_INIT(buffer, bufferSize) Buffer = buffer; BufferLim = buffer + bufferSize; RC_INIT2
-+ 
-+#endif
-+
-+#define RC_NORMALIZE if (Range < kTopValue) { RC_TEST; Range <<= 8; Code = (Code << 8) | RC_READ_BYTE; }
-+
-+#define IfBit0(p) RC_NORMALIZE; bound = (Range >> kNumBitModelTotalBits) * *(p); if (Code < bound)
-+#define UpdateBit0(p) Range = bound; *(p) += (kBitModelTotal - *(p)) >> kNumMoveBits;
-+#define UpdateBit1(p) Range -= bound; Code -= bound; *(p) -= (*(p)) >> kNumMoveBits;
-+
-+#define RC_GET_BIT2(p, mi, A0, A1) IfBit0(p) \
-+  { UpdateBit0(p); mi <<= 1; A0; } else \
-+  { UpdateBit1(p); mi = (mi + mi) + 1; A1; } 
-+  
-+#define RC_GET_BIT(p, mi) RC_GET_BIT2(p, mi, ; , ;)               
-+
-+#define RangeDecoderBitTreeDecode(probs, numLevels, res) \
-+  { int i = numLevels; res = 1; \
-+  do { CProb *p = probs + res; RC_GET_BIT(p, res) } while(--i != 0); \
-+  res -= (1 << numLevels); }
-+
-+
-+#define kNumPosBitsMax 4
-+#define kNumPosStatesMax (1 << kNumPosBitsMax)
-+
-+#define kLenNumLowBits 3
-+#define kLenNumLowSymbols (1 << kLenNumLowBits)
-+#define kLenNumMidBits 3
-+#define kLenNumMidSymbols (1 << kLenNumMidBits)
-+#define kLenNumHighBits 8
-+#define kLenNumHighSymbols (1 << kLenNumHighBits)
-+
-+#define LenChoice 0
-+#define LenChoice2 (LenChoice + 1)
-+#define LenLow (LenChoice2 + 1)
-+#define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits))
-+#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits))
-+#define kNumLenProbs (LenHigh + kLenNumHighSymbols) 
-+
-+
-+#define kNumStates 12
-+#define kNumLitStates 7
-+
-+#define kStartPosModelIndex 4
-+#define kEndPosModelIndex 14
-+#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
-+
-+#define kNumPosSlotBits 6
-+#define kNumLenToPosStates 4
-+
-+#define kNumAlignBits 4
-+#define kAlignTableSize (1 << kNumAlignBits)
-+
-+#define kMatchMinLen 2
-+
-+#define IsMatch 0
-+#define IsRep (IsMatch + (kNumStates << kNumPosBitsMax))
-+#define IsRepG0 (IsRep + kNumStates)
-+#define IsRepG1 (IsRepG0 + kNumStates)
-+#define IsRepG2 (IsRepG1 + kNumStates)
-+#define IsRep0Long (IsRepG2 + kNumStates)
-+#define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax))
-+#define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))
-+#define Align (SpecPos + kNumFullDistances - kEndPosModelIndex)
-+#define LenCoder (Align + kAlignTableSize)
-+#define RepLenCoder (LenCoder + kNumLenProbs)
-+#define Literal (RepLenCoder + kNumLenProbs)
-+
-+#if Literal != LZMA_BASE_SIZE
-+StopCompilingDueBUG
-+#endif
-+
-+#if 0
-+int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size)
-+{
-+  unsigned char prop0;
-+  if (size < LZMA_PROPERTIES_SIZE)
-+    return LZMA_RESULT_DATA_ERROR;
-+  prop0 = propsData[0];
-+  if (prop0 >= (9 * 5 * 5))
-+    return LZMA_RESULT_DATA_ERROR;
-+  {
-+    for (propsRes->pb = 0; prop0 >= (9 * 5); propsRes->pb++, prop0 -= (9 * 5));
-+    for (propsRes->lp = 0; prop0 >= 9; propsRes->lp++, prop0 -= 9);
-+    propsRes->lc = prop0;
-+    /*
-+    unsigned char remainder = (unsigned char)(prop0 / 9);
-+    propsRes->lc = prop0 % 9;
-+    propsRes->pb = remainder / 5;
-+    propsRes->lp = remainder % 5;
-+    */
-+  }
-+
-+  #ifdef _LZMA_OUT_READ
-+  {
-+    int i;
-+    propsRes->DictionarySize = 0;
-+    for (i = 0; i < 4; i++)
-+      propsRes->DictionarySize += (UInt32)(propsData[1 + i]) << (i * 8);
-+    if (propsRes->DictionarySize == 0)
-+      propsRes->DictionarySize = 1;
-+  }
-+  #endif
-+  return LZMA_RESULT_OK;
-+}
-+#endif
-+
-+#define kLzmaStreamWasFinishedId (-1)
-+
-+int LzmaDecode(CLzmaDecoderState *vs,
-+    #ifdef _LZMA_IN_CB
-+    ILzmaInCallback *InCallback,
-+    #else
-+    const unsigned char *inStream, SizeT inSize, SizeT *inSizeProcessed,
-+    #endif
-+    unsigned char *outStream, SizeT outSize, SizeT *outSizeProcessed)
-+{
-+  CProb *p = vs->Probs;
-+  SizeT nowPos = 0;
-+  Byte previousByte = 0;
-+  UInt32 posStateMask = (1 << (vs->Properties.pb)) - 1;
-+  UInt32 literalPosMask = (1 << (vs->Properties.lp)) - 1;
-+  int lc = vs->Properties.lc;
-+
-+  #ifdef _LZMA_OUT_READ
-+  
-+  UInt32 Range = vs->Range;
-+  UInt32 Code = vs->Code;
-+  #ifdef _LZMA_IN_CB
-+  const Byte *Buffer = vs->Buffer;
-+  const Byte *BufferLim = vs->BufferLim;
-+  #else
-+  const Byte *Buffer = inStream;
-+  const Byte *BufferLim = inStream + inSize;
-+  #endif
-+  int state = vs->State;
-+  UInt32 rep0 = vs->Reps[0], rep1 = vs->Reps[1], rep2 = vs->Reps[2], rep3 = vs->Reps[3];
-+  int len = vs->RemainLen;
-+  UInt32 globalPos = vs->GlobalPos;
-+  UInt32 distanceLimit = vs->DistanceLimit;
-+
-+  Byte *dictionary = vs->Dictionary;
-+  UInt32 dictionarySize = vs->Properties.DictionarySize;
-+  UInt32 dictionaryPos = vs->DictionaryPos;
-+
-+  Byte tempDictionary[4];
-+
-+  #ifndef _LZMA_IN_CB
-+  *inSizeProcessed = 0;
-+  #endif
-+  *outSizeProcessed = 0;
-+  if (len == kLzmaStreamWasFinishedId)
-+    return LZMA_RESULT_OK;
-+
-+  if (dictionarySize == 0)
-+  {
-+    dictionary = tempDictionary;
-+    dictionarySize = 1;
-+    tempDictionary[0] = vs->TempDictionary[0];
-+  }
-+
-+  if (len == kLzmaNeedInitId)
-+  {
-+    {
-+      UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp));
-+      UInt32 i;
-+      for (i = 0; i < numProbs; i++)
-+        p[i] = kBitModelTotal >> 1; 
-+      rep0 = rep1 = rep2 = rep3 = 1;
-+      state = 0;
-+      globalPos = 0;
-+      distanceLimit = 0;
-+      dictionaryPos = 0;
-+      dictionary[dictionarySize - 1] = 0;
-+      #ifdef _LZMA_IN_CB
-+      RC_INIT;
-+      #else
-+      RC_INIT(inStream, inSize);
-+      #endif
-+    }
-+    len = 0;
-+  }
-+  while(len != 0 && nowPos < outSize)
-+  {
-+    UInt32 pos = dictionaryPos - rep0;
-+    if (pos >= dictionarySize)
-+      pos += dictionarySize;
-+    outStream[nowPos++] = dictionary[dictionaryPos] = dictionary[pos];
-+    if (++dictionaryPos == dictionarySize)
-+      dictionaryPos = 0;
-+    len--;
-+  }
-+  if (dictionaryPos == 0)
-+    previousByte = dictionary[dictionarySize - 1];
-+  else
-+    previousByte = dictionary[dictionaryPos - 1];
-+
-+  #else /* if !_LZMA_OUT_READ */
-+
-+  int state = 0;
-+  UInt32 rep0 = 1, rep1 = 1, rep2 = 1, rep3 = 1;
-+  int len = 0;
-+  const Byte *Buffer;
-+  const Byte *BufferLim;
-+  UInt32 Range;
-+  UInt32 Code;
-+
-+  #ifndef _LZMA_IN_CB
-+  *inSizeProcessed = 0;
-+  #endif
-+  *outSizeProcessed = 0;
-+
-+  {
-+    UInt32 i;
-+    UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp));
-+    for (i = 0; i < numProbs; i++)
-+      p[i] = kBitModelTotal >> 1;
-+  }
-+  
-+  #ifdef _LZMA_IN_CB
-+  RC_INIT;
-+  #else
-+  RC_INIT(inStream, inSize);
-+  #endif
-+
-+  #endif /* _LZMA_OUT_READ */
-+
-+  while(nowPos < outSize)
-+  {
-+    CProb *prob;
-+    UInt32 bound;
-+    int posState = (int)(
-+        (nowPos 
-+        #ifdef _LZMA_OUT_READ
-+        + globalPos
-+        #endif
-+        )
-+        & posStateMask);
-+
-+    prob = p + IsMatch + (state << kNumPosBitsMax) + posState;
-+    IfBit0(prob)
-+    {
-+      int symbol = 1;
-+      UpdateBit0(prob)
-+      prob = p + Literal + (LZMA_LIT_SIZE * 
-+        (((
-+        (nowPos 
-+        #ifdef _LZMA_OUT_READ
-+        + globalPos
-+        #endif
-+        )
-+        & literalPosMask) << lc) + (previousByte >> (8 - lc))));
-+
-+      if (state >= kNumLitStates)
-+      {
-+        int matchByte;
-+        #ifdef _LZMA_OUT_READ
-+        UInt32 pos = dictionaryPos - rep0;
-+        if (pos >= dictionarySize)
-+          pos += dictionarySize;
-+        matchByte = dictionary[pos];
-+        #else
-+        matchByte = outStream[nowPos - rep0];
-+        #endif
-+        do
-+        {
-+          int bit;
-+          CProb *probLit;
-+          matchByte <<= 1;
-+          bit = (matchByte & 0x100);
-+          probLit = prob + 0x100 + bit + symbol;
-+          RC_GET_BIT2(probLit, symbol, if (bit != 0) break, if (bit == 0) break)
-+        }
-+        while (symbol < 0x100);
-+      }
-+      while (symbol < 0x100)
-+      {
-+        CProb *probLit = prob + symbol;
-+        RC_GET_BIT(probLit, symbol)
-+      }
-+      previousByte = (Byte)symbol;
-+
-+      outStream[nowPos++] = previousByte;
-+      #ifdef _LZMA_OUT_READ
-+      if (distanceLimit < dictionarySize)
-+        distanceLimit++;
-+
-+      dictionary[dictionaryPos] = previousByte;
-+      if (++dictionaryPos == dictionarySize)
-+        dictionaryPos = 0;
-+      #endif
-+      if (state < 4) state = 0;
-+      else if (state < 10) state -= 3;
-+      else state -= 6;
-+    }
-+    else             
-+    {
-+      UpdateBit1(prob);
-+      prob = p + IsRep + state;
-+      IfBit0(prob)
-+      {
-+        UpdateBit0(prob);
-+        rep3 = rep2;
-+        rep2 = rep1;
-+        rep1 = rep0;
-+        state = state < kNumLitStates ? 0 : 3;
-+        prob = p + LenCoder;
-+      }
-+      else
-+      {
-+        UpdateBit1(prob);
-+        prob = p + IsRepG0 + state;
-+        IfBit0(prob)
-+        {
-+          UpdateBit0(prob);
-+          prob = p + IsRep0Long + (state << kNumPosBitsMax) + posState;
-+          IfBit0(prob)
-+          {
-+            #ifdef _LZMA_OUT_READ
-+            UInt32 pos;
-+            #endif
-+            UpdateBit0(prob);
-+            
-+            #ifdef _LZMA_OUT_READ
-+            if (distanceLimit == 0)
-+            #else
-+            if (nowPos == 0)
-+            #endif
-+              return LZMA_RESULT_DATA_ERROR;
-+            
-+            state = state < kNumLitStates ? 9 : 11;
-+            #ifdef _LZMA_OUT_READ
-+            pos = dictionaryPos - rep0;
-+            if (pos >= dictionarySize)
-+              pos += dictionarySize;
-+            previousByte = dictionary[pos];
-+            dictionary[dictionaryPos] = previousByte;
-+            if (++dictionaryPos == dictionarySize)
-+              dictionaryPos = 0;
-+            #else
-+            previousByte = outStream[nowPos - rep0];
-+            #endif
-+            outStream[nowPos++] = previousByte;
-+            #ifdef _LZMA_OUT_READ
-+            if (distanceLimit < dictionarySize)
-+              distanceLimit++;
-+            #endif
-+
-+            continue;
-+          }
-+          else
-+          {
-+            UpdateBit1(prob);
-+          }
-+        }
-+        else
-+        {
-+          UInt32 distance;
-+          UpdateBit1(prob);
-+          prob = p + IsRepG1 + state;
-+          IfBit0(prob)
-+          {
-+            UpdateBit0(prob);
-+            distance = rep1;
-+          }
-+          else 
-+          {
-+            UpdateBit1(prob);
-+            prob = p + IsRepG2 + state;
-+            IfBit0(prob)
-+            {
-+              UpdateBit0(prob);
-+              distance = rep2;
-+            }
-+            else
-+            {
-+              UpdateBit1(prob);
-+              distance = rep3;
-+              rep3 = rep2;
-+            }
-+            rep2 = rep1;
-+          }
-+          rep1 = rep0;
-+          rep0 = distance;
-+        }
-+        state = state < kNumLitStates ? 8 : 11;
-+        prob = p + RepLenCoder;
-+      }
-+      {
-+        int numBits, offset;
-+        CProb *probLen = prob + LenChoice;
-+        IfBit0(probLen)
-+        {
-+          UpdateBit0(probLen);
-+          probLen = prob + LenLow + (posState << kLenNumLowBits);
-+          offset = 0;
-+          numBits = kLenNumLowBits;
-+        }
-+        else
-+        {
-+          UpdateBit1(probLen);
-+          probLen = prob + LenChoice2;
-+          IfBit0(probLen)
-+          {
-+            UpdateBit0(probLen);
-+            probLen = prob + LenMid + (posState << kLenNumMidBits);
-+            offset = kLenNumLowSymbols;
-+            numBits = kLenNumMidBits;
-+          }
-+          else
-+          {
-+            UpdateBit1(probLen);
-+            probLen = prob + LenHigh;
-+            offset = kLenNumLowSymbols + kLenNumMidSymbols;
-+            numBits = kLenNumHighBits;
-+          }
-+        }
-+        RangeDecoderBitTreeDecode(probLen, numBits, len);
-+        len += offset;
-+      }
-+
-+      if (state < 4)
-+      {
-+        int posSlot;
-+        state += kNumLitStates;
-+        prob = p + PosSlot +
-+            ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << 
-+            kNumPosSlotBits);
-+        RangeDecoderBitTreeDecode(prob, kNumPosSlotBits, posSlot);
-+        if (posSlot >= kStartPosModelIndex)
-+        {
-+          int numDirectBits = ((posSlot >> 1) - 1);
-+          rep0 = (2 | ((UInt32)posSlot & 1));
-+          if (posSlot < kEndPosModelIndex)
-+          {
-+            rep0 <<= numDirectBits;
-+            prob = p + SpecPos + rep0 - posSlot - 1;
-+          }
-+          else
-+          {
-+            numDirectBits -= kNumAlignBits;
-+            do
-+            {
-+              RC_NORMALIZE
-+              Range >>= 1;
-+              rep0 <<= 1;
-+              if (Code >= Range)
-+              {
-+                Code -= Range;
-+                rep0 |= 1;
-+              }
-+            }
-+            while (--numDirectBits != 0);
-+            prob = p + Align;
-+            rep0 <<= kNumAlignBits;
-+            numDirectBits = kNumAlignBits;
-+          }
-+          {
-+            int i = 1;
-+            int mi = 1;
-+            do
-+            {
-+              CProb *prob3 = prob + mi;
-+              RC_GET_BIT2(prob3, mi, ; , rep0 |= i);
-+              i <<= 1;
-+            }
-+            while(--numDirectBits != 0);
-+          }
-+        }
-+        else
-+          rep0 = posSlot;
-+        if (++rep0 == (UInt32)(0))
-+        {
-+          /* it's for stream version */
-+          len = kLzmaStreamWasFinishedId;
-+          break;
-+        }
-+      }
-+
-+      len += kMatchMinLen;
-+      #ifdef _LZMA_OUT_READ
-+      if (rep0 > distanceLimit) 
-+      #else
-+      if (rep0 > nowPos)
-+      #endif
-+        return LZMA_RESULT_DATA_ERROR;
-+
-+      #ifdef _LZMA_OUT_READ
-+      if (dictionarySize - distanceLimit > (UInt32)len)
-+        distanceLimit += len;
-+      else
-+        distanceLimit = dictionarySize;
-+      #endif
-+
-+      do
-+      {
-+        #ifdef _LZMA_OUT_READ
-+        UInt32 pos = dictionaryPos - rep0;
-+        if (pos >= dictionarySize)
-+          pos += dictionarySize;
-+        previousByte = dictionary[pos];
-+        dictionary[dictionaryPos] = previousByte;
-+        if (++dictionaryPos == dictionarySize)
-+          dictionaryPos = 0;
-+        #else
-+        previousByte = outStream[nowPos - rep0];
-+        #endif
-+        len--;
-+        outStream[nowPos++] = previousByte;
-+      }
-+      while(len != 0 && nowPos < outSize);
-+    }
-+  }
-+  RC_NORMALIZE;
-+
-+  #ifdef _LZMA_OUT_READ
-+  vs->Range = Range;
-+  vs->Code = Code;
-+  vs->DictionaryPos = dictionaryPos;
-+  vs->GlobalPos = globalPos + (UInt32)nowPos;
-+  vs->DistanceLimit = distanceLimit;
-+  vs->Reps[0] = rep0;
-+  vs->Reps[1] = rep1;
-+  vs->Reps[2] = rep2;
-+  vs->Reps[3] = rep3;
-+  vs->State = state;
-+  vs->RemainLen = len;
-+  vs->TempDictionary[0] = tempDictionary[0];
-+  #endif
-+
-+  #ifdef _LZMA_IN_CB
-+  vs->Buffer = Buffer;
-+  vs->BufferLim = BufferLim;
-+  #else
-+  *inSizeProcessed = (SizeT)(Buffer - inStream);
-+  #endif
-+  *outSizeProcessed = nowPos;
-+  return LZMA_RESULT_OK;
-+}
---- /dev/null
-+++ b/arch/arm/boot/compressed/LzmaDecode.h
-@@ -0,0 +1,131 @@
-+/* 
-+  LzmaDecode.h
-+  LZMA Decoder interface
-+
-+  LZMA SDK 4.21 Copyright (c) 1999-2005 Igor Pavlov (2005-06-08)
-+  http://www.7-zip.org/
-+
-+  LZMA SDK is licensed under two licenses:
-+  1) GNU Lesser General Public License (GNU LGPL)
-+  2) Common Public License (CPL)
-+  It means that you can select one of these two licenses and 
-+  follow rules of that license.
-+
-+  SPECIAL EXCEPTION:
-+  Igor Pavlov, as the author of this code, expressly permits you to 
-+  statically or dynamically link your code (or bind by name) to the 
-+  interfaces of this file without subjecting your linked code to the 
-+  terms of the CPL or GNU LGPL. Any modifications or additions 
-+  to this file, however, are subject to the LGPL or CPL terms.
-+*/
-+
-+#ifndef __LZMADECODE_H
-+#define __LZMADECODE_H
-+
-+/* #define _LZMA_IN_CB */
-+/* Use callback for input data */
-+
-+/* #define _LZMA_OUT_READ */
-+/* Use read function for output data */
-+
-+/* #define _LZMA_PROB32 */
-+/* It can increase speed on some 32-bit CPUs, 
-+   but memory usage will be doubled in that case */
-+
-+/* #define _LZMA_LOC_OPT */
-+/* Enable local speed optimizations inside code */
-+
-+/* #define _LZMA_SYSTEM_SIZE_T */
-+/* Use system's size_t. You can use it to enable 64-bit sizes supporting*/
-+
-+#ifndef UInt32
-+#ifdef _LZMA_UINT32_IS_ULONG
-+#define UInt32 unsigned long
-+#else
-+#define UInt32 unsigned int
-+#endif
-+#endif
-+
-+#ifndef SizeT
-+#ifdef _LZMA_SYSTEM_SIZE_T
-+#include <stddef.h>
-+#define SizeT size_t
-+#else
-+#define SizeT UInt32
-+#endif
-+#endif
-+
-+#ifdef _LZMA_PROB32
-+#define CProb UInt32
-+#else
-+#define CProb unsigned short
-+#endif
-+
-+#define LZMA_RESULT_OK 0
-+#define LZMA_RESULT_DATA_ERROR 1
-+
-+#ifdef _LZMA_IN_CB
-+typedef struct _ILzmaInCallback
-+{
-+  int (*Read)(void *object, const unsigned char **buffer, SizeT *bufferSize);
-+} ILzmaInCallback;
-+#endif
-+
-+#define LZMA_BASE_SIZE 1846
-+#define LZMA_LIT_SIZE 768
-+
-+#define LZMA_PROPERTIES_SIZE 5
-+
-+typedef struct _CLzmaProperties
-+{
-+  int lc;
-+  int lp;
-+  int pb;
-+  #ifdef _LZMA_OUT_READ
-+  UInt32 DictionarySize;
-+  #endif
-+}CLzmaProperties;
-+
-+int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size);
-+
-+#define LzmaGetNumProbs(Properties) (LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((Properties)->lc + (Properties)->lp)))
-+
-+#define kLzmaNeedInitId (-2)
-+
-+typedef struct _CLzmaDecoderState
-+{
-+  CLzmaProperties Properties;
-+  CProb *Probs;
-+
-+  #ifdef _LZMA_IN_CB
-+  const unsigned char *Buffer;
-+  const unsigned char *BufferLim;
-+  #endif
-+
-+  #ifdef _LZMA_OUT_READ
-+  unsigned char *Dictionary;
-+  UInt32 Range;
-+  UInt32 Code;
-+  UInt32 DictionaryPos;
-+  UInt32 GlobalPos;
-+  UInt32 DistanceLimit;
-+  UInt32 Reps[4];
-+  int State;
-+  int RemainLen;
-+  unsigned char TempDictionary[4];
-+  #endif
-+} CLzmaDecoderState;
-+
-+#ifdef _LZMA_OUT_READ
-+#define LzmaDecoderInit(vs) { (vs)->RemainLen = kLzmaNeedInitId; }
-+#endif
-+
-+int LzmaDecode(CLzmaDecoderState *vs,
-+    #ifdef _LZMA_IN_CB
-+    ILzmaInCallback *inCallback,
-+    #else
-+    const unsigned char *inStream, SizeT inSize, SizeT *inSizeProcessed,
-+    #endif
-+    unsigned char *outStream, SizeT outSize, SizeT *outSizeProcessed);
-+
-+#endif
 --- a/arch/arm/boot/compressed/Makefile
 +++ b/arch/arm/boot/compressed/Makefile
-@@ -5,7 +5,7 @@
- #
- 
- HEAD	= head.o
--OBJS	= misc.o
-+OBJS	= misc.o ../../lib/lib1funcs.o
- FONTC	= $(srctree)/drivers/video/console/font_acorn_8x8.c
- 
- #
 @@ -63,7 +63,7 @@ endif
  
  SEDFLAGS	= s/TEXT_START/$(ZTEXTADDR)/;s/BSS_START/$(ZBSSADDR)/
@@ -761,141 +25,160 @@
  
 --- a/arch/arm/boot/compressed/misc.c
 +++ b/arch/arm/boot/compressed/misc.c
-@@ -202,8 +202,8 @@ typedef unsigned long  ulg;
- static uch *inbuf;		/* input buffer */
- static uch window[WSIZE];	/* Sliding window buffer */
+@@ -186,36 +186,10 @@ static inline __ptr_t memcpy(__ptr_t __d
+ 	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, */
++#define WSIZE 0x20000		/* Window size must be at least 128k, */
+ 				/* 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 insize = 0;		/* valid bytes in inbuf */
-+static unsigned inptr = 0;		/* index of next byte to be processed in inbuf */
- static unsigned outcnt;		/* bytes in output buffer */
+-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())
++static u8 window[WSIZE];	/* Sliding window buffer */
+ 
+ /* Diagnostic functions */
+ #ifdef DEBUG
+@@ -234,24 +208,21 @@ static unsigned outcnt;		/* bytes in out
+ #  define Tracecv(c,x)
+ #endif
+ 
+-static int  fill_inbuf(void);
+-static void flush_window(void);
+ static void error(char *m);
  
- /* gzip flag byte */
-@@ -242,7 +242,7 @@ extern char input_data[];
+ extern char input_data[];
  extern char input_data_end[];
  
- static uch *output_data;
+-static uch *output_data;
 -static ulg output_ptr;
-+static ulg output_ptr = 0;
- static ulg bytes_out;
+-static ulg bytes_out;
++static unsigned long output_ptr;
++static unsigned long bytes_out;
  
  static void error(char *m);
-@@ -259,7 +259,7 @@ static ulg free_mem_end_ptr;
  
- #define ARCH_HAS_DECOMP_WDOG
+ static void putstr(const char *);
  
--#include "../../../../lib/inflate.c"
-+/* #include "../../../../lib/inflate.c" */
+ extern int end;
+-static ulg free_mem_ptr;
+-static ulg free_mem_end_ptr;
++static unsigned long free_mem_ptr;
++static unsigned long free_mem_end_ptr;
  
- /* ===========================================================================
-  * Fill the input buffer. This is called only when the buffer is empty
-@@ -277,6 +277,76 @@ int fill_inbuf(void)
- 	return inbuf[0];
- }
+ #ifdef STANDALONE_DEBUG
+ #define NO_INFLATE_MALLOC
+@@ -259,50 +230,10 @@ static ulg free_mem_end_ptr;
  
-+#define _LZMA_IN_CB
-+#include "LzmaDecode.h"
-+#include "LzmaDecode.c"
-+
-+void __div0(void)
-+{
-+}
-+
-+static int read_byte(void *object, const unsigned char **buffer, SizeT *bufferSize);
-+
-+/*
-+ * Do the lzma decompression
-+ */
-+static int unlzma(void)
-+{
-+
-+	unsigned int i;
-+	CLzmaDecoderState state;
-+	unsigned int uncompressedSize = 0;
-+
-+	ILzmaInCallback callback;
-+	callback.Read = read_byte;
-+
-+	/* lzma args */
-+	i = get_byte();
-+	state.Properties.lc = i % 9, i = i / 9;
-+	state.Properties.lp = i % 5, state.Properties.pb = i / 5;
-+
-+	/* skip dictionary size */
-+	for (i = 0; i < 4; i++)
-+		get_byte();
-+	/* get uncompressed size */
-+	uncompressedSize = (get_byte()) +
-+		(get_byte() << 8) +
-+		(get_byte() << 16) +
-+		(get_byte() << 24);
-+
-+	/* skip high order bytes */
-+	for (i = 0; i < 4; i++)
-+		get_byte();
-+	/* point it beyond uncompresedSize */
-+	state.Probs = (CProb *) (output_data + uncompressedSize);
-+
-+	/* decompress kernel */
-+	if (LzmaDecode(&state, &callback,
-+		(unsigned char *)output_data, uncompressedSize, &i) == LZMA_RESULT_OK) {
-+		if (i != uncompressedSize)
-+			error("kernel corrupted!\n");
-+		/* copy it back to low_buffer */
-+		bytes_out = i;
-+		output_ptr = i;
-+		return 0;
-+	}
-+	return 1;
-+}
-+
-+static unsigned int icnt = 0;
-+
-+static int read_byte(void *object, const unsigned char **buffer, SizeT *bufferSize)
-+{
-+	static unsigned char val;
-+	*bufferSize = 1;
-+	val = get_byte();
-+	*buffer = &val;
-+	if (icnt++ % (1024 * 10) == 0)
-+		putstr(".");
-+	return LZMA_RESULT_OK;
-+}
-+
-+#if 0
- /* ===========================================================================
-  * Write the output window window[0..outcnt-1] and update crc and bytes_out.
-  * (Used for the decompressed data only.)
-@@ -299,6 +369,7 @@ void flush_window(void)
- 	outcnt = 0;
- 	putstr(".");
- }
-+#endif
+ #define ARCH_HAS_DECOMP_WDOG
  
+-#include "../../../../lib/inflate.c"
+-
+-/* ===========================================================================
+- * 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");
+-
+-	inbuf = input_data;
+-	insize = &input_data_end[0] - &input_data[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;
+-	putstr(".");
+-}
+-
  #ifndef arch_error
  #define arch_error(x)
-@@ -328,9 +399,9 @@ decompress_kernel(ulg output_start, ulg 
+ #endif
++#include "unlzma.c"
+ 
+ static void error(char *x)
+ {
+@@ -317,20 +248,16 @@ static void error(char *x)
+ 
+ #ifndef STANDALONE_DEBUG
+ 
+-ulg
+-decompress_kernel(ulg output_start, ulg free_mem_ptr_p, ulg free_mem_ptr_end_p,
++unsigned long
++decompress_kernel(unsigned long output_start, unsigned long free_mem_ptr_p, unsigned long 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_end_ptr	= free_mem_ptr_end_p;
+ 	__machine_arch_type	= arch_id;
  
  	arch_decomp_setup();
  
 -	makecrc();
-+	/* makecrc(); */
  	putstr("Uncompressing Linux...");
 -	gunzip();
-+	unlzma();
++	output_ptr += unlzma((u8 *) output_start, input_data, window);
  	putstr(" done, booting the kernel.\n");
  	return output_ptr;
  }
-@@ -342,9 +413,9 @@ int main()
- {
- 	output_data = output_buffer;
+@@ -340,11 +267,8 @@ char output_buffer[1500*1024];
  
+ int main()
+ {
+-	output_data = output_buffer;
+-
 -	makecrc();
-+	/* makecrc(); */
  	putstr("Uncompressing Linux...");
 -	gunzip();
-+	unlzma();
++	unlzma((u8 *) output_buffer, input_data, window);
  	putstr("done.\n");
  	return 0;
  }
@@ -909,3 +192,519 @@
 +	.incbin	"arch/arm/boot/compressed/piggy.lzma"
  	.globl	input_data_end
  input_data_end:
+--- /dev/null
++++ b/arch/arm/boot/compressed/unlzma.c
+@@ -0,0 +1,429 @@
++/*
++ * Copyright (c) 2009  Felix Fietkau <nbd@openwrt.org>
++ *
++ * 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,
++ * 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
++ *
++ * uncompress.c
++ */
++
++#include <linux/types.h>
++#include <asm/byteorder.h>
++#include "unlzma.h"
++
++struct unlzma_ctx {
++	const u8 *next_in;
++	u8 *next_out;
++	u8 *outbuf;
++
++	/* reader state */
++	u32 code;
++	u32 range;
++	u32 bound;
++
++	/* writer state */
++	u8 previous_byte;
++	ssize_t pos;
++
++	/* cstate */
++	int state;
++	u32 rep0, rep1, rep2, rep3;
++
++	void *workspace;
++} ctx;
++
++static int inbs = 0;
++static inline u8
++rc_read(void)
++{
++#if 0
++	if (unlikely(++inbs > 16 * 1024)) {
++		putstr(".");
++		inbs = 0;
++	}
++#endif
++	return *(ctx.next_in++);
++}
++
++
++static inline void
++rc_get_code(void)
++{
++	ctx.code = (ctx.code << 8) | rc_read();
++}
++
++static inline void
++rc_normalize(void)
++{
++	if (ctx.range < (1 << RC_TOP_BITS)) {
++		ctx.range <<= 8;
++		rc_get_code();
++	}
++}
++
++static inline int
++rc_is_bit_0(u16 *p)
++{
++	rc_normalize();
++	ctx.bound = *p * (ctx.range >> RC_MODEL_TOTAL_BITS);
++	return ctx.code < ctx.bound;
++}
++
++static inline void
++rc_update_bit_0(u16 *p)
++{
++	ctx.range = ctx.bound;
++	*p += ((1 << RC_MODEL_TOTAL_BITS) - *p) >> RC_MOVE_BITS;
++}
++
++static inline void
++rc_update_bit_1(u16 *p)
++{
++	ctx.range -= ctx.bound;
++	ctx.code -= ctx.bound;
++	*p -= *p >> RC_MOVE_BITS;
++}
++
++static inline bool
++rc_get_bit(u16 *p, int *symbol)
++{
++	if (rc_is_bit_0(p)) {
++		rc_update_bit_0(p);
++		*symbol *= 2;
++		return 0;
++	} else {
++		rc_update_bit_1(p);
++		*symbol = *symbol * 2 + 1;
++		return 1;
++	}
++}
++
++static inline int
++rc_direct_bit(void)
++{
++	rc_normalize();
++	ctx.range >>= 1;
++	if (ctx.code >= ctx.range) {
++		ctx.code -= ctx.range;
++		return 1;
++	}
++	return 0;
++}
++
++static inline void
++rc_bit_tree_decode(u16 *p, int num_levels, int *symbol)
++{
++	int i = num_levels;
++
++	*symbol = 1;
++	while (i--)
++		rc_get_bit(p + *symbol, symbol);
++	*symbol -= 1 << num_levels;
++}
++
++static inline u8
++peek_old_byte(u32 offs)
++{
++	u32 pos = ctx.pos - offs;
++	return ctx.outbuf[pos];
++}
++
++static inline void
++write_byte(u8 byte)
++{
++	ctx.previous_byte = byte;
++	*(ctx.next_out++) = byte;
++	ctx.pos++;
++}
++
++
++static inline void
++copy_byte(u32 offs)
++{
++	write_byte(peek_old_byte(offs));
++}
++
++static inline void
++copy_bytes(u32 rep0, int len)
++{
++	do {
++		copy_byte(rep0);
++		len--;
++	} while (len != 0);
++}
++
++static inline void
++process_bit0(u16 *p, int pos_state, u16 *prob,
++             int lc, u32 literal_pos_mask)
++{
++	int mi = 1;
++	rc_update_bit_0(prob);
++	prob = (p + LZMA_LITERAL +
++		(LZMA_LIT_SIZE
++		 * (((ctx.pos & literal_pos_mask) << lc)
++		    + (ctx.previous_byte >> (8 - lc))))
++		);
++
++	if (ctx.state >= LZMA_NUM_LIT_STATES) {
++		int match_byte = peek_old_byte(ctx.rep0);
++		do {
++			u16 bit;
++			u16 *prob_lit;
++
++			match_byte <<= 1;
++			bit = match_byte & 0x100;
++			prob_lit = prob + 0x100 + bit + mi;
++			if (rc_get_bit(prob_lit, &mi) != !!bit)
++				break;
++		} while (mi < 0x100);
++	}
++	while (mi < 0x100) {
++		u16 *prob_lit = prob + mi;
++		rc_get_bit(prob_lit, &mi);
++	}
++	write_byte(mi);
++	if (ctx.state < 4)
++		ctx.state = 0;
++	else if (ctx.state < 10)
++		ctx.state -= 3;
++	else
++		ctx.state -= 6;
++}
++
++static inline void
++process_bit1(u16 *p, int pos_state, u16 *prob)
++{
++	int offset;
++	u16 *prob_len;
++	int num_bits;
++	int len;
++
++	rc_update_bit_1(prob);
++	prob = p + LZMA_IS_REP + ctx.state;
++	if (rc_is_bit_0(prob)) {
++		rc_update_bit_0(prob);
++		ctx.rep3 = ctx.rep2;
++		ctx.rep2 = ctx.rep1;
++		ctx.rep1 = ctx.rep0;
++		ctx.state = ctx.state < LZMA_NUM_LIT_STATES ? 0 : 3;
++		prob = p + LZMA_LEN_CODER;
++	} else {
++		rc_update_bit_1(prob);
++		prob = p + LZMA_IS_REP_G0 + ctx.state;
++		if (rc_is_bit_0(prob)) {
++			rc_update_bit_0(prob);
++			prob = (p + LZMA_IS_REP_0_LONG
++				+ (ctx.state <<
++				   LZMA_NUM_POS_BITS_MAX) +
++				pos_state);
++			if (rc_is_bit_0(prob)) {
++				rc_update_bit_0(prob);
++
++				ctx.state = ctx.state < LZMA_NUM_LIT_STATES ?
++					9 : 11;
++				copy_byte(ctx.rep0);
++				return;
++			} else {
++				rc_update_bit_1(prob);
++			}
++		} else {
++			u32 distance;
++
++			rc_update_bit_1(prob);
++			prob = p + LZMA_IS_REP_G1 + ctx.state;
++			if (rc_is_bit_0(prob)) {
++				rc_update_bit_0(prob);
++				distance = ctx.rep1;
++			} else {
++				rc_update_bit_1(prob);
++				prob = p + LZMA_IS_REP_G2 + ctx.state;
++				if (rc_is_bit_0(prob)) {
++					rc_update_bit_0(prob);
++					distance = ctx.rep2;
++				} else {
++					rc_update_bit_1(prob);
++					distance = ctx.rep3;
++					ctx.rep3 = ctx.rep2;
++				}
++				ctx.rep2 = ctx.rep1;
++			}
++			ctx.rep1 = ctx.rep0;
++			ctx.rep0 = distance;
++		}
++		ctx.state = ctx.state < LZMA_NUM_LIT_STATES ? 8 : 11;
++		prob = p + LZMA_REP_LEN_CODER;
++	}
++
++	prob_len = prob + LZMA_LEN_CHOICE;
++	if (rc_is_bit_0(prob_len)) {
++		rc_update_bit_0(prob_len);
++		prob_len = (prob + LZMA_LEN_LOW
++			    + (pos_state <<
++			       LZMA_LEN_NUM_LOW_BITS));
++		offset = 0;
++		num_bits = LZMA_LEN_NUM_LOW_BITS;
++	} else {
++		rc_update_bit_1(prob_len);
++		prob_len = prob + LZMA_LEN_CHOICE_2;
++		if (rc_is_bit_0(prob_len)) {
++			rc_update_bit_0(prob_len);
++			prob_len = (prob + LZMA_LEN_MID
++				    + (pos_state <<
++				       LZMA_LEN_NUM_MID_BITS));
++			offset = 1 << LZMA_LEN_NUM_LOW_BITS;
++			num_bits = LZMA_LEN_NUM_MID_BITS;
++		} else {
++			rc_update_bit_1(prob_len);
++			prob_len = prob + LZMA_LEN_HIGH;
++			offset = ((1 << LZMA_LEN_NUM_LOW_BITS)
++				  + (1 << LZMA_LEN_NUM_MID_BITS));
++			num_bits = LZMA_LEN_NUM_HIGH_BITS;
++		}
++	}
++
++	rc_bit_tree_decode(prob_len, num_bits, &len);
++	len += offset;
++
++	if (ctx.state < 4) {
++		int pos_slot;
++
++		ctx.state += LZMA_NUM_LIT_STATES;
++		prob =
++			p + LZMA_POS_SLOT +
++			((len <
++			  LZMA_NUM_LEN_TO_POS_STATES ? len :
++			  LZMA_NUM_LEN_TO_POS_STATES - 1)
++			 << LZMA_NUM_POS_SLOT_BITS);
++		rc_bit_tree_decode(prob,
++				   LZMA_NUM_POS_SLOT_BITS,
++				   &pos_slot);
++		if (pos_slot >= LZMA_START_POS_MODEL_INDEX) {
++			int i, mi;
++			num_bits = (pos_slot >> 1) - 1;
++			ctx.rep0 = 2 | (pos_slot & 1);
++			if (pos_slot < LZMA_END_POS_MODEL_INDEX) {
++				ctx.rep0 <<= num_bits;
++				prob = p + LZMA_SPEC_POS +
++					ctx.rep0 - pos_slot - 1;
++			} else {
++				num_bits -= LZMA_NUM_ALIGN_BITS;
++				while (num_bits--)
++					ctx.rep0 = (ctx.rep0 << 1) |
++						rc_direct_bit();
++				prob = p + LZMA_ALIGN;
++				ctx.rep0 <<= LZMA_NUM_ALIGN_BITS;
++				num_bits = LZMA_NUM_ALIGN_BITS;
++			}
++			i = 1;
++			mi = 1;
++			while (num_bits--) {
++				if (rc_get_bit(prob + mi, &mi))
++					ctx.rep0 |= i;
++				i <<= 1;
++			}
++		} else
++			ctx.rep0 = pos_slot;
++		if (++(ctx.rep0) == 0)
++			return;
++	}
++
++	len += LZMA_MATCH_MIN_LEN;
++
++	copy_bytes(ctx.rep0, len);
++}
++
++
++static int
++do_unlzma(void)
++{
++	u8 hdr_buf[sizeof(struct lzma_header)];
++	struct lzma_header *header = (struct lzma_header *)hdr_buf;
++	u32 pos_state_mask;
++	u32 literal_pos_mask;
++	int lc, pb, lp;
++	int num_probs;
++	int i, mi;
++	u16 *p;
++
++	for (i = 0; i < sizeof(struct lzma_header); i++) {
++		hdr_buf[i] = rc_read();
++	}
++
++	ctx.pos = 0;
++	ctx.state = 0;
++	ctx.rep0 = ctx.rep1 = ctx.rep2 = ctx.rep3 = 1;
++
++	ctx.previous_byte = 0;
++	ctx.code = 0;
++	ctx.range = 0xFFFFFFFF;
++
++	if (header->pos >= (9 * 5 * 5))
++		return -1;
++
++	mi = 0;
++	lc = header->pos;
++	while (lc >= 9) {
++		mi++;
++		lc -= 9;
++	}
++	pb = 0;
++	lp = mi;
++	while (lp >= 5) {
++		pb++;
++		lp -= 5;
++	}
++	pos_state_mask = (1 << pb) - 1;
++	literal_pos_mask = (1 << lp) - 1;
++
++	p = (u16 *) ctx.workspace;
++	if (!p)
++		return -1;
++
++	num_probs = LZMA_LITERAL + (LZMA_LIT_SIZE << (lc + lp));
++	for (i = 0; i < num_probs; i++)
++		p[i] = (1 << RC_MODEL_TOTAL_BITS) >> 1;
++
++	for (i = 0; i < 5; i++)
++		rc_get_code();
++
++	while (1) {
++		int pos_state =	ctx.pos & pos_state_mask;
++		u16 *prob = p + LZMA_IS_MATCH +
++			(ctx.state << LZMA_NUM_POS_BITS_MAX) + pos_state;
++		if (rc_is_bit_0(prob))
++			process_bit0(p, pos_state, prob,
++				     lc, literal_pos_mask);
++		else {
++			process_bit1(p, pos_state, prob);
++			if (ctx.rep0 == 0)
++				break;
++		}
++	}
++
++	return ctx.pos;
++}
++
++
++static int unlzma(unsigned char *dest, const unsigned char *src, unsigned char *workspace)
++{
++	memset(&ctx, 0, sizeof(ctx));
++	ctx.outbuf = dest;
++	ctx.next_in = src;
++	ctx.next_out = dest;
++	ctx.workspace = workspace;
++
++	return do_unlzma();
++}
++
++
+--- /dev/null
++++ b/arch/arm/boot/compressed/unlzma.h
+@@ -0,0 +1,81 @@
++/* LZMA uncompresion module for pcomp
++ * Copyright (C) 2009  Felix Fietkau <nbd@openwrt.org>
++ *
++ * Based on:
++ *  Initial Linux kernel adaptation
++ *  Copyright (C) 2006  Alain < alain@knaff.lu >
++ *
++ *  Based on small lzma deflate implementation/Small range coder
++ *  implementation for lzma.
++ *  Copyright (C) 2006  Aurelien Jacobs < aurel@gnuage.org >
++ *
++ *  Based on LzmaDecode.c from the LZMA SDK 4.22 (http://www.7-zip.org/)
++ *  Copyright (C) 1999-2005  Igor Pavlov
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 as published
++ * by the Free Software Foundation.
++ */
++#ifndef __UNLZMA_H
++#define __UNLZMA_H
++
++struct lzma_header {
++	__u8 pos;
++	__le32 dict_size;
++	__le64 uncompr_size;
++} __attribute__ ((packed));
++
++
++#define RC_TOP_BITS 24
++#define RC_MOVE_BITS 5
++#define RC_MODEL_TOTAL_BITS 11
++
++#define LZMA_BASE_SIZE 1846
++#define LZMA_LIT_SIZE 768
++
++#define LZMA_NUM_POS_BITS_MAX 4
++
++#define LZMA_LEN_NUM_LOW_BITS 3
++#define LZMA_LEN_NUM_MID_BITS 3
++#define LZMA_LEN_NUM_HIGH_BITS 8
++
++#define LZMA_LEN_CHOICE 0
++#define LZMA_LEN_CHOICE_2 (LZMA_LEN_CHOICE + 1)
++#define LZMA_LEN_LOW (LZMA_LEN_CHOICE_2 + 1)
++#define LZMA_LEN_MID (LZMA_LEN_LOW \
++		      + (1 << (LZMA_NUM_POS_BITS_MAX + LZMA_LEN_NUM_LOW_BITS)))
++#define LZMA_LEN_HIGH (LZMA_LEN_MID \
++		       +(1 << (LZMA_NUM_POS_BITS_MAX + LZMA_LEN_NUM_MID_BITS)))
++#define LZMA_NUM_LEN_PROBS (LZMA_LEN_HIGH + (1 << LZMA_LEN_NUM_HIGH_BITS))
++
++#define LZMA_NUM_STATES 12
++#define LZMA_NUM_LIT_STATES 7
++
++#define LZMA_START_POS_MODEL_INDEX 4
++#define LZMA_END_POS_MODEL_INDEX 14
++#define LZMA_NUM_FULL_DISTANCES (1 << (LZMA_END_POS_MODEL_INDEX >> 1))
++
++#define LZMA_NUM_POS_SLOT_BITS 6
++#define LZMA_NUM_LEN_TO_POS_STATES 4
++
++#define LZMA_NUM_ALIGN_BITS 4
++
++#define LZMA_MATCH_MIN_LEN 2
++
++#define LZMA_IS_MATCH 0
++#define LZMA_IS_REP (LZMA_IS_MATCH + (LZMA_NUM_STATES << LZMA_NUM_POS_BITS_MAX))
++#define LZMA_IS_REP_G0 (LZMA_IS_REP + LZMA_NUM_STATES)
++#define LZMA_IS_REP_G1 (LZMA_IS_REP_G0 + LZMA_NUM_STATES)
++#define LZMA_IS_REP_G2 (LZMA_IS_REP_G1 + LZMA_NUM_STATES)
++#define LZMA_IS_REP_0_LONG (LZMA_IS_REP_G2 + LZMA_NUM_STATES)
++#define LZMA_POS_SLOT (LZMA_IS_REP_0_LONG \
++		       + (LZMA_NUM_STATES << LZMA_NUM_POS_BITS_MAX))
++#define LZMA_SPEC_POS (LZMA_POS_SLOT \
++		       +(LZMA_NUM_LEN_TO_POS_STATES << LZMA_NUM_POS_SLOT_BITS))
++#define LZMA_ALIGN (LZMA_SPEC_POS \
++		    + LZMA_NUM_FULL_DISTANCES - LZMA_END_POS_MODEL_INDEX)
++#define LZMA_LEN_CODER (LZMA_ALIGN + (1 << LZMA_NUM_ALIGN_BITS))
++#define LZMA_REP_LEN_CODER (LZMA_LEN_CODER + LZMA_NUM_LEN_PROBS)
++#define LZMA_LITERAL (LZMA_REP_LEN_CODER + LZMA_NUM_LEN_PROBS)
++
++#endif
diff --git a/target/linux/generic-2.6/patches-2.6.30/998-openwrt_lzma_options.patch b/target/linux/generic-2.6/patches-2.6.30/998-openwrt_lzma_options.patch
index 8e05052ea4..e7b6b3d4c0 100644
--- a/target/linux/generic-2.6/patches-2.6.30/998-openwrt_lzma_options.patch
+++ b/target/linux/generic-2.6/patches-2.6.30/998-openwrt_lzma_options.patch
@@ -5,4 +5,4 @@
  
  quiet_cmd_lzma = LZMA    $@
 -cmd_lzma = (lzma -9 -c $< && $(size_append) $<) >$@ || (rm -f $@ ; false)
-+cmd_lzma = lzma e $< $@ -lc1 -lp2 -pb2
++cmd_lzma = lzma e $< $@ -lc1 -lp2 -pb2 -eos