diff options
| -rw-r--r-- | target/linux/avr32/image/u-boot/patches/001-add_lzma_decompression_support.patch | 1135 | ||||
| -rw-r--r-- | target/linux/avr32/image/u-boot/patches/100-ngw100_enable_lzma_support.patch | 12 |
2 files changed, 1147 insertions, 0 deletions
diff --git a/target/linux/avr32/image/u-boot/patches/001-add_lzma_decompression_support.patch b/target/linux/avr32/image/u-boot/patches/001-add_lzma_decompression_support.patch new file mode 100644 index 0000000000..a9b8582c18 --- /dev/null +++ b/target/linux/avr32/image/u-boot/patches/001-add_lzma_decompression_support.patch @@ -0,0 +1,1135 @@ +From d37394e9ca1b85407408719feb2468c5affefa4a Mon Sep 17 00:00:00 2001 +From: Gabor Juhos <juhosg at openwrt.org> +Date: Fri, 9 May 2008 17:26:14 +0200 +Subject: [PATCH] add LZMA decompression support + +--- + common/cmd_bootm.c | 18 ++ + common/image.c | 1 + + include/LzmaWrapper.h | 36 +++ + include/image.h | 1 + + lib_generic/LzmaDecode.c | 602 +++++++++++++++++++++++++++++++++++++++++++++ + lib_generic/LzmaDecode.h | 113 +++++++++ + lib_generic/LzmaTypes.h | 45 ++++ + lib_generic/LzmaWrapper.c | 197 +++++++++++++++ + lib_generic/Makefile | 2 + + 9 files changed, 1015 insertions(+), 0 deletions(-) + create mode 100644 include/LzmaWrapper.h + create mode 100644 lib_generic/LzmaDecode.c + create mode 100644 lib_generic/LzmaDecode.h + create mode 100644 lib_generic/LzmaTypes.h + create mode 100644 lib_generic/LzmaWrapper.c + +diff --git a/common/cmd_bootm.c b/common/cmd_bootm.c +index 0d67132..6071817 100644 +--- a/common/cmd_bootm.c ++++ b/common/cmd_bootm.c +@@ -32,6 +32,7 @@ + #include <malloc.h> + #include <zlib.h> + #include <bzlib.h> ++#include <LzmaWrapper.h> + #include <environment.h> + #include <lmb.h> + #include <asm/byteorder.h> +@@ -237,6 +238,7 @@ int do_bootm (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) + puts("OK\n"); + } + break; ++#ifndef CONFIG_NO_GZIP + case IH_COMP_GZIP: + printf (" Uncompressing %s ... ", type_name); + if (gunzip ((void *)load_start, unc_len, +@@ -249,6 +251,7 @@ int do_bootm (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) + + load_end = load_start + os_len; + break; ++#endif + #ifdef CONFIG_BZIP2 + case IH_COMP_BZIP2: + printf (" Uncompressing %s ... ", type_name); +@@ -270,6 +273,21 @@ int do_bootm (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) + load_end = load_start + unc_len; + break; + #endif /* CONFIG_BZIP2 */ ++#ifdef CONFIG_LZMA ++ case IH_COMP_LZMA: ++ printf (" Uncompressing %s ... ", type_name); ++ int i = lzma_inflate ((unsigned char *)os_data, os_len, ++ (unsigned char *)load_start, &unc_len); ++ if (i != LZMA_RESULT_OK) { ++ printf ("LZMA: uncompress or overwrite error %d " ++ "- must RESET board to recover\n", i); ++ show_boot_progress (-6); ++ do_reset (cmdtp, flag, argc, argv); ++ } ++ ++ load_end = load_start + unc_len; ++ break; ++#endif /* CONFIG_LZMA */ + default: + if (iflag) + enable_interrupts(); +diff --git a/common/image.c b/common/image.c +index 67e594d..9b42ae9 100644 +--- a/common/image.c ++++ b/common/image.c +@@ -148,6 +148,7 @@ static table_entry_t uimage_comp[] = { + { IH_COMP_NONE, "none", "uncompressed", }, + { IH_COMP_BZIP2, "bzip2", "bzip2 compressed", }, + { IH_COMP_GZIP, "gzip", "gzip compressed", }, ++ { IH_COMP_LZMA, "lzma", "lzma compressed", }, + { -1, "", "", }, + }; + +diff --git a/include/LzmaWrapper.h b/include/LzmaWrapper.h +new file mode 100644 +index 0000000..2f9a3ff +--- /dev/null ++++ b/include/LzmaWrapper.h +@@ -0,0 +1,36 @@ ++/****************************************************************************** ++** ++** FILE NAME : LzmaWrapper.h ++** PROJECT : bootloader ++** MODULES : U-boot ++** ++** DATE : 2 Nov 2006 ++** AUTHOR : Lin Mars ++** DESCRIPTION : LZMA decoder support for U-boot 1.1.5 ++** COPYRIGHT : Copyright (c) 2006 ++** Infineon Technologies AG ++** Am Campeon 1-12, 85579 Neubiberg, Germany ++** ++** 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 of the License, or ++** (at your option) any later version. ++** ++** HISTORY ++** $Date $Author $Comment ++** 2 Nov 2006 Lin Mars init version which derived from LzmaTest.c from ++** LZMA v4.43 SDK ++*******************************************************************************/ ++#ifndef __LZMA_WRAPPER_H__ ++#define __LZMA_WRAPPER_H__ ++ ++#ifndef LZMA_RESULT_OK ++#define LZMA_RESULT_OK 0 ++#endif ++#ifndef LZMA_RESULT_DATA_ERROR ++#define LZMA_RESULT_DATA_ERROR 1 ++#endif ++ ++extern int lzma_inflate(unsigned char *source, int s_len, unsigned char *dest, int *d_len); ++ ++#endif /*__LZMA_WRAPPER_H__*/ +diff --git a/include/image.h b/include/image.h +index 664e51e..6de51c4 100644 +--- a/include/image.h ++++ b/include/image.h +@@ -164,6 +164,7 @@ + #define IH_COMP_NONE 0 /* No Compression Used */ + #define IH_COMP_GZIP 1 /* gzip Compression Used */ + #define IH_COMP_BZIP2 2 /* bzip2 Compression Used */ ++#define IH_COMP_LZMA 3 /* lzma Compression used */ + + #define IH_MAGIC 0x27051956 /* Image Magic Number */ + #define IH_NMLEN 32 /* Image Name Length */ +diff --git a/lib_generic/LzmaDecode.c b/lib_generic/LzmaDecode.c +new file mode 100644 +index 0000000..d876e8b +--- /dev/null ++++ b/lib_generic/LzmaDecode.c +@@ -0,0 +1,602 @@ ++/* ++ LzmaDecode.c ++ LZMA Decoder (optimized for Speed version) ++ ++ LZMA SDK 4.40 Copyright (c) 1999-2006 Igor Pavlov (2006-05-01) ++ 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 <config.h> ++ ++#ifdef CONFIG_LZMA ++ ++#include "LzmaDecode.h" ++ ++#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) { printf("ERROR, %s, %d\n", __FILE__, __LINE__); return result; } \ ++ BufferLim = Buffer + size; if (size == 0) { printf("ERROR, %s, %d\n", __FILE__, __LINE__); return LZMA_RESULT_DATA_ERROR; } }} ++ ++#define RC_INIT Buffer = BufferLim = 0; RC_INIT2 ++ ++#else ++ ++#define RC_TEST { if (Buffer == BufferLim) { printf("ERROR, %s, %d\n", __FILE__, __LINE__); 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 ++ ++int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size) ++{ ++ unsigned char prop0; ++ if (size < LZMA_PROPERTIES_SIZE) ++ { ++ printf("ERROR: %s, %d\n", __FILE__, __LINE__); ++ return LZMA_RESULT_DATA_ERROR; ++ } ++ prop0 = propsData[0]; ++ if (prop0 >= (9 * 5 * 5)) ++ { ++ printf("ERROR: %s, %d\n", __FILE__, __LINE__); ++ 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; ++} ++ ++#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 ++ { ++ printf("ERROR: %s, %d\n", __FILE__, __LINE__); ++ 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 ++ { ++ printf("ERROR: %s, %d\n", __FILE__, __LINE__); ++ 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; ++} ++ ++#endif /* CONFIG_LZMA */ +diff --git a/lib_generic/LzmaDecode.h b/lib_generic/LzmaDecode.h +new file mode 100644 +index 0000000..2870eeb +--- /dev/null ++++ b/lib_generic/LzmaDecode.h +@@ -0,0 +1,113 @@ ++/* ++ LzmaDecode.h ++ LZMA Decoder interface ++ ++ LZMA SDK 4.40 Copyright (c) 1999-2006 Igor Pavlov (2006-05-01) ++ 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 ++ ++#include "LzmaTypes.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 */ ++ ++#ifdef _LZMA_PROB32 ++#define CProb UInt32 ++#else ++#define CProb UInt16 ++#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 +diff --git a/lib_generic/LzmaTypes.h b/lib_generic/LzmaTypes.h +new file mode 100644 +index 0000000..288c5e4 +--- /dev/null ++++ b/lib_generic/LzmaTypes.h +@@ -0,0 +1,45 @@ ++/* ++LzmaTypes.h ++ ++Types for LZMA Decoder ++ ++This file written and distributed to public domain by Igor Pavlov. ++This file is part of LZMA SDK 4.40 (2006-05-01) ++*/ ++ ++#ifndef __LZMATYPES_H ++#define __LZMATYPES_H ++ ++#ifndef _7ZIP_BYTE_DEFINED ++#define _7ZIP_BYTE_DEFINED ++typedef unsigned char Byte; ++#endif ++ ++#ifndef _7ZIP_UINT16_DEFINED ++#define _7ZIP_UINT16_DEFINED ++typedef unsigned short UInt16; ++#endif ++ ++#ifndef _7ZIP_UINT32_DEFINED ++#define _7ZIP_UINT32_DEFINED ++#ifdef _LZMA_UINT32_IS_ULONG ++typedef unsigned long UInt32; ++#else ++typedef unsigned int UInt32; ++#endif ++#endif ++ ++/* #define _LZMA_SYSTEM_SIZE_T */ ++/* Use system's size_t. You can use it to enable 64-bit sizes supporting */ ++ ++#ifndef _7ZIP_SIZET_DEFINED ++#define _7ZIP_SIZET_DEFINED ++#ifdef _LZMA_SYSTEM_SIZE_T ++#include <stddef.h> ++typedef size_t SizeT; ++#else ++typedef UInt32 SizeT; ++#endif ++#endif ++ ++#endif +diff --git a/lib_generic/LzmaWrapper.c b/lib_generic/LzmaWrapper.c +new file mode 100644 +index 0000000..6c3d702 +--- /dev/null ++++ b/lib_generic/LzmaWrapper.c +@@ -0,0 +1,197 @@ ++/****************************************************************************** ++** ++** FILE NAME : LzmaWrapper.c ++** PROJECT : bootloader ++** MODULES : U-boot ++** ++** DATE : 2 Nov 2006 ++** AUTHOR : Lin Mars ++** DESCRIPTION : LZMA decoder support for U-boot 1.1.5 ++** COPYRIGHT : Copyright (c) 2006 ++** Infineon Technologies AG ++** Am Campeon 1-12, 85579 Neubiberg, Germany ++** ++** 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 of the License, or ++** (at your option) any later version. ++** ++** HISTORY ++** $Date $Author $Comment ++** 2 Nov 2006 Lin Mars init version which derived from LzmaTest.c from ++** LZMA v4.43 SDK ++*******************************************************************************/ ++#define LZMA_NO_STDIO ++#ifndef LZMA_NO_STDIO ++#include <stdio.h> ++#include <stdlib.h> ++#include <string.h> ++#endif ++ ++#include <config.h> ++#include <common.h> ++#include <linux/types.h> ++#include <linux/string.h> ++#include <linux/ctype.h> ++#include <malloc.h> ++ ++#ifdef CONFIG_LZMA ++ ++#include "LzmaDecode.h" ++#include "LzmaWrapper.h" ++ ++static const char *kCantReadMessage = "Can not read from source buffer"; ++static const char *kCantAllocateMessage = "Not enough buffer for decompression"; ++ ++static size_t rpos=0, dpos=0; ++ ++static int MyReadFileAndCheck(unsigned char *src, void *dest, size_t size) ++{ ++ if (size == 0) ++ return 0; ++ memcpy(dest, src + rpos, size); ++ rpos += size; ++ return 1; ++} ++ ++int lzma_inflate(unsigned char *source, int s_len, unsigned char *dest, int *d_len) ++{ ++ /* We use two 32-bit integers to construct 64-bit integer for file size. ++ You can remove outSizeHigh, if you don't need >= 4GB supporting, ++ or you can use UInt64 outSize, if your compiler supports 64-bit integers*/ ++ UInt32 outSize = 0; ++ UInt32 outSizeHigh = 0; ++ SizeT outSizeFull; ++ unsigned char *outStream; ++ ++ int waitEOS = 1; ++ /* waitEOS = 1, if there is no uncompressed size in headers, ++ so decoder will wait EOS (End of Stream Marker) in compressed stream */ ++ ++ SizeT compressedSize; ++ unsigned char *inStream; ++ ++ CLzmaDecoderState state; /* it's about 24-80 bytes structure, if int is 32-bit */ ++ unsigned char properties[LZMA_PROPERTIES_SIZE]; ++ ++ int res; ++ ++ if (sizeof(UInt32) < 4) ++ { ++ printf("LZMA decoder needs correct UInt32\n"); ++ return LZMA_RESULT_DATA_ERROR; ++ } ++ ++ { ++ long length=s_len; ++ if ((long)(SizeT)length != length) ++ { ++ printf("Too big compressed stream\n"); ++ return LZMA_RESULT_DATA_ERROR; ++ } ++ compressedSize = (SizeT)(length - (LZMA_PROPERTIES_SIZE + 8)); ++ } ++ ++ /* Read LZMA properties for compressed stream */ ++ ++ if (!MyReadFileAndCheck(source, properties, sizeof(properties))) ++ { ++ printf("%s\n", kCantReadMessage); ++ return LZMA_RESULT_DATA_ERROR; ++ } ++ ++ /* Read uncompressed size */ ++ { ++ int i; ++ for (i = 0; i < 8; i++) ++ { ++ unsigned char b; ++ if (!MyReadFileAndCheck(source, &b, 1)) ++ { ++ printf("%s\n", kCantReadMessage); ++ return LZMA_RESULT_DATA_ERROR; ++ } ++ if (b != 0xFF) ++ waitEOS = 0; ++ if (i < 4) ++ outSize += (UInt32)(b) << (i * 8); ++ else ++ outSizeHigh += (UInt32)(b) << ((i - 4) * 8); ++ } ++ ++ if (waitEOS) ++ { ++ printf("Stream with EOS marker is not supported"); ++ return LZMA_RESULT_DATA_ERROR; ++ } ++ outSizeFull = (SizeT)outSize; ++ if (sizeof(SizeT) >= 8) ++ outSizeFull |= (((SizeT)outSizeHigh << 16) << 16); ++ else if (outSizeHigh != 0 || (UInt32)(SizeT)outSize != outSize) ++ { ++ printf("Too big uncompressed stream"); ++ return LZMA_RESULT_DATA_ERROR; ++ } ++ } ++ ++ /* Decode LZMA properties and allocate memory */ ++ if (LzmaDecodeProperties(&state.Properties, properties, LZMA_PROPERTIES_SIZE) != LZMA_RESULT_OK) ++ { ++ printf("Incorrect stream properties"); ++ return LZMA_RESULT_DATA_ERROR; ++ } ++ state.Probs = (CProb *)malloc(LzmaGetNumProbs(&state.Properties) * sizeof(CProb)); ++ ++ if (outSizeFull == 0) ++ outStream = 0; ++ else ++ { ++ if (outSizeFull > d_len) ++ outStream = 0; ++ else ++ outStream = dest; ++ } ++ ++ if (compressedSize == 0) ++ inStream = 0; ++ else ++ { ++ if ((compressedSize+rpos) > s_len ) ++ inStream = 0; ++ else ++ inStream = source + rpos; ++ } ++ ++ if (state.Probs == 0 ++ || (outStream == 0 && outSizeFull != 0) ++ || (inStream == 0 && compressedSize != 0) ++ ) ++ { ++ free(state.Probs); ++ printf("%s\n", kCantAllocateMessage); ++ return LZMA_RESULT_DATA_ERROR; ++ } ++ ++ /* Decompress */ ++ { ++ SizeT inProcessed; ++ SizeT outProcessed; ++ res = LzmaDecode(&state, ++ inStream, compressedSize, &inProcessed, ++ outStream, outSizeFull, &outProcessed); ++ if (res != 0) ++ { ++ printf("\nDecoding error = %d\n", res); ++ res = 1; ++ } ++ else ++ { ++ *d_len = outProcessed; ++ } ++ } ++ ++ free(state.Probs); ++ return res; ++} ++ ++#endif /* CONFIG_LZMA */ +diff --git a/lib_generic/Makefile b/lib_generic/Makefile +index abee19a..449e994 100644 +--- a/lib_generic/Makefile ++++ b/lib_generic/Makefile +@@ -41,6 +41,8 @@ COBJS-y += sha1.o + COBJS-y += string.o + COBJS-y += vsprintf.o + COBJS-y += zlib.o ++COBJS-y += LzmaDecode.o ++COBJS-y += LzmaWrapper.o + + COBJS := $(COBJS-y) + SRCS := $(COBJS:.o=.c) +-- +1.5.3.2 + diff --git a/target/linux/avr32/image/u-boot/patches/100-ngw100_enable_lzma_support.patch b/target/linux/avr32/image/u-boot/patches/100-ngw100_enable_lzma_support.patch new file mode 100644 index 0000000000..5ff91b8f6f --- /dev/null +++ b/target/linux/avr32/image/u-boot/patches/100-ngw100_enable_lzma_support.patch @@ -0,0 +1,12 @@ +Index: u-boot-1.3.3/include/configs/atngw100.h +=================================================================== +--- u-boot-1.3.3.orig/include/configs/atngw100.h ++++ u-boot-1.3.3/include/configs/atngw100.h +@@ -60,6 +60,7 @@ + + /* User serviceable stuff */ + #define CONFIG_DOS_PARTITION 1 ++#define CONFIG_LZMA 1 + + #define CONFIG_CMDLINE_TAG 1 + #define CONFIG_SETUP_MEMORY_TAGS 1 |