From 925c5951c6531802e3f48a45a33afa68dbaddb99 Mon Sep 17 00:00:00 2001 From: Felix Fietkau Date: Tue, 21 Jul 2009 02:31:37 +0000 Subject: [PATCH] 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 --- .../patches-2.6.28/960-arm_lzma_loader.patch | 719 ++++++++ .../patches-2.6.30/960-arm_lzma_loader.patch | 1483 +++++++---------- .../998-openwrt_lzma_options.patch | 2 +- 3 files changed, 1361 insertions(+), 843 deletions(-) create mode 100644 target/linux/generic-2.6/patches-2.6.28/960-arm_lzma_loader.patch 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 ++ * ++ * 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 ++#include ++#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 ++ * ++ * 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 -+#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 ++ * ++ * 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 ++#include ++#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 ++ * ++ * 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 -- 2.30.2