add a new arm lzma kernel decompressor based on rewritten (and much more readable...
authorFelix Fietkau <nbd@openwrt.org>
Tue, 21 Jul 2009 02:31:37 +0000 (02:31 +0000)
committerFelix Fietkau <nbd@openwrt.org>
Tue, 21 Jul 2009 02:31:37 +0000 (02:31 +0000)
SVN-Revision: 16939

target/linux/generic-2.6/patches-2.6.28/960-arm_lzma_loader.patch [new file with mode: 0644]
target/linux/generic-2.6/patches-2.6.30/960-arm_lzma_loader.patch
target/linux/generic-2.6/patches-2.6.30/998-openwrt_lzma_options.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 (file)
index 0000000..986c282
--- /dev/null
@@ -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
index 7995b5e..f159898 100644 (file)
@@ -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)/
  
 --- 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;
  }
 +      .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
index 8e05052..e7b6b3d 100644 (file)
@@ -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