diff options
| -rw-r--r-- | target/linux/generic-2.6/patches/600-x86_lzma.patch | 1167 |
1 files changed, 1167 insertions, 0 deletions
diff --git a/target/linux/generic-2.6/patches/600-x86_lzma.patch b/target/linux/generic-2.6/patches/600-x86_lzma.patch new file mode 100644 index 000000000..1a948839b --- /dev/null +++ b/target/linux/generic-2.6/patches/600-x86_lzma.patch @@ -0,0 +1,1167 @@ +diff -Naur linux-old/arch/i386/boot/compressed/LzmaDecode.c linux-lzma/arch/i386/boot/compressed/LzmaDecode.c +--- linux-old/arch/i386/boot/compressed/LzmaDecode.c 1969-12-31 19:00:00.000000000 -0500 ++++ linux-lzma/arch/i386/boot/compressed/LzmaDecode.c 2005-06-05 00:07:38.000000000 -0400 +@@ -0,0 +1,586 @@ ++/* ++ LzmaDecode.c ++ LZMA Decoder (optimized for Speed version) ++ ++ LZMA SDK 4.17 Copyright (c) 1999-2005 Igor Pavlov (2005-04-05) ++ 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) \ ++ { UInt32 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 ++ ++#ifdef _LZMA_OUT_READ ++ ++typedef struct _LzmaVarState ++{ ++ Byte *Buffer; ++ Byte *BufferLim; ++ UInt32 Range; ++ UInt32 Code; ++ #ifdef _LZMA_IN_CB ++ ILzmaInCallback *InCallback; ++ #endif ++ Byte *Dictionary; ++ UInt32 DictionarySize; ++ UInt32 DictionaryPos; ++ UInt32 GlobalPos; ++ UInt32 Reps[4]; ++ int lc; ++ int lp; ++ int pb; ++ int State; ++ int RemainLen; ++ Byte TempDictionary[4]; ++} LzmaVarState; ++ ++int LzmaDecoderInit( ++ unsigned char *buffer, UInt32 bufferSize, ++ int lc, int lp, int pb, ++ unsigned char *dictionary, UInt32 dictionarySize, ++ #ifdef _LZMA_IN_CB ++ ILzmaInCallback *InCallback ++ #else ++ unsigned char *inStream, UInt32 inSize ++ #endif ++ ) ++{ ++ Byte *Buffer; ++ Byte *BufferLim; ++ UInt32 Range; ++ UInt32 Code; ++ LzmaVarState *vs = (LzmaVarState *)buffer; ++ CProb *p = (CProb *)(buffer + sizeof(LzmaVarState)); ++ UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + lp)); ++ UInt32 i; ++ if (bufferSize < numProbs * sizeof(CProb) + sizeof(LzmaVarState)) ++ return LZMA_RESULT_NOT_ENOUGH_MEM; ++ vs->Dictionary = dictionary; ++ vs->DictionarySize = dictionarySize; ++ vs->DictionaryPos = 0; ++ vs->GlobalPos = 0; ++ vs->Reps[0] = vs->Reps[1] = vs->Reps[2] = vs->Reps[3] = 1; ++ vs->lc = lc; ++ vs->lp = lp; ++ vs->pb = pb; ++ vs->State = 0; ++ vs->RemainLen = 0; ++ dictionary[dictionarySize - 1] = 0; ++ for (i = 0; i < numProbs; i++) ++ p[i] = kBitModelTotal >> 1; ++ ++ #ifdef _LZMA_IN_CB ++ RC_INIT; ++ #else ++ RC_INIT(inStream, inSize); ++ #endif ++ vs->Buffer = Buffer; ++ vs->BufferLim = BufferLim; ++ vs->Range = Range; ++ vs->Code = Code; ++ #ifdef _LZMA_IN_CB ++ vs->InCallback = InCallback; ++ #endif ++ ++ return LZMA_RESULT_OK; ++} ++ ++int LzmaDecode(unsigned char *buffer, ++ unsigned char *outStream, UInt32 outSize, ++ UInt32 *outSizeProcessed) ++{ ++ LzmaVarState *vs = (LzmaVarState *)buffer; ++ Byte *Buffer = vs->Buffer; ++ Byte *BufferLim = vs->BufferLim; ++ UInt32 Range = vs->Range; ++ UInt32 Code = vs->Code; ++ #ifdef _LZMA_IN_CB ++ ILzmaInCallback *InCallback = vs->InCallback; ++ #endif ++ CProb *p = (CProb *)(buffer + sizeof(LzmaVarState)); ++ int state = vs->State; ++ Byte previousByte; ++ UInt32 rep0 = vs->Reps[0], rep1 = vs->Reps[1], rep2 = vs->Reps[2], rep3 = vs->Reps[3]; ++ UInt32 nowPos = 0; ++ UInt32 posStateMask = (1 << (vs->pb)) - 1; ++ UInt32 literalPosMask = (1 << (vs->lp)) - 1; ++ int lc = vs->lc; ++ int len = vs->RemainLen; ++ UInt32 globalPos = vs->GlobalPos; ++ ++ Byte *dictionary = vs->Dictionary; ++ UInt32 dictionarySize = vs->DictionarySize; ++ UInt32 dictionaryPos = vs->DictionaryPos; ++ ++ Byte tempDictionary[4]; ++ if (dictionarySize == 0) ++ { ++ dictionary = tempDictionary; ++ dictionarySize = 1; ++ tempDictionary[0] = vs->TempDictionary[0]; ++ } ++ ++ if (len == -1) ++ { ++ *outSizeProcessed = 0; ++ return LZMA_RESULT_OK; ++ } ++ ++ 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 ++ ++int LzmaDecode( ++ Byte *buffer, UInt32 bufferSize, ++ int lc, int lp, int pb, ++ #ifdef _LZMA_IN_CB ++ ILzmaInCallback *InCallback, ++ #else ++ unsigned char *inStream, UInt32 inSize, ++ #endif ++ unsigned char *outStream, UInt32 outSize, ++ UInt32 *outSizeProcessed) ++{ ++ UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + lp)); ++ CProb *p = (CProb *)buffer; ++ ++ UInt32 i; ++ int state = 0; ++ Byte previousByte = 0; ++ UInt32 rep0 = 1, rep1 = 1, rep2 = 1, rep3 = 1; ++ UInt32 nowPos = 0; ++ UInt32 posStateMask = (1 << pb) - 1; ++ UInt32 literalPosMask = (1 << lp) - 1; ++ int len = 0; ++ ++ Byte *Buffer; ++ Byte *BufferLim; ++ UInt32 Range; ++ UInt32 Code; ++ ++ if (bufferSize < numProbs * sizeof(CProb)) ++ return LZMA_RESULT_NOT_ENOUGH_MEM; ++ for (i = 0; i < numProbs; i++) ++ p[i] = kBitModelTotal >> 1; ++ ++ ++ #ifdef _LZMA_IN_CB ++ RC_INIT; ++ #else ++ RC_INIT(inStream, inSize); ++ #endif ++#endif ++ ++ *outSizeProcessed = 0; ++ 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 ++ 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); ++ if (nowPos ++ #ifdef _LZMA_OUT_READ ++ + globalPos ++ #endif ++ == 0) ++ 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; ++ 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 = -1; ++ break; ++ } ++ } ++ ++ len += kMatchMinLen; ++ if (rep0 > nowPos ++ #ifdef _LZMA_OUT_READ ++ + globalPos || rep0 > dictionarySize ++ #endif ++ ) ++ return LZMA_RESULT_DATA_ERROR; ++ 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->Buffer = Buffer; ++ vs->BufferLim = BufferLim; ++ vs->Range = Range; ++ vs->Code = Code; ++ vs->DictionaryPos = dictionaryPos; ++ vs->GlobalPos = globalPos + nowPos; ++ 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 ++ ++ *outSizeProcessed = nowPos; ++ return LZMA_RESULT_OK; ++} +diff -Naur linux-old/arch/i386/boot/compressed/LzmaDecode.h linux-lzma/arch/i386/boot/compressed/LzmaDecode.h +--- linux-old/arch/i386/boot/compressed/LzmaDecode.h 1969-12-31 19:00:00.000000000 -0500 ++++ linux-lzma/arch/i386/boot/compressed/LzmaDecode.h 2005-06-05 00:07:39.000000000 -0400 +@@ -0,0 +1,100 @@ ++/* ++ LzmaDecode.h ++ LZMA Decoder interface ++ ++ LZMA SDK 4.16 Copyright (c) 1999-2005 Igor Pavlov (2005-03-18) ++ 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 */ ++ ++#ifndef UInt32 ++#ifdef _LZMA_UINT32_IS_ULONG ++#define UInt32 unsigned long ++#else ++#define UInt32 unsigned int ++#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 ++#define LZMA_RESULT_NOT_ENOUGH_MEM 2 ++ ++#ifdef _LZMA_IN_CB ++typedef struct _ILzmaInCallback ++{ ++ int (*Read)(void *object, unsigned char **buffer, UInt32 *bufferSize); ++} ILzmaInCallback; ++#endif ++ ++#define LZMA_BASE_SIZE 1846 ++#define LZMA_LIT_SIZE 768 ++ ++/* ++bufferSize = (LZMA_BASE_SIZE + (LZMA_LIT_SIZE << (lc + lp)))* sizeof(CProb) ++bufferSize += 100 in case of _LZMA_OUT_READ ++by default CProb is unsigned short, ++but if specify _LZMA_PROB_32, CProb will be UInt32(unsigned int) ++*/ ++ ++#ifdef _LZMA_OUT_READ ++int LzmaDecoderInit( ++ unsigned char *buffer, UInt32 bufferSize, ++ int lc, int lp, int pb, ++ unsigned char *dictionary, UInt32 dictionarySize, ++ #ifdef _LZMA_IN_CB ++ ILzmaInCallback *inCallback ++ #else ++ unsigned char *inStream, UInt32 inSize ++ #endif ++); ++#endif ++ ++int LzmaDecode( ++ unsigned char *buffer, ++ #ifndef _LZMA_OUT_READ ++ UInt32 bufferSize, ++ int lc, int lp, int pb, ++ #ifdef _LZMA_IN_CB ++ ILzmaInCallback *inCallback, ++ #else ++ unsigned char *inStream, UInt32 inSize, ++ #endif ++ #endif ++ unsigned char *outStream, UInt32 outSize, ++ UInt32 *outSizeProcessed); ++ ++#endif +diff -Naur linux-old/arch/i386/boot/compressed/Makefile linux-lzma/arch/i386/boot/compressed/Makefile +--- linux-old/arch/i386/boot/compressed/Makefile 2005-06-04 21:53:40.000000000 -0400 ++++ linux-lzma/arch/i386/boot/compressed/Makefile 2005-06-05 00:25:23.000000000 -0400 +@@ -2,24 +2,33 @@ + # linux/arch/i386/boot/compressed/Makefile + # + # create a compressed vmlinux image from the original vmlinux ++# patched by Ming-Ching Tiew <mctiew@yahoo.com> for kernel 2.6 ++# requires program 'lzma' from LZMA SDK ( http://www.7-zip.org/ ) to work ++# $ mkdir lzma ++# $ cd lzma ++# $ tar tvjf ../lzma417.tar.bz2 ++# $ cd SRC/7zip/Compress/LZMA_Alone ++# $ dos2unix makefile ++# $ make ++# $ su ++# # cp lzma /usr/bin + # +- +-targets := vmlinux vmlinux.bin vmlinux.bin.gz head.o misc.o piggy.o ++targets := vmlinux vmlinux.bin vmlinux.bin.lzma head.o lzma_misc.o piggy.o + EXTRA_AFLAGS := -traditional + + LDFLAGS_vmlinux := -Ttext $(IMAGE_OFFSET) -e startup_32 + +-$(obj)/vmlinux: $(obj)/head.o $(obj)/misc.o $(obj)/piggy.o FORCE ++$(obj)/vmlinux: $(obj)/head.o $(obj)/lzma_misc.o $(obj)/piggy.o FORCE + $(call if_changed,ld) + @: + + $(obj)/vmlinux.bin: vmlinux FORCE + $(call if_changed,objcopy) + +-$(obj)/vmlinux.bin.gz: $(obj)/vmlinux.bin FORCE +- $(call if_changed,gzip) ++$(obj)/vmlinux.bin.lzma: $(obj)/vmlinux.bin FORCE ++ $(call if_changed,lzma) + + LDFLAGS_piggy.o := -r --format binary --oformat elf32-i386 -T + +-$(obj)/piggy.o: $(obj)/vmlinux.scr $(obj)/vmlinux.bin.gz FORCE ++$(obj)/piggy.o: $(obj)/vmlinux.scr $(obj)/vmlinux.bin.lzma FORCE + $(call if_changed,ld) +diff -Naur linux-old/arch/i386/boot/compressed/lzma_misc.c linux-lzma/arch/i386/boot/compressed/lzma_misc.c +--- linux-old/arch/i386/boot/compressed/lzma_misc.c 1969-12-31 19:00:00.000000000 -0500 ++++ linux-lzma/arch/i386/boot/compressed/lzma_misc.c 2005-06-04 21:33:48.000000000 -0400 +@@ -0,0 +1,412 @@ ++/* ++ * lzma_misc.c ++ * ++ * Decompress LZMA compressed vmlinuz ++ * Version 0.9 Copyright (c) Ming-Ching Tiew mctiew@yahoo.com ++ * Program adapted from misc.c for 2.6 kernel ++ * Date: 3 June 2005 ++ * Source released under GPL ++ */ ++ ++#include <linux/linkage.h> ++#include <linux/vmalloc.h> ++#include <linux/tty.h> ++#include <linux/screen_info.h> ++#include <asm/io.h> ++ ++#define OF(args) args ++#define STATIC static ++ ++#undef memset ++#undef memcpy ++ ++/* ++ * Why do we do this? Don't ask me.. ++ * ++ * Incomprehensible are the ways of bootloaders. ++ */ ++static void* memcpy(void *, __const void *, size_t); ++ ++typedef unsigned char uch; ++typedef unsigned short ush; ++typedef unsigned long ulg; ++ ++#define WSIZE 0x8000 /* Window size must be at least 32k, */ ++ /* and a power of two */ ++ ++static uch *inbuf; /* input buffer */ ++ ++static unsigned insize = 0; /* valid bytes in inbuf */ ++static unsigned inptr = 0; /* index of next byte to be processed in inbuf */ ++ ++#define get_byte() (inptr < insize ? inbuf[inptr++] : fill_inbuf()) ++ ++/* Diagnostic functions */ ++#ifdef DEBUG ++# define Assert(cond,msg) {if(!(cond)) error(msg);} ++# define Trace(x) fprintf x ++# define Tracev(x) {if (verbose) fprintf x ;} ++# define Tracevv(x) {if (verbose>1) fprintf x ;} ++# define Tracec(c,x) {if (verbose && (c)) fprintf x ;} ++# define Tracecv(c,x) {if (verbose>1 && (c)) fprintf x ;} ++#else ++# define Assert(cond,msg) ++# define Trace(x) ++# define Tracev(x) ++# define Tracevv(x) ++# define Tracec(c,x) ++# define Tracecv(c,x) ++#endif ++ ++static int fill_inbuf(void); ++static void error(char *m); ++ ++/* ++ * This is set up by the setup-routine at boot-time ++ */ ++static unsigned char *real_mode; /* Pointer to real-mode data */ ++ ++#define RM_EXT_MEM_K (*(unsigned short *)(real_mode + 0x2)) ++#ifndef STANDARD_MEMORY_BIOS_CALL ++#define RM_ALT_MEM_K (*(unsigned long *)(real_mode + 0x1e0)) ++#endif ++#define RM_SCREEN_INFO (*(struct screen_info *)(real_mode+0)) ++ ++extern char input_data[]; ++extern int input_len; ++ ++static long bytes_out = 0; ++static uch *output_data; ++ ++static void putstr(const char *); ++ ++extern int end; ++static long free_mem_ptr = (long)&end; ++static long free_mem_end_ptr; ++ ++#define INPLACE_MOVE_ROUTINE 0x1000 ++#define LOW_BUFFER_START 0x2000 ++#define LOW_BUFFER_MAX 0x90000 ++#define HEAP_SIZE 0x3000 ++static unsigned int low_buffer_end, low_buffer_size; ++static int high_loaded =0; ++static uch *high_buffer_start /* = (uch *)(((ulg)&end) + HEAP_SIZE)*/; ++ ++static char *vidmem = (char *)0xb8000; ++static int vidport; ++static int lines, cols; ++ ++static void scroll(void) ++{ ++ int i; ++ ++ memcpy ( vidmem, vidmem + cols * 2, ( lines - 1 ) * cols * 2 ); ++ for ( i = ( lines - 1 ) * cols * 2; i < lines * cols * 2; i += 2 ) ++ vidmem[i] = ' '; ++} ++ ++static void putstr(const char *s) ++{ ++ int x,y,pos; ++ char c; ++ ++ x = RM_SCREEN_INFO.orig_x; ++ y = RM_SCREEN_INFO.orig_y; ++ ++ while ( ( c = *s++ ) != '\0' ) { ++ if ( c == '\n' ) { ++ x = 0; ++ if ( ++y >= lines ) { ++ scroll(); ++ y--; ++ } ++ } else { ++ vidmem [ ( x + cols * y ) * 2 ] = c; ++ if ( ++x >= cols ) { ++ x = 0; ++ if ( ++y >= lines ) { ++ scroll(); ++ y--; ++ } ++ } ++ } ++ } ++ ++ RM_SCREEN_INFO.orig_x = x; ++ RM_SCREEN_INFO.orig_y = y; ++ ++ pos = (x + cols * y) * 2; /* Update cursor position */ ++ outb_p(14, vidport); ++ outb_p(0xff & (pos >> 9), vidport+1); ++ outb_p(15, vidport); ++ outb_p(0xff & (pos >> 1), vidport+1); ++} ++ ++static void* memcpy(void* __dest, __const void* __src, ++ size_t __n) ++{ ++ int i; ++ char *d = (char *)__dest, *s = (char *)__src; ++ ++ for (i=0;i<__n;i++) d[i] = s[i]; ++ return __dest; ++} ++ ++/* =========================================================================== ++ * Fill the input buffer. This is called only when the buffer is empty ++ * and at least one byte is really needed. ++ */ ++static int fill_inbuf(void) ++{ ++ if (insize != 0) { ++ error("ran out of input data"); ++ } ++ ++ inbuf = input_data; ++ insize = input_len; ++ inptr = 1; ++ return inbuf[0]; ++} ++ ++static void error(char *x) ++{ ++ putstr("\n\n"); ++ putstr(x); ++ putstr("\n\n -- System halted"); ++ ++ while(1); /* Halt */ ++} ++ ++#define STACK_SIZE (4096) ++ ++long user_stack [STACK_SIZE]; ++ ++struct { ++ long * a; ++ short b; ++ } stack_start = { & user_stack [STACK_SIZE] , __BOOT_DS }; ++ ++static void setup_normal_output_buffer(void) ++{ ++#ifdef STANDARD_MEMORY_BIOS_CALL ++ if (RM_EXT_MEM_K < 1024) error("Less than 2MB of memory"); ++#else ++ if ((RM_ALT_MEM_K > RM_EXT_MEM_K ? RM_ALT_MEM_K : RM_EXT_MEM_K) < 1024) error("Less than 2MB of memory"); ++#endif ++ output_data = (char *)0x100000; /* Points to 1M */ ++ free_mem_end_ptr = (long)real_mode; ++} ++ ++struct moveparams { ++ uch *low_buffer_start; int lcount; ++ uch *high_buffer_start; int hcount; ++}; ++ ++static void setup_output_buffer_if_we_run_high(struct moveparams *mv) ++{ ++ high_buffer_start = (uch *)(((ulg)&end) + HEAP_SIZE); ++#ifdef STANDARD_MEMORY_BIOS_CALL ++ if (RM_EXT_MEM_K < (3*1024)) error("Less than 4MB of memory"); ++#else ++ if ((RM_ALT_MEM_K > RM_EXT_MEM_K ? RM_ALT_MEM_K : RM_EXT_MEM_K) < ++ (3*1024)) ++ error("Less than 4MB of memory"); ++#endif ++ mv->low_buffer_start = output_data = (char *)LOW_BUFFER_START; ++ low_buffer_end = ((unsigned int)real_mode > LOW_BUFFER_MAX ++ ? LOW_BUFFER_MAX : (unsigned int)real_mode) & ~0xfff; ++ low_buffer_size = low_buffer_end - LOW_BUFFER_START; ++ high_loaded = 1; ++ free_mem_end_ptr = (long)high_buffer_start; ++ if ( (0x100000 + low_buffer_size) > ((ulg)high_buffer_start)) { ++ high_buffer_start = (uch *)(0x100000 + low_buffer_size); ++ mv->hcount = 0; /* say: we need not to move high_buffer */ ++ } ++ else mv->hcount = -1; ++ mv->high_buffer_start = high_buffer_start; ++} ++ ++static void close_output_buffer_if_we_run_high(struct moveparams *mv) ++{ ++ if (bytes_out > low_buffer_size) { ++ mv->lcount = low_buffer_size; ++ if (mv->hcount) ++ mv->hcount = bytes_out - low_buffer_size; ++ } else { ++ mv->lcount = bytes_out; ++ mv->hcount = 0; ++ } ++} ++ ++// When using LZMA in callback, the compressed length is not needed. ++// Otherwise you need a special version of lzma compression program ++// which will pad the compressed length in the header. ++#define _LZMA_IN_CB ++#include "LzmaDecode.h" ++#include "LzmaDecode.c" ++ ++#ifdef _LZMA_IN_CB ++static int read_byte(void *object, unsigned char **buffer, UInt32 *bufferSize); ++#endif ++ ++ ++/* ++ * Do the lzma decompression ++ * When using LZMA in callback, the end of input stream is automatically determined ++ */ ++static int lzma_unzip(void) ++{ ++ ++ unsigned int i; /* temp value */ ++ unsigned int lc; /* literal context bits */ ++ unsigned int lp; /* literal pos state bits */ ++ unsigned int pb; /* pos state bits */ ++ unsigned char* workspace; ++ unsigned int uncompressedSize = 0; ++ unsigned char* p; ++ ++#ifdef _LZMA_IN_CB ++ ILzmaInCallback callback; ++ callback.Read = read_byte; ++#else ++ unsigned char* inputbuf; ++ unsigned int lzma_workspace_size; ++ unsigned int compressedSize = 0; ++#endif ++ ++ /* lzma args */ ++ i = get_byte(); ++ lc = i % 9, i = i / 9; ++ lp = i % 5, pb = i / 5; ++ ++ /* skip dictionary size */ ++ for (i = 0; i < 4; i++) ++ get_byte(); ++ // get uncompressedSize ++ p= (char*)&uncompressedSize; ++ for (i = 0; i < 4; i++) ++ *p++ = get_byte(); ++ ++ //get compressedSize ++#ifdef _LZMA_IN_CB ++ for (i = 0; i < 4; i++) ++ get_byte(); ++#else ++ p= (char*)&compressedSize; ++ for (i = 0; i < 4; i++) ++ *p++ = get_byte(); ++#endif ++ ++#if 0 ++ if ( (lc == 5 ) && (lp == 0 ) && ( pb == 0 )) ++ { ++ putstr("got prop!\n"); ++ } ++ ++#ifndef _LZMA_IN_CB ++ if( compressedSize == 496722 ) ++ { ++ putstr( "got the right sizes\n"); ++ } ++ else if ( compressedSize > 496722 ) ++ { ++ putstr( "greater !\n"); ++ } ++ else if ( compressedSize < 496722 ) ++ putstr( "smaller!\n"); ++ ++#endif ++ if ( uncompressedSize == 1187168 ) ++ { ++ putstr( "got the right uncompressed size \n"); ++ }else if ( uncompressedSize > 1187168 ) ++ { ++ putstr( "uncompressedSize greater!\n"); ++ }else ++ putstr( "uncompressedSize smaller!|n"); ++#endif ++ ++ // point it beyond uncompresedSize ++ workspace = high_buffer_start + uncompressedSize; ++ // ++#ifndef _LZMA_IN_CB ++ lzma_workspace_size = (LZMA_BASE_SIZE + (LZMA_LIT_SIZE << (lc + lp))) * sizeof(CProb); ++ inputbuf = high_buffer_start + uncompressedSize + lzma_workspace_size; ++ // read the compressed data ++ for( i=0; i < compressedSize; i++) ++ { ++ if ( i % ( 1024 * 10 ) == 0 ) ++ putstr("."); ++ *inputbuf++ = get_byte(); ++ } ++#endif ++ ++ /* decompress kernel */ ++#ifdef _LZMA_IN_CB ++ if (LzmaDecode(workspace, ~0, lc, lp, pb, ++ &callback, ++#else ++ if (LzmaDecode(workspace, lzma_workspace_size, lc, lp, pb, ++ inputbuf - compressedSize, compressedSize, ++#endif ++ (unsigned char*)high_buffer_start, uncompressedSize, &i) == LZMA_RESULT_OK) ++ { ++ if ( i != uncompressedSize ) ++ error( "kernel corrupted!\n"); ++ //copy it back to low_buffer ++ if( uncompressedSize > low_buffer_size ) ++ { ++ memcpy((char*)LOW_BUFFER_START, high_buffer_start, low_buffer_size); ++ memcpy(high_buffer_start, high_buffer_start+low_buffer_size, ++ uncompressedSize-low_buffer_size); ++ } ++ else ++ memcpy((char*)LOW_BUFFER_START, high_buffer_start, uncompressedSize ); ++ bytes_out = i; ++ return 0; ++ } ++ return 1; ++} ++ ++ ++#ifdef _LZMA_IN_CB ++static int read_byte(void *object, unsigned char **buffer, UInt32 *bufferSize) ++{ ++ static unsigned int i = 0; ++ static unsigned char val; ++ *bufferSize = 1; ++ val = get_byte(); ++ *buffer = &val; ++ if ( i++ % ( 1024 * 50 ) == 0 ) ++ putstr("."); ++ return LZMA_RESULT_OK; ++} ++#endif ++ ++asmlinkage int decompress_kernel(struct moveparams *mv, void *rmode) ++{ ++ real_mode = rmode; ++ ++ if (RM_SCREEN_INFO.orig_video_mode == 7) { ++ vidmem = (char *) 0xb0000; ++ vidport = 0x3b4; ++ } else { ++ vidmem = (char *) 0xb8000; ++ vidport = 0x3d4; ++ } ++ ++ lines = RM_SCREEN_INFO.orig_video_lines; ++ cols = RM_SCREEN_INFO.orig_video_cols; ++ ++ if (free_mem_ptr < 0x100000) setup_normal_output_buffer(); ++ else setup_output_buffer_if_we_run_high(mv); ++ ++ putstr("LZMA vmlinuz: Ming-Ching Tiew <mctiew@yahoo.com> ..."); ++ if( lzma_unzip() != 0 ) ++ { ++ error("inflate error\n"); ++ } ++ putstr("Ok, booting the kernel.\n"); ++ if (high_loaded) close_output_buffer_if_we_run_high(mv); ++ return high_loaded; ++} +diff -urN linux-2.6.19.2/scripts/Makefile.lib linux-2.6.19.2.new/scripts/Makefile.lib +--- linux-2.6.19.2/scripts/Makefile.lib 2007-01-10 20:10:37.000000000 +0100 ++++ linux-2.6.19.2.new/scripts/Makefile.lib 2007-04-15 23:51:54.000000000 +0200 +@@ -162,4 +162,9 @@ + quiet_cmd_gzip = GZIP $@ + cmd_gzip = gzip -f -9 < $< > $@ + +- ++# LZMA ++# ++quiet_cmd_lzma = LZMA $@ ++cmd_lzma = lzma e $< $@ -lc7 -lp0 -pb0 ++# to use lzmacomp, ++# cmd_lzma = lzmacomp $< 700 > $@ |