Commit | Line | Data |
---|---|---|
4e1a33b1 SS |
1 | #ifndef __LZ4DEFS_H__ |
2 | #define __LZ4DEFS_H__ | |
3 | ||
cffb78b0 | 4 | /* |
4e1a33b1 SS |
5 | * lz4defs.h -- common and architecture specific defines for the kernel usage |
6 | ||
7 | * LZ4 - Fast LZ compression algorithm | |
8 | * Copyright (C) 2011-2016, Yann Collet. | |
9 | * BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) | |
10 | * Redistribution and use in source and binary forms, with or without | |
11 | * modification, are permitted provided that the following conditions are | |
12 | * met: | |
13 | * * Redistributions of source code must retain the above copyright | |
14 | * notice, this list of conditions and the following disclaimer. | |
15 | * * Redistributions in binary form must reproduce the above | |
16 | * copyright notice, this list of conditions and the following disclaimer | |
17 | * in the documentation and/or other materials provided with the | |
18 | * distribution. | |
19 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
20 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
21 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
22 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
23 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
24 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
25 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
26 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
27 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
28 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
29 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
30 | * You can contact the author at : | |
31 | * - LZ4 homepage : http://www.lz4.org | |
32 | * - LZ4 source repository : https://github.com/lz4/lz4 | |
cffb78b0 | 33 | * |
4e1a33b1 SS |
34 | * Changed for kernel usage by: |
35 | * Sven Schmidt <4sschmid@informatik.uni-hamburg.de> | |
cffb78b0 KL |
36 | */ |
37 | ||
4e1a33b1 SS |
38 | #include <asm/unaligned.h> |
39 | #include <linux/string.h> /* memset, memcpy */ | |
40 | ||
41 | #define FORCE_INLINE __always_inline | |
42 | ||
43 | /*-************************************ | |
44 | * Basic Types | |
45 | **************************************/ | |
46 | #include <linux/types.h> | |
47 | ||
48 | typedef uint8_t BYTE; | |
49 | typedef uint16_t U16; | |
50 | typedef uint32_t U32; | |
51 | typedef int32_t S32; | |
52 | typedef uint64_t U64; | |
53 | typedef uintptr_t uptrval; | |
54 | ||
55 | /*-************************************ | |
56 | * Architecture specifics | |
57 | **************************************/ | |
3e26a691 | 58 | #if defined(CONFIG_64BIT) |
cffb78b0 KL |
59 | #define LZ4_ARCH64 1 |
60 | #else | |
61 | #define LZ4_ARCH64 0 | |
62 | #endif | |
63 | ||
4e1a33b1 SS |
64 | #if defined(__LITTLE_ENDIAN) |
65 | #define LZ4_LITTLE_ENDIAN 1 | |
66 | #else | |
67 | #define LZ4_LITTLE_ENDIAN 0 | |
cffb78b0 KL |
68 | #endif |
69 | ||
4e1a33b1 SS |
70 | /*-************************************ |
71 | * Constants | |
72 | **************************************/ | |
73 | #define MINMATCH 4 | |
74 | ||
75 | #define WILDCOPYLENGTH 8 | |
76 | #define LASTLITERALS 5 | |
77 | #define MFLIMIT (WILDCOPYLENGTH + MINMATCH) | |
2209fda3 GX |
78 | /* |
79 | * ensure it's possible to write 2 x wildcopyLength | |
80 | * without overflowing output buffer | |
81 | */ | |
82 | #define MATCH_SAFEGUARD_DISTANCE ((2 * WILDCOPYLENGTH) - MINMATCH) | |
4e1a33b1 SS |
83 | |
84 | /* Increase this value ==> compression run slower on incompressible data */ | |
85 | #define LZ4_SKIPTRIGGER 6 | |
86 | ||
87 | #define HASH_UNIT sizeof(size_t) | |
88 | ||
89 | #define KB (1 << 10) | |
90 | #define MB (1 << 20) | |
91 | #define GB (1U << 30) | |
92 | ||
93 | #define MAXD_LOG 16 | |
94 | #define MAX_DISTANCE ((1 << MAXD_LOG) - 1) | |
95 | #define STEPSIZE sizeof(size_t) | |
96 | ||
97 | #define ML_BITS 4 | |
98 | #define ML_MASK ((1U << ML_BITS) - 1) | |
cffb78b0 KL |
99 | #define RUN_BITS (8 - ML_BITS) |
100 | #define RUN_MASK ((1U << RUN_BITS) - 1) | |
4e1a33b1 SS |
101 | |
102 | /*-************************************ | |
103 | * Reading and writing into memory | |
104 | **************************************/ | |
105 | static FORCE_INLINE U16 LZ4_read16(const void *ptr) | |
106 | { | |
107 | return get_unaligned((const U16 *)ptr); | |
108 | } | |
109 | ||
110 | static FORCE_INLINE U32 LZ4_read32(const void *ptr) | |
111 | { | |
112 | return get_unaligned((const U32 *)ptr); | |
113 | } | |
114 | ||
115 | static FORCE_INLINE size_t LZ4_read_ARCH(const void *ptr) | |
116 | { | |
117 | return get_unaligned((const size_t *)ptr); | |
118 | } | |
119 | ||
120 | static FORCE_INLINE void LZ4_write16(void *memPtr, U16 value) | |
121 | { | |
122 | put_unaligned(value, (U16 *)memPtr); | |
123 | } | |
124 | ||
125 | static FORCE_INLINE void LZ4_write32(void *memPtr, U32 value) | |
126 | { | |
127 | put_unaligned(value, (U32 *)memPtr); | |
128 | } | |
129 | ||
130 | static FORCE_INLINE U16 LZ4_readLE16(const void *memPtr) | |
131 | { | |
132 | return get_unaligned_le16(memPtr); | |
133 | } | |
134 | ||
135 | static FORCE_INLINE void LZ4_writeLE16(void *memPtr, U16 value) | |
136 | { | |
137 | return put_unaligned_le16(value, memPtr); | |
138 | } | |
139 | ||
140 | static FORCE_INLINE void LZ4_copy8(void *dst, const void *src) | |
141 | { | |
142 | #if LZ4_ARCH64 | |
143 | U64 a = get_unaligned((const U64 *)src); | |
144 | ||
145 | put_unaligned(a, (U64 *)dst); | |
146 | #else | |
147 | U32 a = get_unaligned((const U32 *)src); | |
148 | U32 b = get_unaligned((const U32 *)src + 1); | |
149 | ||
150 | put_unaligned(a, (U32 *)dst); | |
151 | put_unaligned(b, (U32 *)dst + 1); | |
152 | #endif | |
153 | } | |
154 | ||
155 | /* | |
156 | * customized variant of memcpy, | |
157 | * which can overwrite up to 7 bytes beyond dstEnd | |
158 | */ | |
159 | static FORCE_INLINE void LZ4_wildCopy(void *dstPtr, | |
160 | const void *srcPtr, void *dstEnd) | |
161 | { | |
162 | BYTE *d = (BYTE *)dstPtr; | |
163 | const BYTE *s = (const BYTE *)srcPtr; | |
164 | BYTE *const e = (BYTE *)dstEnd; | |
165 | ||
166 | do { | |
167 | LZ4_copy8(d, s); | |
168 | d += 8; | |
169 | s += 8; | |
170 | } while (d < e); | |
171 | } | |
172 | ||
173 | static FORCE_INLINE unsigned int LZ4_NbCommonBytes(register size_t val) | |
174 | { | |
175 | #if LZ4_LITTLE_ENDIAN | |
176 | return __ffs(val) >> 3; | |
c72ac7a1 | 177 | #else |
4e1a33b1 SS |
178 | return (BITS_PER_LONG - 1 - __fls(val)) >> 3; |
179 | #endif | |
180 | } | |
181 | ||
182 | static FORCE_INLINE unsigned int LZ4_count( | |
183 | const BYTE *pIn, | |
184 | const BYTE *pMatch, | |
185 | const BYTE *pInLimit) | |
186 | { | |
187 | const BYTE *const pStart = pIn; | |
188 | ||
189 | while (likely(pIn < pInLimit - (STEPSIZE - 1))) { | |
190 | size_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn); | |
191 | ||
192 | if (!diff) { | |
193 | pIn += STEPSIZE; | |
194 | pMatch += STEPSIZE; | |
195 | continue; | |
196 | } | |
197 | ||
198 | pIn += LZ4_NbCommonBytes(diff); | |
199 | ||
200 | return (unsigned int)(pIn - pStart); | |
201 | } | |
202 | ||
203 | #if LZ4_ARCH64 | |
204 | if ((pIn < (pInLimit - 3)) | |
205 | && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { | |
206 | pIn += 4; | |
207 | pMatch += 4; | |
208 | } | |
c72ac7a1 | 209 | #endif |
cffb78b0 | 210 | |
4e1a33b1 SS |
211 | if ((pIn < (pInLimit - 1)) |
212 | && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { | |
213 | pIn += 2; | |
214 | pMatch += 2; | |
215 | } | |
cffb78b0 | 216 | |
4e1a33b1 SS |
217 | if ((pIn < pInLimit) && (*pMatch == *pIn)) |
218 | pIn++; | |
cffb78b0 | 219 | |
4e1a33b1 SS |
220 | return (unsigned int)(pIn - pStart); |
221 | } | |
cffb78b0 | 222 | |
4e1a33b1 SS |
223 | typedef enum { noLimit = 0, limitedOutput = 1 } limitedOutput_directive; |
224 | typedef enum { byPtr, byU32, byU16 } tableType_t; | |
c72ac7a1 | 225 | |
4e1a33b1 SS |
226 | typedef enum { noDict = 0, withPrefix64k, usingExtDict } dict_directive; |
227 | typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive; | |
c72ac7a1 | 228 | |
4e1a33b1 | 229 | typedef enum { endOnOutputSize = 0, endOnInputSize = 1 } endCondition_directive; |
2209fda3 GX |
230 | typedef enum { decode_full_block = 0, partial_decode = 1 } earlyEnd_directive; |
231 | ||
232 | #define LZ4_STATIC_ASSERT(c) BUILD_BUG_ON(!(c)) | |
cffb78b0 | 233 | |
4e1a33b1 | 234 | #endif |