Loading...
1/*
2 * Aug 8, 2011 Bob Pearson with help from Joakim Tjernlund and George Spelvin
3 * cleaned up code to current version of sparse and added the slicing-by-8
4 * algorithm to the closely similar existing slicing-by-4 algorithm.
5 *
6 * Oct 15, 2000 Matt Domsch <Matt_Domsch@dell.com>
7 * Nicer crc32 functions/docs submitted by linux@horizon.com. Thanks!
8 * Code was from the public domain, copyright abandoned. Code was
9 * subsequently included in the kernel, thus was re-licensed under the
10 * GNU GPL v2.
11 *
12 * Oct 12, 2000 Matt Domsch <Matt_Domsch@dell.com>
13 * Same crc32 function was used in 5 other places in the kernel.
14 * I made one version, and deleted the others.
15 * There are various incantations of crc32(). Some use a seed of 0 or ~0.
16 * Some xor at the end with ~0. The generic crc32() function takes
17 * seed as an argument, and doesn't xor at the end. Then individual
18 * users can do whatever they need.
19 * drivers/net/smc9194.c uses seed ~0, doesn't xor with ~0.
20 * fs/jffs2 uses seed 0, doesn't xor with ~0.
21 * fs/partitions/efi.c uses seed ~0, xor's with ~0.
22 *
23 * This source code is licensed under the GNU General Public License,
24 * Version 2. See the file COPYING for more details.
25 */
26
27/* see: Documentation/staging/crc32.rst for a description of algorithms */
28
29#include <linux/crc32.h>
30#include <linux/crc32poly.h>
31#include <linux/module.h>
32#include <linux/types.h>
33#include <linux/sched.h>
34#include "crc32defs.h"
35
36#if CRC_LE_BITS > 8
37# define tole(x) ((__force u32) cpu_to_le32(x))
38#else
39# define tole(x) (x)
40#endif
41
42#if CRC_BE_BITS > 8
43# define tobe(x) ((__force u32) cpu_to_be32(x))
44#else
45# define tobe(x) (x)
46#endif
47
48#include "crc32table.h"
49
50MODULE_AUTHOR("Matt Domsch <Matt_Domsch@dell.com>");
51MODULE_DESCRIPTION("Various CRC32 calculations");
52MODULE_LICENSE("GPL");
53
54#if CRC_LE_BITS > 8 || CRC_BE_BITS > 8
55
56/* implements slicing-by-4 or slicing-by-8 algorithm */
57static inline u32 __pure
58crc32_body(u32 crc, unsigned char const *buf, size_t len, const u32 (*tab)[256])
59{
60# ifdef __LITTLE_ENDIAN
61# define DO_CRC(x) crc = t0[(crc ^ (x)) & 255] ^ (crc >> 8)
62# define DO_CRC4 (t3[(q) & 255] ^ t2[(q >> 8) & 255] ^ \
63 t1[(q >> 16) & 255] ^ t0[(q >> 24) & 255])
64# define DO_CRC8 (t7[(q) & 255] ^ t6[(q >> 8) & 255] ^ \
65 t5[(q >> 16) & 255] ^ t4[(q >> 24) & 255])
66# else
67# define DO_CRC(x) crc = t0[((crc >> 24) ^ (x)) & 255] ^ (crc << 8)
68# define DO_CRC4 (t0[(q) & 255] ^ t1[(q >> 8) & 255] ^ \
69 t2[(q >> 16) & 255] ^ t3[(q >> 24) & 255])
70# define DO_CRC8 (t4[(q) & 255] ^ t5[(q >> 8) & 255] ^ \
71 t6[(q >> 16) & 255] ^ t7[(q >> 24) & 255])
72# endif
73 const u32 *b;
74 size_t rem_len;
75# ifdef CONFIG_X86
76 size_t i;
77# endif
78 const u32 *t0=tab[0], *t1=tab[1], *t2=tab[2], *t3=tab[3];
79# if CRC_LE_BITS != 32
80 const u32 *t4 = tab[4], *t5 = tab[5], *t6 = tab[6], *t7 = tab[7];
81# endif
82 u32 q;
83
84 /* Align it */
85 if (unlikely((long)buf & 3 && len)) {
86 do {
87 DO_CRC(*buf++);
88 } while ((--len) && ((long)buf)&3);
89 }
90
91# if CRC_LE_BITS == 32
92 rem_len = len & 3;
93 len = len >> 2;
94# else
95 rem_len = len & 7;
96 len = len >> 3;
97# endif
98
99 b = (const u32 *)buf;
100# ifdef CONFIG_X86
101 --b;
102 for (i = 0; i < len; i++) {
103# else
104 for (--b; len; --len) {
105# endif
106 q = crc ^ *++b; /* use pre increment for speed */
107# if CRC_LE_BITS == 32
108 crc = DO_CRC4;
109# else
110 crc = DO_CRC8;
111 q = *++b;
112 crc ^= DO_CRC4;
113# endif
114 }
115 len = rem_len;
116 /* And the last few bytes */
117 if (len) {
118 u8 *p = (u8 *)(b + 1) - 1;
119# ifdef CONFIG_X86
120 for (i = 0; i < len; i++)
121 DO_CRC(*++p); /* use pre increment for speed */
122# else
123 do {
124 DO_CRC(*++p); /* use pre increment for speed */
125 } while (--len);
126# endif
127 }
128 return crc;
129#undef DO_CRC
130#undef DO_CRC4
131#undef DO_CRC8
132}
133#endif
134
135
136/**
137 * crc32_le_generic() - Calculate bitwise little-endian Ethernet AUTODIN II
138 * CRC32/CRC32C
139 * @crc: seed value for computation. ~0 for Ethernet, sometimes 0 for other
140 * uses, or the previous crc32/crc32c value if computing incrementally.
141 * @p: pointer to buffer over which CRC32/CRC32C is run
142 * @len: length of buffer @p
143 * @tab: little-endian Ethernet table
144 * @polynomial: CRC32/CRC32c LE polynomial
145 */
146static inline u32 __pure crc32_le_generic(u32 crc, unsigned char const *p,
147 size_t len, const u32 (*tab)[256],
148 u32 polynomial)
149{
150#if CRC_LE_BITS == 1
151 int i;
152 while (len--) {
153 crc ^= *p++;
154 for (i = 0; i < 8; i++)
155 crc = (crc >> 1) ^ ((crc & 1) ? polynomial : 0);
156 }
157# elif CRC_LE_BITS == 2
158 while (len--) {
159 crc ^= *p++;
160 crc = (crc >> 2) ^ tab[0][crc & 3];
161 crc = (crc >> 2) ^ tab[0][crc & 3];
162 crc = (crc >> 2) ^ tab[0][crc & 3];
163 crc = (crc >> 2) ^ tab[0][crc & 3];
164 }
165# elif CRC_LE_BITS == 4
166 while (len--) {
167 crc ^= *p++;
168 crc = (crc >> 4) ^ tab[0][crc & 15];
169 crc = (crc >> 4) ^ tab[0][crc & 15];
170 }
171# elif CRC_LE_BITS == 8
172 /* aka Sarwate algorithm */
173 while (len--) {
174 crc ^= *p++;
175 crc = (crc >> 8) ^ tab[0][crc & 255];
176 }
177# else
178 crc = (__force u32) __cpu_to_le32(crc);
179 crc = crc32_body(crc, p, len, tab);
180 crc = __le32_to_cpu((__force __le32)crc);
181#endif
182 return crc;
183}
184
185#if CRC_LE_BITS == 1
186u32 __pure __weak crc32_le(u32 crc, unsigned char const *p, size_t len)
187{
188 return crc32_le_generic(crc, p, len, NULL, CRC32_POLY_LE);
189}
190u32 __pure __weak __crc32c_le(u32 crc, unsigned char const *p, size_t len)
191{
192 return crc32_le_generic(crc, p, len, NULL, CRC32C_POLY_LE);
193}
194#else
195u32 __pure __weak crc32_le(u32 crc, unsigned char const *p, size_t len)
196{
197 return crc32_le_generic(crc, p, len,
198 (const u32 (*)[256])crc32table_le, CRC32_POLY_LE);
199}
200u32 __pure __weak __crc32c_le(u32 crc, unsigned char const *p, size_t len)
201{
202 return crc32_le_generic(crc, p, len,
203 (const u32 (*)[256])crc32ctable_le, CRC32C_POLY_LE);
204}
205#endif
206EXPORT_SYMBOL(crc32_le);
207EXPORT_SYMBOL(__crc32c_le);
208
209u32 __pure crc32_le_base(u32, unsigned char const *, size_t) __alias(crc32_le);
210u32 __pure __crc32c_le_base(u32, unsigned char const *, size_t) __alias(__crc32c_le);
211
212/*
213 * This multiplies the polynomials x and y modulo the given modulus.
214 * This follows the "little-endian" CRC convention that the lsbit
215 * represents the highest power of x, and the msbit represents x^0.
216 */
217static u32 __attribute_const__ gf2_multiply(u32 x, u32 y, u32 modulus)
218{
219 u32 product = x & 1 ? y : 0;
220 int i;
221
222 for (i = 0; i < 31; i++) {
223 product = (product >> 1) ^ (product & 1 ? modulus : 0);
224 x >>= 1;
225 product ^= x & 1 ? y : 0;
226 }
227
228 return product;
229}
230
231/**
232 * crc32_generic_shift - Append @len 0 bytes to crc, in logarithmic time
233 * @crc: The original little-endian CRC (i.e. lsbit is x^31 coefficient)
234 * @len: The number of bytes. @crc is multiplied by x^(8*@len)
235 * @polynomial: The modulus used to reduce the result to 32 bits.
236 *
237 * It's possible to parallelize CRC computations by computing a CRC
238 * over separate ranges of a buffer, then summing them.
239 * This shifts the given CRC by 8*len bits (i.e. produces the same effect
240 * as appending len bytes of zero to the data), in time proportional
241 * to log(len).
242 */
243static u32 __attribute_const__ crc32_generic_shift(u32 crc, size_t len,
244 u32 polynomial)
245{
246 u32 power = polynomial; /* CRC of x^32 */
247 int i;
248
249 /* Shift up to 32 bits in the simple linear way */
250 for (i = 0; i < 8 * (int)(len & 3); i++)
251 crc = (crc >> 1) ^ (crc & 1 ? polynomial : 0);
252
253 len >>= 2;
254 if (!len)
255 return crc;
256
257 for (;;) {
258 /* "power" is x^(2^i), modulo the polynomial */
259 if (len & 1)
260 crc = gf2_multiply(crc, power, polynomial);
261
262 len >>= 1;
263 if (!len)
264 break;
265
266 /* Square power, advancing to x^(2^(i+1)) */
267 power = gf2_multiply(power, power, polynomial);
268 }
269
270 return crc;
271}
272
273u32 __attribute_const__ crc32_le_shift(u32 crc, size_t len)
274{
275 return crc32_generic_shift(crc, len, CRC32_POLY_LE);
276}
277
278u32 __attribute_const__ __crc32c_le_shift(u32 crc, size_t len)
279{
280 return crc32_generic_shift(crc, len, CRC32C_POLY_LE);
281}
282EXPORT_SYMBOL(crc32_le_shift);
283EXPORT_SYMBOL(__crc32c_le_shift);
284
285/**
286 * crc32_be_generic() - Calculate bitwise big-endian Ethernet AUTODIN II CRC32
287 * @crc: seed value for computation. ~0 for Ethernet, sometimes 0 for
288 * other uses, or the previous crc32 value if computing incrementally.
289 * @p: pointer to buffer over which CRC32 is run
290 * @len: length of buffer @p
291 * @tab: big-endian Ethernet table
292 * @polynomial: CRC32 BE polynomial
293 */
294static inline u32 __pure crc32_be_generic(u32 crc, unsigned char const *p,
295 size_t len, const u32 (*tab)[256],
296 u32 polynomial)
297{
298#if CRC_BE_BITS == 1
299 int i;
300 while (len--) {
301 crc ^= *p++ << 24;
302 for (i = 0; i < 8; i++)
303 crc =
304 (crc << 1) ^ ((crc & 0x80000000) ? polynomial :
305 0);
306 }
307# elif CRC_BE_BITS == 2
308 while (len--) {
309 crc ^= *p++ << 24;
310 crc = (crc << 2) ^ tab[0][crc >> 30];
311 crc = (crc << 2) ^ tab[0][crc >> 30];
312 crc = (crc << 2) ^ tab[0][crc >> 30];
313 crc = (crc << 2) ^ tab[0][crc >> 30];
314 }
315# elif CRC_BE_BITS == 4
316 while (len--) {
317 crc ^= *p++ << 24;
318 crc = (crc << 4) ^ tab[0][crc >> 28];
319 crc = (crc << 4) ^ tab[0][crc >> 28];
320 }
321# elif CRC_BE_BITS == 8
322 while (len--) {
323 crc ^= *p++ << 24;
324 crc = (crc << 8) ^ tab[0][crc >> 24];
325 }
326# else
327 crc = (__force u32) __cpu_to_be32(crc);
328 crc = crc32_body(crc, p, len, tab);
329 crc = __be32_to_cpu((__force __be32)crc);
330# endif
331 return crc;
332}
333
334#if CRC_BE_BITS == 1
335u32 __pure crc32_be(u32 crc, unsigned char const *p, size_t len)
336{
337 return crc32_be_generic(crc, p, len, NULL, CRC32_POLY_BE);
338}
339#else
340u32 __pure crc32_be(u32 crc, unsigned char const *p, size_t len)
341{
342 return crc32_be_generic(crc, p, len,
343 (const u32 (*)[256])crc32table_be, CRC32_POLY_BE);
344}
345#endif
346EXPORT_SYMBOL(crc32_be);
1/*
2 * Aug 8, 2011 Bob Pearson with help from Joakim Tjernlund and George Spelvin
3 * cleaned up code to current version of sparse and added the slicing-by-8
4 * algorithm to the closely similar existing slicing-by-4 algorithm.
5 *
6 * Oct 15, 2000 Matt Domsch <Matt_Domsch@dell.com>
7 * Nicer crc32 functions/docs submitted by linux@horizon.com. Thanks!
8 * Code was from the public domain, copyright abandoned. Code was
9 * subsequently included in the kernel, thus was re-licensed under the
10 * GNU GPL v2.
11 *
12 * Oct 12, 2000 Matt Domsch <Matt_Domsch@dell.com>
13 * Same crc32 function was used in 5 other places in the kernel.
14 * I made one version, and deleted the others.
15 * There are various incantations of crc32(). Some use a seed of 0 or ~0.
16 * Some xor at the end with ~0. The generic crc32() function takes
17 * seed as an argument, and doesn't xor at the end. Then individual
18 * users can do whatever they need.
19 * drivers/net/smc9194.c uses seed ~0, doesn't xor with ~0.
20 * fs/jffs2 uses seed 0, doesn't xor with ~0.
21 * fs/partitions/efi.c uses seed ~0, xor's with ~0.
22 *
23 * This source code is licensed under the GNU General Public License,
24 * Version 2. See the file COPYING for more details.
25 */
26
27/* see: Documentation/crc32.txt for a description of algorithms */
28
29#include <linux/crc32.h>
30#include <linux/module.h>
31#include <linux/types.h>
32#include <linux/sched.h>
33#include "crc32defs.h"
34
35#if CRC_LE_BITS > 8
36# define tole(x) ((__force u32) __constant_cpu_to_le32(x))
37#else
38# define tole(x) (x)
39#endif
40
41#if CRC_BE_BITS > 8
42# define tobe(x) ((__force u32) __constant_cpu_to_be32(x))
43#else
44# define tobe(x) (x)
45#endif
46
47#include "crc32table.h"
48
49MODULE_AUTHOR("Matt Domsch <Matt_Domsch@dell.com>");
50MODULE_DESCRIPTION("Various CRC32 calculations");
51MODULE_LICENSE("GPL");
52
53#define GF2_DIM 32
54
55static u32 gf2_matrix_times(u32 *mat, u32 vec)
56{
57 u32 sum = 0;
58
59 while (vec) {
60 if (vec & 1)
61 sum ^= *mat;
62 vec >>= 1;
63 mat++;
64 }
65
66 return sum;
67}
68
69static void gf2_matrix_square(u32 *square, u32 *mat)
70{
71 int i;
72
73 for (i = 0; i < GF2_DIM; i++)
74 square[i] = gf2_matrix_times(mat, mat[i]);
75}
76
77#if CRC_LE_BITS > 8 || CRC_BE_BITS > 8
78
79/* implements slicing-by-4 or slicing-by-8 algorithm */
80static inline u32
81crc32_body(u32 crc, unsigned char const *buf, size_t len, const u32 (*tab)[256])
82{
83# ifdef __LITTLE_ENDIAN
84# define DO_CRC(x) crc = t0[(crc ^ (x)) & 255] ^ (crc >> 8)
85# define DO_CRC4 (t3[(q) & 255] ^ t2[(q >> 8) & 255] ^ \
86 t1[(q >> 16) & 255] ^ t0[(q >> 24) & 255])
87# define DO_CRC8 (t7[(q) & 255] ^ t6[(q >> 8) & 255] ^ \
88 t5[(q >> 16) & 255] ^ t4[(q >> 24) & 255])
89# else
90# define DO_CRC(x) crc = t0[((crc >> 24) ^ (x)) & 255] ^ (crc << 8)
91# define DO_CRC4 (t0[(q) & 255] ^ t1[(q >> 8) & 255] ^ \
92 t2[(q >> 16) & 255] ^ t3[(q >> 24) & 255])
93# define DO_CRC8 (t4[(q) & 255] ^ t5[(q >> 8) & 255] ^ \
94 t6[(q >> 16) & 255] ^ t7[(q >> 24) & 255])
95# endif
96 const u32 *b;
97 size_t rem_len;
98# ifdef CONFIG_X86
99 size_t i;
100# endif
101 const u32 *t0=tab[0], *t1=tab[1], *t2=tab[2], *t3=tab[3];
102# if CRC_LE_BITS != 32
103 const u32 *t4 = tab[4], *t5 = tab[5], *t6 = tab[6], *t7 = tab[7];
104# endif
105 u32 q;
106
107 /* Align it */
108 if (unlikely((long)buf & 3 && len)) {
109 do {
110 DO_CRC(*buf++);
111 } while ((--len) && ((long)buf)&3);
112 }
113
114# if CRC_LE_BITS == 32
115 rem_len = len & 3;
116 len = len >> 2;
117# else
118 rem_len = len & 7;
119 len = len >> 3;
120# endif
121
122 b = (const u32 *)buf;
123# ifdef CONFIG_X86
124 --b;
125 for (i = 0; i < len; i++) {
126# else
127 for (--b; len; --len) {
128# endif
129 q = crc ^ *++b; /* use pre increment for speed */
130# if CRC_LE_BITS == 32
131 crc = DO_CRC4;
132# else
133 crc = DO_CRC8;
134 q = *++b;
135 crc ^= DO_CRC4;
136# endif
137 }
138 len = rem_len;
139 /* And the last few bytes */
140 if (len) {
141 u8 *p = (u8 *)(b + 1) - 1;
142# ifdef CONFIG_X86
143 for (i = 0; i < len; i++)
144 DO_CRC(*++p); /* use pre increment for speed */
145# else
146 do {
147 DO_CRC(*++p); /* use pre increment for speed */
148 } while (--len);
149# endif
150 }
151 return crc;
152#undef DO_CRC
153#undef DO_CRC4
154#undef DO_CRC8
155}
156#endif
157
158/* For conditions of distribution and use, see copyright notice in zlib.h */
159static u32 crc32_generic_combine(u32 crc1, u32 crc2, size_t len2,
160 u32 polynomial)
161{
162 u32 even[GF2_DIM]; /* Even-power-of-two zeros operator */
163 u32 odd[GF2_DIM]; /* Odd-power-of-two zeros operator */
164 u32 row;
165 int i;
166
167 if (len2 <= 0)
168 return crc1;
169
170 /* Put operator for one zero bit in odd */
171 odd[0] = polynomial;
172 row = 1;
173 for (i = 1; i < GF2_DIM; i++) {
174 odd[i] = row;
175 row <<= 1;
176 }
177
178 gf2_matrix_square(even, odd); /* Put operator for two zero bits in even */
179 gf2_matrix_square(odd, even); /* Put operator for four zero bits in odd */
180
181 /* Apply len2 zeros to crc1 (first square will put the operator for one
182 * zero byte, eight zero bits, in even).
183 */
184 do {
185 /* Apply zeros operator for this bit of len2 */
186 gf2_matrix_square(even, odd);
187 if (len2 & 1)
188 crc1 = gf2_matrix_times(even, crc1);
189 len2 >>= 1;
190 /* If no more bits set, then done */
191 if (len2 == 0)
192 break;
193 /* Another iteration of the loop with odd and even swapped */
194 gf2_matrix_square(odd, even);
195 if (len2 & 1)
196 crc1 = gf2_matrix_times(odd, crc1);
197 len2 >>= 1;
198 } while (len2 != 0);
199
200 crc1 ^= crc2;
201 return crc1;
202}
203
204/**
205 * crc32_le_generic() - Calculate bitwise little-endian Ethernet AUTODIN II
206 * CRC32/CRC32C
207 * @crc: seed value for computation. ~0 for Ethernet, sometimes 0 for other
208 * uses, or the previous crc32/crc32c value if computing incrementally.
209 * @p: pointer to buffer over which CRC32/CRC32C is run
210 * @len: length of buffer @p
211 * @tab: little-endian Ethernet table
212 * @polynomial: CRC32/CRC32c LE polynomial
213 */
214static inline u32 __pure crc32_le_generic(u32 crc, unsigned char const *p,
215 size_t len, const u32 (*tab)[256],
216 u32 polynomial)
217{
218#if CRC_LE_BITS == 1
219 int i;
220 while (len--) {
221 crc ^= *p++;
222 for (i = 0; i < 8; i++)
223 crc = (crc >> 1) ^ ((crc & 1) ? polynomial : 0);
224 }
225# elif CRC_LE_BITS == 2
226 while (len--) {
227 crc ^= *p++;
228 crc = (crc >> 2) ^ tab[0][crc & 3];
229 crc = (crc >> 2) ^ tab[0][crc & 3];
230 crc = (crc >> 2) ^ tab[0][crc & 3];
231 crc = (crc >> 2) ^ tab[0][crc & 3];
232 }
233# elif CRC_LE_BITS == 4
234 while (len--) {
235 crc ^= *p++;
236 crc = (crc >> 4) ^ tab[0][crc & 15];
237 crc = (crc >> 4) ^ tab[0][crc & 15];
238 }
239# elif CRC_LE_BITS == 8
240 /* aka Sarwate algorithm */
241 while (len--) {
242 crc ^= *p++;
243 crc = (crc >> 8) ^ tab[0][crc & 255];
244 }
245# else
246 crc = (__force u32) __cpu_to_le32(crc);
247 crc = crc32_body(crc, p, len, tab);
248 crc = __le32_to_cpu((__force __le32)crc);
249#endif
250 return crc;
251}
252
253#if CRC_LE_BITS == 1
254u32 __pure crc32_le(u32 crc, unsigned char const *p, size_t len)
255{
256 return crc32_le_generic(crc, p, len, NULL, CRCPOLY_LE);
257}
258u32 __pure __crc32c_le(u32 crc, unsigned char const *p, size_t len)
259{
260 return crc32_le_generic(crc, p, len, NULL, CRC32C_POLY_LE);
261}
262#else
263u32 __pure crc32_le(u32 crc, unsigned char const *p, size_t len)
264{
265 return crc32_le_generic(crc, p, len,
266 (const u32 (*)[256])crc32table_le, CRCPOLY_LE);
267}
268u32 __pure __crc32c_le(u32 crc, unsigned char const *p, size_t len)
269{
270 return crc32_le_generic(crc, p, len,
271 (const u32 (*)[256])crc32ctable_le, CRC32C_POLY_LE);
272}
273#endif
274u32 __pure crc32_le_combine(u32 crc1, u32 crc2, size_t len2)
275{
276 return crc32_generic_combine(crc1, crc2, len2, CRCPOLY_LE);
277}
278
279u32 __pure __crc32c_le_combine(u32 crc1, u32 crc2, size_t len2)
280{
281 return crc32_generic_combine(crc1, crc2, len2, CRC32C_POLY_LE);
282}
283EXPORT_SYMBOL(crc32_le);
284EXPORT_SYMBOL(crc32_le_combine);
285EXPORT_SYMBOL(__crc32c_le);
286EXPORT_SYMBOL(__crc32c_le_combine);
287
288/**
289 * crc32_be_generic() - Calculate bitwise big-endian Ethernet AUTODIN II CRC32
290 * @crc: seed value for computation. ~0 for Ethernet, sometimes 0 for
291 * other uses, or the previous crc32 value if computing incrementally.
292 * @p: pointer to buffer over which CRC32 is run
293 * @len: length of buffer @p
294 * @tab: big-endian Ethernet table
295 * @polynomial: CRC32 BE polynomial
296 */
297static inline u32 __pure crc32_be_generic(u32 crc, unsigned char const *p,
298 size_t len, const u32 (*tab)[256],
299 u32 polynomial)
300{
301#if CRC_BE_BITS == 1
302 int i;
303 while (len--) {
304 crc ^= *p++ << 24;
305 for (i = 0; i < 8; i++)
306 crc =
307 (crc << 1) ^ ((crc & 0x80000000) ? polynomial :
308 0);
309 }
310# elif CRC_BE_BITS == 2
311 while (len--) {
312 crc ^= *p++ << 24;
313 crc = (crc << 2) ^ tab[0][crc >> 30];
314 crc = (crc << 2) ^ tab[0][crc >> 30];
315 crc = (crc << 2) ^ tab[0][crc >> 30];
316 crc = (crc << 2) ^ tab[0][crc >> 30];
317 }
318# elif CRC_BE_BITS == 4
319 while (len--) {
320 crc ^= *p++ << 24;
321 crc = (crc << 4) ^ tab[0][crc >> 28];
322 crc = (crc << 4) ^ tab[0][crc >> 28];
323 }
324# elif CRC_BE_BITS == 8
325 while (len--) {
326 crc ^= *p++ << 24;
327 crc = (crc << 8) ^ tab[0][crc >> 24];
328 }
329# else
330 crc = (__force u32) __cpu_to_be32(crc);
331 crc = crc32_body(crc, p, len, tab);
332 crc = __be32_to_cpu((__force __be32)crc);
333# endif
334 return crc;
335}
336
337#if CRC_LE_BITS == 1
338u32 __pure crc32_be(u32 crc, unsigned char const *p, size_t len)
339{
340 return crc32_be_generic(crc, p, len, NULL, CRCPOLY_BE);
341}
342#else
343u32 __pure crc32_be(u32 crc, unsigned char const *p, size_t len)
344{
345 return crc32_be_generic(crc, p, len,
346 (const u32 (*)[256])crc32table_be, CRCPOLY_BE);
347}
348#endif
349EXPORT_SYMBOL(crc32_be);
350
351#ifdef CONFIG_CRC32_SELFTEST
352
353/* 4096 random bytes */
354static u8 __attribute__((__aligned__(8))) test_buf[] =
355{
356 0x5b, 0x85, 0x21, 0xcb, 0x09, 0x68, 0x7d, 0x30,
357 0xc7, 0x69, 0xd7, 0x30, 0x92, 0xde, 0x59, 0xe4,
358 0xc9, 0x6e, 0x8b, 0xdb, 0x98, 0x6b, 0xaa, 0x60,
359 0xa8, 0xb5, 0xbc, 0x6c, 0xa9, 0xb1, 0x5b, 0x2c,
360 0xea, 0xb4, 0x92, 0x6a, 0x3f, 0x79, 0x91, 0xe4,
361 0xe9, 0x70, 0x51, 0x8c, 0x7f, 0x95, 0x6f, 0x1a,
362 0x56, 0xa1, 0x5c, 0x27, 0x03, 0x67, 0x9f, 0x3a,
363 0xe2, 0x31, 0x11, 0x29, 0x6b, 0x98, 0xfc, 0xc4,
364 0x53, 0x24, 0xc5, 0x8b, 0xce, 0x47, 0xb2, 0xb9,
365 0x32, 0xcb, 0xc1, 0xd0, 0x03, 0x57, 0x4e, 0xd4,
366 0xe9, 0x3c, 0xa1, 0x63, 0xcf, 0x12, 0x0e, 0xca,
367 0xe1, 0x13, 0xd1, 0x93, 0xa6, 0x88, 0x5c, 0x61,
368 0x5b, 0xbb, 0xf0, 0x19, 0x46, 0xb4, 0xcf, 0x9e,
369 0xb6, 0x6b, 0x4c, 0x3a, 0xcf, 0x60, 0xf9, 0x7a,
370 0x8d, 0x07, 0x63, 0xdb, 0x40, 0xe9, 0x0b, 0x6f,
371 0xad, 0x97, 0xf1, 0xed, 0xd0, 0x1e, 0x26, 0xfd,
372 0xbf, 0xb7, 0xc8, 0x04, 0x94, 0xf8, 0x8b, 0x8c,
373 0xf1, 0xab, 0x7a, 0xd4, 0xdd, 0xf3, 0xe8, 0x88,
374 0xc3, 0xed, 0x17, 0x8a, 0x9b, 0x40, 0x0d, 0x53,
375 0x62, 0x12, 0x03, 0x5f, 0x1b, 0x35, 0x32, 0x1f,
376 0xb4, 0x7b, 0x93, 0x78, 0x0d, 0xdb, 0xce, 0xa4,
377 0xc0, 0x47, 0xd5, 0xbf, 0x68, 0xe8, 0x5d, 0x74,
378 0x8f, 0x8e, 0x75, 0x1c, 0xb2, 0x4f, 0x9a, 0x60,
379 0xd1, 0xbe, 0x10, 0xf4, 0x5c, 0xa1, 0x53, 0x09,
380 0xa5, 0xe0, 0x09, 0x54, 0x85, 0x5c, 0xdc, 0x07,
381 0xe7, 0x21, 0x69, 0x7b, 0x8a, 0xfd, 0x90, 0xf1,
382 0x22, 0xd0, 0xb4, 0x36, 0x28, 0xe6, 0xb8, 0x0f,
383 0x39, 0xde, 0xc8, 0xf3, 0x86, 0x60, 0x34, 0xd2,
384 0x5e, 0xdf, 0xfd, 0xcf, 0x0f, 0xa9, 0x65, 0xf0,
385 0xd5, 0x4d, 0x96, 0x40, 0xe3, 0xdf, 0x3f, 0x95,
386 0x5a, 0x39, 0x19, 0x93, 0xf4, 0x75, 0xce, 0x22,
387 0x00, 0x1c, 0x93, 0xe2, 0x03, 0x66, 0xf4, 0x93,
388 0x73, 0x86, 0x81, 0x8e, 0x29, 0x44, 0x48, 0x86,
389 0x61, 0x7c, 0x48, 0xa3, 0x43, 0xd2, 0x9c, 0x8d,
390 0xd4, 0x95, 0xdd, 0xe1, 0x22, 0x89, 0x3a, 0x40,
391 0x4c, 0x1b, 0x8a, 0x04, 0xa8, 0x09, 0x69, 0x8b,
392 0xea, 0xc6, 0x55, 0x8e, 0x57, 0xe6, 0x64, 0x35,
393 0xf0, 0xc7, 0x16, 0x9f, 0x5d, 0x5e, 0x86, 0x40,
394 0x46, 0xbb, 0xe5, 0x45, 0x88, 0xfe, 0xc9, 0x63,
395 0x15, 0xfb, 0xf5, 0xbd, 0x71, 0x61, 0xeb, 0x7b,
396 0x78, 0x70, 0x07, 0x31, 0x03, 0x9f, 0xb2, 0xc8,
397 0xa7, 0xab, 0x47, 0xfd, 0xdf, 0xa0, 0x78, 0x72,
398 0xa4, 0x2a, 0xe4, 0xb6, 0xba, 0xc0, 0x1e, 0x86,
399 0x71, 0xe6, 0x3d, 0x18, 0x37, 0x70, 0xe6, 0xff,
400 0xe0, 0xbc, 0x0b, 0x22, 0xa0, 0x1f, 0xd3, 0xed,
401 0xa2, 0x55, 0x39, 0xab, 0xa8, 0x13, 0x73, 0x7c,
402 0x3f, 0xb2, 0xd6, 0x19, 0xac, 0xff, 0x99, 0xed,
403 0xe8, 0xe6, 0xa6, 0x22, 0xe3, 0x9c, 0xf1, 0x30,
404 0xdc, 0x01, 0x0a, 0x56, 0xfa, 0xe4, 0xc9, 0x99,
405 0xdd, 0xa8, 0xd8, 0xda, 0x35, 0x51, 0x73, 0xb4,
406 0x40, 0x86, 0x85, 0xdb, 0x5c, 0xd5, 0x85, 0x80,
407 0x14, 0x9c, 0xfd, 0x98, 0xa9, 0x82, 0xc5, 0x37,
408 0xff, 0x32, 0x5d, 0xd0, 0x0b, 0xfa, 0xdc, 0x04,
409 0x5e, 0x09, 0xd2, 0xca, 0x17, 0x4b, 0x1a, 0x8e,
410 0x15, 0xe1, 0xcc, 0x4e, 0x52, 0x88, 0x35, 0xbd,
411 0x48, 0xfe, 0x15, 0xa0, 0x91, 0xfd, 0x7e, 0x6c,
412 0x0e, 0x5d, 0x79, 0x1b, 0x81, 0x79, 0xd2, 0x09,
413 0x34, 0x70, 0x3d, 0x81, 0xec, 0xf6, 0x24, 0xbb,
414 0xfb, 0xf1, 0x7b, 0xdf, 0x54, 0xea, 0x80, 0x9b,
415 0xc7, 0x99, 0x9e, 0xbd, 0x16, 0x78, 0x12, 0x53,
416 0x5e, 0x01, 0xa7, 0x4e, 0xbd, 0x67, 0xe1, 0x9b,
417 0x4c, 0x0e, 0x61, 0x45, 0x97, 0xd2, 0xf0, 0x0f,
418 0xfe, 0x15, 0x08, 0xb7, 0x11, 0x4c, 0xe7, 0xff,
419 0x81, 0x53, 0xff, 0x91, 0x25, 0x38, 0x7e, 0x40,
420 0x94, 0xe5, 0xe0, 0xad, 0xe6, 0xd9, 0x79, 0xb6,
421 0x92, 0xc9, 0xfc, 0xde, 0xc3, 0x1a, 0x23, 0xbb,
422 0xdd, 0xc8, 0x51, 0x0c, 0x3a, 0x72, 0xfa, 0x73,
423 0x6f, 0xb7, 0xee, 0x61, 0x39, 0x03, 0x01, 0x3f,
424 0x7f, 0x94, 0x2e, 0x2e, 0xba, 0x3a, 0xbb, 0xb4,
425 0xfa, 0x6a, 0x17, 0xfe, 0xea, 0xef, 0x5e, 0x66,
426 0x97, 0x3f, 0x32, 0x3d, 0xd7, 0x3e, 0xb1, 0xf1,
427 0x6c, 0x14, 0x4c, 0xfd, 0x37, 0xd3, 0x38, 0x80,
428 0xfb, 0xde, 0xa6, 0x24, 0x1e, 0xc8, 0xca, 0x7f,
429 0x3a, 0x93, 0xd8, 0x8b, 0x18, 0x13, 0xb2, 0xe5,
430 0xe4, 0x93, 0x05, 0x53, 0x4f, 0x84, 0x66, 0xa7,
431 0x58, 0x5c, 0x7b, 0x86, 0x52, 0x6d, 0x0d, 0xce,
432 0xa4, 0x30, 0x7d, 0xb6, 0x18, 0x9f, 0xeb, 0xff,
433 0x22, 0xbb, 0x72, 0x29, 0xb9, 0x44, 0x0b, 0x48,
434 0x1e, 0x84, 0x71, 0x81, 0xe3, 0x6d, 0x73, 0x26,
435 0x92, 0xb4, 0x4d, 0x2a, 0x29, 0xb8, 0x1f, 0x72,
436 0xed, 0xd0, 0xe1, 0x64, 0x77, 0xea, 0x8e, 0x88,
437 0x0f, 0xef, 0x3f, 0xb1, 0x3b, 0xad, 0xf9, 0xc9,
438 0x8b, 0xd0, 0xac, 0xc6, 0xcc, 0xa9, 0x40, 0xcc,
439 0x76, 0xf6, 0x3b, 0x53, 0xb5, 0x88, 0xcb, 0xc8,
440 0x37, 0xf1, 0xa2, 0xba, 0x23, 0x15, 0x99, 0x09,
441 0xcc, 0xe7, 0x7a, 0x3b, 0x37, 0xf7, 0x58, 0xc8,
442 0x46, 0x8c, 0x2b, 0x2f, 0x4e, 0x0e, 0xa6, 0x5c,
443 0xea, 0x85, 0x55, 0xba, 0x02, 0x0e, 0x0e, 0x48,
444 0xbc, 0xe1, 0xb1, 0x01, 0x35, 0x79, 0x13, 0x3d,
445 0x1b, 0xc0, 0x53, 0x68, 0x11, 0xe7, 0x95, 0x0f,
446 0x9d, 0x3f, 0x4c, 0x47, 0x7b, 0x4d, 0x1c, 0xae,
447 0x50, 0x9b, 0xcb, 0xdd, 0x05, 0x8d, 0x9a, 0x97,
448 0xfd, 0x8c, 0xef, 0x0c, 0x1d, 0x67, 0x73, 0xa8,
449 0x28, 0x36, 0xd5, 0xb6, 0x92, 0x33, 0x40, 0x75,
450 0x0b, 0x51, 0xc3, 0x64, 0xba, 0x1d, 0xc2, 0xcc,
451 0xee, 0x7d, 0x54, 0x0f, 0x27, 0x69, 0xa7, 0x27,
452 0x63, 0x30, 0x29, 0xd9, 0xc8, 0x84, 0xd8, 0xdf,
453 0x9f, 0x68, 0x8d, 0x04, 0xca, 0xa6, 0xc5, 0xc7,
454 0x7a, 0x5c, 0xc8, 0xd1, 0xcb, 0x4a, 0xec, 0xd0,
455 0xd8, 0x20, 0x69, 0xc5, 0x17, 0xcd, 0x78, 0xc8,
456 0x75, 0x23, 0x30, 0x69, 0xc9, 0xd4, 0xea, 0x5c,
457 0x4f, 0x6b, 0x86, 0x3f, 0x8b, 0xfe, 0xee, 0x44,
458 0xc9, 0x7c, 0xb7, 0xdd, 0x3e, 0xe5, 0xec, 0x54,
459 0x03, 0x3e, 0xaa, 0x82, 0xc6, 0xdf, 0xb2, 0x38,
460 0x0e, 0x5d, 0xb3, 0x88, 0xd9, 0xd3, 0x69, 0x5f,
461 0x8f, 0x70, 0x8a, 0x7e, 0x11, 0xd9, 0x1e, 0x7b,
462 0x38, 0xf1, 0x42, 0x1a, 0xc0, 0x35, 0xf5, 0xc7,
463 0x36, 0x85, 0xf5, 0xf7, 0xb8, 0x7e, 0xc7, 0xef,
464 0x18, 0xf1, 0x63, 0xd6, 0x7a, 0xc6, 0xc9, 0x0e,
465 0x4d, 0x69, 0x4f, 0x84, 0xef, 0x26, 0x41, 0x0c,
466 0xec, 0xc7, 0xe0, 0x7e, 0x3c, 0x67, 0x01, 0x4c,
467 0x62, 0x1a, 0x20, 0x6f, 0xee, 0x47, 0x4d, 0xc0,
468 0x99, 0x13, 0x8d, 0x91, 0x4a, 0x26, 0xd4, 0x37,
469 0x28, 0x90, 0x58, 0x75, 0x66, 0x2b, 0x0a, 0xdf,
470 0xda, 0xee, 0x92, 0x25, 0x90, 0x62, 0x39, 0x9e,
471 0x44, 0x98, 0xad, 0xc1, 0x88, 0xed, 0xe4, 0xb4,
472 0xaf, 0xf5, 0x8c, 0x9b, 0x48, 0x4d, 0x56, 0x60,
473 0x97, 0x0f, 0x61, 0x59, 0x9e, 0xa6, 0x27, 0xfe,
474 0xc1, 0x91, 0x15, 0x38, 0xb8, 0x0f, 0xae, 0x61,
475 0x7d, 0x26, 0x13, 0x5a, 0x73, 0xff, 0x1c, 0xa3,
476 0x61, 0x04, 0x58, 0x48, 0x55, 0x44, 0x11, 0xfe,
477 0x15, 0xca, 0xc3, 0xbd, 0xca, 0xc5, 0xb4, 0x40,
478 0x5d, 0x1b, 0x7f, 0x39, 0xb5, 0x9c, 0x35, 0xec,
479 0x61, 0x15, 0x32, 0x32, 0xb8, 0x4e, 0x40, 0x9f,
480 0x17, 0x1f, 0x0a, 0x4d, 0xa9, 0x91, 0xef, 0xb7,
481 0xb0, 0xeb, 0xc2, 0x83, 0x9a, 0x6c, 0xd2, 0x79,
482 0x43, 0x78, 0x5e, 0x2f, 0xe5, 0xdd, 0x1a, 0x3c,
483 0x45, 0xab, 0x29, 0x40, 0x3a, 0x37, 0x5b, 0x6f,
484 0xd7, 0xfc, 0x48, 0x64, 0x3c, 0x49, 0xfb, 0x21,
485 0xbe, 0xc3, 0xff, 0x07, 0xfb, 0x17, 0xe9, 0xc9,
486 0x0c, 0x4c, 0x5c, 0x15, 0x9e, 0x8e, 0x22, 0x30,
487 0x0a, 0xde, 0x48, 0x7f, 0xdb, 0x0d, 0xd1, 0x2b,
488 0x87, 0x38, 0x9e, 0xcc, 0x5a, 0x01, 0x16, 0xee,
489 0x75, 0x49, 0x0d, 0x30, 0x01, 0x34, 0x6a, 0xb6,
490 0x9a, 0x5a, 0x2a, 0xec, 0xbb, 0x48, 0xac, 0xd3,
491 0x77, 0x83, 0xd8, 0x08, 0x86, 0x4f, 0x48, 0x09,
492 0x29, 0x41, 0x79, 0xa1, 0x03, 0x12, 0xc4, 0xcd,
493 0x90, 0x55, 0x47, 0x66, 0x74, 0x9a, 0xcc, 0x4f,
494 0x35, 0x8c, 0xd6, 0x98, 0xef, 0xeb, 0x45, 0xb9,
495 0x9a, 0x26, 0x2f, 0x39, 0xa5, 0x70, 0x6d, 0xfc,
496 0xb4, 0x51, 0xee, 0xf4, 0x9c, 0xe7, 0x38, 0x59,
497 0xad, 0xf4, 0xbc, 0x46, 0xff, 0x46, 0x8e, 0x60,
498 0x9c, 0xa3, 0x60, 0x1d, 0xf8, 0x26, 0x72, 0xf5,
499 0x72, 0x9d, 0x68, 0x80, 0x04, 0xf6, 0x0b, 0xa1,
500 0x0a, 0xd5, 0xa7, 0x82, 0x3a, 0x3e, 0x47, 0xa8,
501 0x5a, 0xde, 0x59, 0x4f, 0x7b, 0x07, 0xb3, 0xe9,
502 0x24, 0x19, 0x3d, 0x34, 0x05, 0xec, 0xf1, 0xab,
503 0x6e, 0x64, 0x8f, 0xd3, 0xe6, 0x41, 0x86, 0x80,
504 0x70, 0xe3, 0x8d, 0x60, 0x9c, 0x34, 0x25, 0x01,
505 0x07, 0x4d, 0x19, 0x41, 0x4e, 0x3d, 0x5c, 0x7e,
506 0xa8, 0xf5, 0xcc, 0xd5, 0x7b, 0xe2, 0x7d, 0x3d,
507 0x49, 0x86, 0x7d, 0x07, 0xb7, 0x10, 0xe3, 0x35,
508 0xb8, 0x84, 0x6d, 0x76, 0xab, 0x17, 0xc6, 0x38,
509 0xb4, 0xd3, 0x28, 0x57, 0xad, 0xd3, 0x88, 0x5a,
510 0xda, 0xea, 0xc8, 0x94, 0xcc, 0x37, 0x19, 0xac,
511 0x9c, 0x9f, 0x4b, 0x00, 0x15, 0xc0, 0xc8, 0xca,
512 0x1f, 0x15, 0xaa, 0xe0, 0xdb, 0xf9, 0x2f, 0x57,
513 0x1b, 0x24, 0xc7, 0x6f, 0x76, 0x29, 0xfb, 0xed,
514 0x25, 0x0d, 0xc0, 0xfe, 0xbd, 0x5a, 0xbf, 0x20,
515 0x08, 0x51, 0x05, 0xec, 0x71, 0xa3, 0xbf, 0xef,
516 0x5e, 0x99, 0x75, 0xdb, 0x3c, 0x5f, 0x9a, 0x8c,
517 0xbb, 0x19, 0x5c, 0x0e, 0x93, 0x19, 0xf8, 0x6a,
518 0xbc, 0xf2, 0x12, 0x54, 0x2f, 0xcb, 0x28, 0x64,
519 0x88, 0xb3, 0x92, 0x0d, 0x96, 0xd1, 0xa6, 0xe4,
520 0x1f, 0xf1, 0x4d, 0xa4, 0xab, 0x1c, 0xee, 0x54,
521 0xf2, 0xad, 0x29, 0x6d, 0x32, 0x37, 0xb2, 0x16,
522 0x77, 0x5c, 0xdc, 0x2e, 0x54, 0xec, 0x75, 0x26,
523 0xc6, 0x36, 0xd9, 0x17, 0x2c, 0xf1, 0x7a, 0xdc,
524 0x4b, 0xf1, 0xe2, 0xd9, 0x95, 0xba, 0xac, 0x87,
525 0xc1, 0xf3, 0x8e, 0x58, 0x08, 0xd8, 0x87, 0x60,
526 0xc9, 0xee, 0x6a, 0xde, 0xa4, 0xd2, 0xfc, 0x0d,
527 0xe5, 0x36, 0xc4, 0x5c, 0x52, 0xb3, 0x07, 0x54,
528 0x65, 0x24, 0xc1, 0xb1, 0xd1, 0xb1, 0x53, 0x13,
529 0x31, 0x79, 0x7f, 0x05, 0x76, 0xeb, 0x37, 0x59,
530 0x15, 0x2b, 0xd1, 0x3f, 0xac, 0x08, 0x97, 0xeb,
531 0x91, 0x98, 0xdf, 0x6c, 0x09, 0x0d, 0x04, 0x9f,
532 0xdc, 0x3b, 0x0e, 0x60, 0x68, 0x47, 0x23, 0x15,
533 0x16, 0xc6, 0x0b, 0x35, 0xf8, 0x77, 0xa2, 0x78,
534 0x50, 0xd4, 0x64, 0x22, 0x33, 0xff, 0xfb, 0x93,
535 0x71, 0x46, 0x50, 0x39, 0x1b, 0x9c, 0xea, 0x4e,
536 0x8d, 0x0c, 0x37, 0xe5, 0x5c, 0x51, 0x3a, 0x31,
537 0xb2, 0x85, 0x84, 0x3f, 0x41, 0xee, 0xa2, 0xc1,
538 0xc6, 0x13, 0x3b, 0x54, 0x28, 0xd2, 0x18, 0x37,
539 0xcc, 0x46, 0x9f, 0x6a, 0x91, 0x3d, 0x5a, 0x15,
540 0x3c, 0x89, 0xa3, 0x61, 0x06, 0x7d, 0x2e, 0x78,
541 0xbe, 0x7d, 0x40, 0xba, 0x2f, 0x95, 0xb1, 0x2f,
542 0x87, 0x3b, 0x8a, 0xbe, 0x6a, 0xf4, 0xc2, 0x31,
543 0x74, 0xee, 0x91, 0xe0, 0x23, 0xaa, 0x5d, 0x7f,
544 0xdd, 0xf0, 0x44, 0x8c, 0x0b, 0x59, 0x2b, 0xfc,
545 0x48, 0x3a, 0xdf, 0x07, 0x05, 0x38, 0x6c, 0xc9,
546 0xeb, 0x18, 0x24, 0x68, 0x8d, 0x58, 0x98, 0xd3,
547 0x31, 0xa3, 0xe4, 0x70, 0x59, 0xb1, 0x21, 0xbe,
548 0x7e, 0x65, 0x7d, 0xb8, 0x04, 0xab, 0xf6, 0xe4,
549 0xd7, 0xda, 0xec, 0x09, 0x8f, 0xda, 0x6d, 0x24,
550 0x07, 0xcc, 0x29, 0x17, 0x05, 0x78, 0x1a, 0xc1,
551 0xb1, 0xce, 0xfc, 0xaa, 0x2d, 0xe7, 0xcc, 0x85,
552 0x84, 0x84, 0x03, 0x2a, 0x0c, 0x3f, 0xa9, 0xf8,
553 0xfd, 0x84, 0x53, 0x59, 0x5c, 0xf0, 0xd4, 0x09,
554 0xf0, 0xd2, 0x6c, 0x32, 0x03, 0xb0, 0xa0, 0x8c,
555 0x52, 0xeb, 0x23, 0x91, 0x88, 0x43, 0x13, 0x46,
556 0xf6, 0x1e, 0xb4, 0x1b, 0xf5, 0x8e, 0x3a, 0xb5,
557 0x3d, 0x00, 0xf6, 0xe5, 0x08, 0x3d, 0x5f, 0x39,
558 0xd3, 0x21, 0x69, 0xbc, 0x03, 0x22, 0x3a, 0xd2,
559 0x5c, 0x84, 0xf8, 0x15, 0xc4, 0x80, 0x0b, 0xbc,
560 0x29, 0x3c, 0xf3, 0x95, 0x98, 0xcd, 0x8f, 0x35,
561 0xbc, 0xa5, 0x3e, 0xfc, 0xd4, 0x13, 0x9e, 0xde,
562 0x4f, 0xce, 0x71, 0x9d, 0x09, 0xad, 0xf2, 0x80,
563 0x6b, 0x65, 0x7f, 0x03, 0x00, 0x14, 0x7c, 0x15,
564 0x85, 0x40, 0x6d, 0x70, 0xea, 0xdc, 0xb3, 0x63,
565 0x35, 0x4f, 0x4d, 0xe0, 0xd9, 0xd5, 0x3c, 0x58,
566 0x56, 0x23, 0x80, 0xe2, 0x36, 0xdd, 0x75, 0x1d,
567 0x94, 0x11, 0x41, 0x8e, 0xe0, 0x81, 0x8e, 0xcf,
568 0xe0, 0xe5, 0xf6, 0xde, 0xd1, 0xe7, 0x04, 0x12,
569 0x79, 0x92, 0x2b, 0x71, 0x2a, 0x79, 0x8b, 0x7c,
570 0x44, 0x79, 0x16, 0x30, 0x4e, 0xf4, 0xf6, 0x9b,
571 0xb7, 0x40, 0xa3, 0x5a, 0xa7, 0x69, 0x3e, 0xc1,
572 0x3a, 0x04, 0xd0, 0x88, 0xa0, 0x3b, 0xdd, 0xc6,
573 0x9e, 0x7e, 0x1e, 0x1e, 0x8f, 0x44, 0xf7, 0x73,
574 0x67, 0x1e, 0x1a, 0x78, 0xfa, 0x62, 0xf4, 0xa9,
575 0xa8, 0xc6, 0x5b, 0xb8, 0xfa, 0x06, 0x7d, 0x5e,
576 0x38, 0x1c, 0x9a, 0x39, 0xe9, 0x39, 0x98, 0x22,
577 0x0b, 0xa7, 0xac, 0x0b, 0xf3, 0xbc, 0xf1, 0xeb,
578 0x8c, 0x81, 0xe3, 0x48, 0x8a, 0xed, 0x42, 0xc2,
579 0x38, 0xcf, 0x3e, 0xda, 0xd2, 0x89, 0x8d, 0x9c,
580 0x53, 0xb5, 0x2f, 0x41, 0x01, 0x26, 0x84, 0x9c,
581 0xa3, 0x56, 0xf6, 0x49, 0xc7, 0xd4, 0x9f, 0x93,
582 0x1b, 0x96, 0x49, 0x5e, 0xad, 0xb3, 0x84, 0x1f,
583 0x3c, 0xa4, 0xe0, 0x9b, 0xd1, 0x90, 0xbc, 0x38,
584 0x6c, 0xdd, 0x95, 0x4d, 0x9d, 0xb1, 0x71, 0x57,
585 0x2d, 0x34, 0xe8, 0xb8, 0x42, 0xc7, 0x99, 0x03,
586 0xc7, 0x07, 0x30, 0x65, 0x91, 0x55, 0xd5, 0x90,
587 0x70, 0x97, 0x37, 0x68, 0xd4, 0x11, 0xf9, 0xe8,
588 0xce, 0xec, 0xdc, 0x34, 0xd5, 0xd3, 0xb7, 0xc4,
589 0xb8, 0x97, 0x05, 0x92, 0xad, 0xf8, 0xe2, 0x36,
590 0x64, 0x41, 0xc9, 0xc5, 0x41, 0x77, 0x52, 0xd7,
591 0x2c, 0xa5, 0x24, 0x2f, 0xd9, 0x34, 0x0b, 0x47,
592 0x35, 0xa7, 0x28, 0x8b, 0xc5, 0xcd, 0xe9, 0x46,
593 0xac, 0x39, 0x94, 0x3c, 0x10, 0xc6, 0x29, 0x73,
594 0x0e, 0x0e, 0x5d, 0xe0, 0x71, 0x03, 0x8a, 0x72,
595 0x0e, 0x26, 0xb0, 0x7d, 0x84, 0xed, 0x95, 0x23,
596 0x49, 0x5a, 0x45, 0x83, 0x45, 0x60, 0x11, 0x4a,
597 0x46, 0x31, 0xd4, 0xd8, 0x16, 0x54, 0x98, 0x58,
598 0xed, 0x6d, 0xcc, 0x5d, 0xd6, 0x50, 0x61, 0x9f,
599 0x9d, 0xc5, 0x3e, 0x9d, 0x32, 0x47, 0xde, 0x96,
600 0xe1, 0x5d, 0xd8, 0xf8, 0xb4, 0x69, 0x6f, 0xb9,
601 0x15, 0x90, 0x57, 0x7a, 0xf6, 0xad, 0xb0, 0x5b,
602 0xf5, 0xa6, 0x36, 0x94, 0xfd, 0x84, 0xce, 0x1c,
603 0x0f, 0x4b, 0xd0, 0xc2, 0x5b, 0x6b, 0x56, 0xef,
604 0x73, 0x93, 0x0b, 0xc3, 0xee, 0xd9, 0xcf, 0xd3,
605 0xa4, 0x22, 0x58, 0xcd, 0x50, 0x6e, 0x65, 0xf4,
606 0xe9, 0xb7, 0x71, 0xaf, 0x4b, 0xb3, 0xb6, 0x2f,
607 0x0f, 0x0e, 0x3b, 0xc9, 0x85, 0x14, 0xf5, 0x17,
608 0xe8, 0x7a, 0x3a, 0xbf, 0x5f, 0x5e, 0xf8, 0x18,
609 0x48, 0xa6, 0x72, 0xab, 0x06, 0x95, 0xe9, 0xc8,
610 0xa7, 0xf4, 0x32, 0x44, 0x04, 0x0c, 0x84, 0x98,
611 0x73, 0xe3, 0x89, 0x8d, 0x5f, 0x7e, 0x4a, 0x42,
612 0x8f, 0xc5, 0x28, 0xb1, 0x82, 0xef, 0x1c, 0x97,
613 0x31, 0x3b, 0x4d, 0xe0, 0x0e, 0x10, 0x10, 0x97,
614 0x93, 0x49, 0x78, 0x2f, 0x0d, 0x86, 0x8b, 0xa1,
615 0x53, 0xa9, 0x81, 0x20, 0x79, 0xe7, 0x07, 0x77,
616 0xb6, 0xac, 0x5e, 0xd2, 0x05, 0xcd, 0xe9, 0xdb,
617 0x8a, 0x94, 0x82, 0x8a, 0x23, 0xb9, 0x3d, 0x1c,
618 0xa9, 0x7d, 0x72, 0x4a, 0xed, 0x33, 0xa3, 0xdb,
619 0x21, 0xa7, 0x86, 0x33, 0x45, 0xa5, 0xaa, 0x56,
620 0x45, 0xb5, 0x83, 0x29, 0x40, 0x47, 0x79, 0x04,
621 0x6e, 0xb9, 0x95, 0xd0, 0x81, 0x77, 0x2d, 0x48,
622 0x1e, 0xfe, 0xc3, 0xc2, 0x1e, 0xe5, 0xf2, 0xbe,
623 0xfd, 0x3b, 0x94, 0x9f, 0xc4, 0xc4, 0x26, 0x9d,
624 0xe4, 0x66, 0x1e, 0x19, 0xee, 0x6c, 0x79, 0x97,
625 0x11, 0x31, 0x4b, 0x0d, 0x01, 0xcb, 0xde, 0xa8,
626 0xf6, 0x6d, 0x7c, 0x39, 0x46, 0x4e, 0x7e, 0x3f,
627 0x94, 0x17, 0xdf, 0xa1, 0x7d, 0xd9, 0x1c, 0x8e,
628 0xbc, 0x7d, 0x33, 0x7d, 0xe3, 0x12, 0x40, 0xca,
629 0xab, 0x37, 0x11, 0x46, 0xd4, 0xae, 0xef, 0x44,
630 0xa2, 0xb3, 0x6a, 0x66, 0x0e, 0x0c, 0x90, 0x7f,
631 0xdf, 0x5c, 0x66, 0x5f, 0xf2, 0x94, 0x9f, 0xa6,
632 0x73, 0x4f, 0xeb, 0x0d, 0xad, 0xbf, 0xc0, 0x63,
633 0x5c, 0xdc, 0x46, 0x51, 0xe8, 0x8e, 0x90, 0x19,
634 0xa8, 0xa4, 0x3c, 0x91, 0x79, 0xfa, 0x7e, 0x58,
635 0x85, 0x13, 0x55, 0xc5, 0x19, 0x82, 0x37, 0x1b,
636 0x0a, 0x02, 0x1f, 0x99, 0x6b, 0x18, 0xf1, 0x28,
637 0x08, 0xa2, 0x73, 0xb8, 0x0f, 0x2e, 0xcd, 0xbf,
638 0xf3, 0x86, 0x7f, 0xea, 0xef, 0xd0, 0xbb, 0xa6,
639 0x21, 0xdf, 0x49, 0x73, 0x51, 0xcc, 0x36, 0xd3,
640 0x3e, 0xa0, 0xf8, 0x44, 0xdf, 0xd3, 0xa6, 0xbe,
641 0x8a, 0xd4, 0x57, 0xdd, 0x72, 0x94, 0x61, 0x0f,
642 0x82, 0xd1, 0x07, 0xb8, 0x7c, 0x18, 0x83, 0xdf,
643 0x3a, 0xe5, 0x50, 0x6a, 0x82, 0x20, 0xac, 0xa9,
644 0xa8, 0xff, 0xd9, 0xf3, 0x77, 0x33, 0x5a, 0x9e,
645 0x7f, 0x6d, 0xfe, 0x5d, 0x33, 0x41, 0x42, 0xe7,
646 0x6c, 0x19, 0xe0, 0x44, 0x8a, 0x15, 0xf6, 0x70,
647 0x98, 0xb7, 0x68, 0x4d, 0xfa, 0x97, 0x39, 0xb0,
648 0x8e, 0xe8, 0x84, 0x8b, 0x75, 0x30, 0xb7, 0x7d,
649 0x92, 0x69, 0x20, 0x9c, 0x81, 0xfb, 0x4b, 0xf4,
650 0x01, 0x50, 0xeb, 0xce, 0x0c, 0x1c, 0x6c, 0xb5,
651 0x4a, 0xd7, 0x27, 0x0c, 0xce, 0xbb, 0xe5, 0x85,
652 0xf0, 0xb6, 0xee, 0xd5, 0x70, 0xdd, 0x3b, 0xfc,
653 0xd4, 0x99, 0xf1, 0x33, 0xdd, 0x8b, 0xc4, 0x2f,
654 0xae, 0xab, 0x74, 0x96, 0x32, 0xc7, 0x4c, 0x56,
655 0x3c, 0x89, 0x0f, 0x96, 0x0b, 0x42, 0xc0, 0xcb,
656 0xee, 0x0f, 0x0b, 0x8c, 0xfb, 0x7e, 0x47, 0x7b,
657 0x64, 0x48, 0xfd, 0xb2, 0x00, 0x80, 0x89, 0xa5,
658 0x13, 0x55, 0x62, 0xfc, 0x8f, 0xe2, 0x42, 0x03,
659 0xb7, 0x4e, 0x2a, 0x79, 0xb4, 0x82, 0xea, 0x23,
660 0x49, 0xda, 0xaf, 0x52, 0x63, 0x1e, 0x60, 0x03,
661 0x89, 0x06, 0x44, 0x46, 0x08, 0xc3, 0xc4, 0x87,
662 0x70, 0x2e, 0xda, 0x94, 0xad, 0x6b, 0xe0, 0xe4,
663 0xd1, 0x8a, 0x06, 0xc2, 0xa8, 0xc0, 0xa7, 0x43,
664 0x3c, 0x47, 0x52, 0x0e, 0xc3, 0x77, 0x81, 0x11,
665 0x67, 0x0e, 0xa0, 0x70, 0x04, 0x47, 0x29, 0x40,
666 0x86, 0x0d, 0x34, 0x56, 0xa7, 0xc9, 0x35, 0x59,
667 0x68, 0xdc, 0x93, 0x81, 0x70, 0xee, 0x86, 0xd9,
668 0x80, 0x06, 0x40, 0x4f, 0x1a, 0x0d, 0x40, 0x30,
669 0x0b, 0xcb, 0x96, 0x47, 0xc1, 0xb7, 0x52, 0xfd,
670 0x56, 0xe0, 0x72, 0x4b, 0xfb, 0xbd, 0x92, 0x45,
671 0x61, 0x71, 0xc2, 0x33, 0x11, 0xbf, 0x52, 0x83,
672 0x79, 0x26, 0xe0, 0x49, 0x6b, 0xb7, 0x05, 0x8b,
673 0xe8, 0x0e, 0x87, 0x31, 0xd7, 0x9d, 0x8a, 0xf5,
674 0xc0, 0x5f, 0x2e, 0x58, 0x4a, 0xdb, 0x11, 0xb3,
675 0x6c, 0x30, 0x2a, 0x46, 0x19, 0xe3, 0x27, 0x84,
676 0x1f, 0x63, 0x6e, 0xf6, 0x57, 0xc7, 0xc9, 0xd8,
677 0x5e, 0xba, 0xb3, 0x87, 0xd5, 0x83, 0x26, 0x34,
678 0x21, 0x9e, 0x65, 0xde, 0x42, 0xd3, 0xbe, 0x7b,
679 0xbc, 0x91, 0x71, 0x44, 0x4d, 0x99, 0x3b, 0x31,
680 0xe5, 0x3f, 0x11, 0x4e, 0x7f, 0x13, 0x51, 0x3b,
681 0xae, 0x79, 0xc9, 0xd3, 0x81, 0x8e, 0x25, 0x40,
682 0x10, 0xfc, 0x07, 0x1e, 0xf9, 0x7b, 0x9a, 0x4b,
683 0x6c, 0xe3, 0xb3, 0xad, 0x1a, 0x0a, 0xdd, 0x9e,
684 0x59, 0x0c, 0xa2, 0xcd, 0xae, 0x48, 0x4a, 0x38,
685 0x5b, 0x47, 0x41, 0x94, 0x65, 0x6b, 0xbb, 0xeb,
686 0x5b, 0xe3, 0xaf, 0x07, 0x5b, 0xd4, 0x4a, 0xa2,
687 0xc9, 0x5d, 0x2f, 0x64, 0x03, 0xd7, 0x3a, 0x2c,
688 0x6e, 0xce, 0x76, 0x95, 0xb4, 0xb3, 0xc0, 0xf1,
689 0xe2, 0x45, 0x73, 0x7a, 0x5c, 0xab, 0xc1, 0xfc,
690 0x02, 0x8d, 0x81, 0x29, 0xb3, 0xac, 0x07, 0xec,
691 0x40, 0x7d, 0x45, 0xd9, 0x7a, 0x59, 0xee, 0x34,
692 0xf0, 0xe9, 0xd5, 0x7b, 0x96, 0xb1, 0x3d, 0x95,
693 0xcc, 0x86, 0xb5, 0xb6, 0x04, 0x2d, 0xb5, 0x92,
694 0x7e, 0x76, 0xf4, 0x06, 0xa9, 0xa3, 0x12, 0x0f,
695 0xb1, 0xaf, 0x26, 0xba, 0x7c, 0xfc, 0x7e, 0x1c,
696 0xbc, 0x2c, 0x49, 0x97, 0x53, 0x60, 0x13, 0x0b,
697 0xa6, 0x61, 0x83, 0x89, 0x42, 0xd4, 0x17, 0x0c,
698 0x6c, 0x26, 0x52, 0xc3, 0xb3, 0xd4, 0x67, 0xf5,
699 0xe3, 0x04, 0xb7, 0xf4, 0xcb, 0x80, 0xb8, 0xcb,
700 0x77, 0x56, 0x3e, 0xaa, 0x57, 0x54, 0xee, 0xb4,
701 0x2c, 0x67, 0xcf, 0xf2, 0xdc, 0xbe, 0x55, 0xf9,
702 0x43, 0x1f, 0x6e, 0x22, 0x97, 0x67, 0x7f, 0xc4,
703 0xef, 0xb1, 0x26, 0x31, 0x1e, 0x27, 0xdf, 0x41,
704 0x80, 0x47, 0x6c, 0xe2, 0xfa, 0xa9, 0x8c, 0x2a,
705 0xf6, 0xf2, 0xab, 0xf0, 0x15, 0xda, 0x6c, 0xc8,
706 0xfe, 0xb5, 0x23, 0xde, 0xa9, 0x05, 0x3f, 0x06,
707 0x54, 0x4c, 0xcd, 0xe1, 0xab, 0xfc, 0x0e, 0x62,
708 0x33, 0x31, 0x73, 0x2c, 0x76, 0xcb, 0xb4, 0x47,
709 0x1e, 0x20, 0xad, 0xd8, 0xf2, 0x31, 0xdd, 0xc4,
710 0x8b, 0x0c, 0x77, 0xbe, 0xe1, 0x8b, 0x26, 0x00,
711 0x02, 0x58, 0xd6, 0x8d, 0xef, 0xad, 0x74, 0x67,
712 0xab, 0x3f, 0xef, 0xcb, 0x6f, 0xb0, 0xcc, 0x81,
713 0x44, 0x4c, 0xaf, 0xe9, 0x49, 0x4f, 0xdb, 0xa0,
714 0x25, 0xa4, 0xf0, 0x89, 0xf1, 0xbe, 0xd8, 0x10,
715 0xff, 0xb1, 0x3b, 0x4b, 0xfa, 0x98, 0xf5, 0x79,
716 0x6d, 0x1e, 0x69, 0x4d, 0x57, 0xb1, 0xc8, 0x19,
717 0x1b, 0xbd, 0x1e, 0x8c, 0x84, 0xb7, 0x7b, 0xe8,
718 0xd2, 0x2d, 0x09, 0x41, 0x41, 0x37, 0x3d, 0xb1,
719 0x6f, 0x26, 0x5d, 0x71, 0x16, 0x3d, 0xb7, 0x83,
720 0x27, 0x2c, 0xa7, 0xb6, 0x50, 0xbd, 0x91, 0x86,
721 0xab, 0x24, 0xa1, 0x38, 0xfd, 0xea, 0x71, 0x55,
722 0x7e, 0x9a, 0x07, 0x77, 0x4b, 0xfa, 0x61, 0x66,
723 0x20, 0x1e, 0x28, 0x95, 0x18, 0x1b, 0xa4, 0xa0,
724 0xfd, 0xc0, 0x89, 0x72, 0x43, 0xd9, 0x3b, 0x49,
725 0x5a, 0x3f, 0x9d, 0xbf, 0xdb, 0xb4, 0x46, 0xea,
726 0x42, 0x01, 0x77, 0x23, 0x68, 0x95, 0xb6, 0x24,
727 0xb3, 0xa8, 0x6c, 0x28, 0x3b, 0x11, 0x40, 0x7e,
728 0x18, 0x65, 0x6d, 0xd8, 0x24, 0x42, 0x7d, 0x88,
729 0xc0, 0x52, 0xd9, 0x05, 0xe4, 0x95, 0x90, 0x87,
730 0x8c, 0xf4, 0xd0, 0x6b, 0xb9, 0x83, 0x99, 0x34,
731 0x6d, 0xfe, 0x54, 0x40, 0x94, 0x52, 0x21, 0x4f,
732 0x14, 0x25, 0xc5, 0xd6, 0x5e, 0x95, 0xdc, 0x0a,
733 0x2b, 0x89, 0x20, 0x11, 0x84, 0x48, 0xd6, 0x3a,
734 0xcd, 0x5c, 0x24, 0xad, 0x62, 0xe3, 0xb1, 0x93,
735 0x25, 0x8d, 0xcd, 0x7e, 0xfc, 0x27, 0xa3, 0x37,
736 0xfd, 0x84, 0xfc, 0x1b, 0xb2, 0xf1, 0x27, 0x38,
737 0x5a, 0xb7, 0xfc, 0xf2, 0xfa, 0x95, 0x66, 0xd4,
738 0xfb, 0xba, 0xa7, 0xd7, 0xa3, 0x72, 0x69, 0x48,
739 0x48, 0x8c, 0xeb, 0x28, 0x89, 0xfe, 0x33, 0x65,
740 0x5a, 0x36, 0x01, 0x7e, 0x06, 0x79, 0x0a, 0x09,
741 0x3b, 0x74, 0x11, 0x9a, 0x6e, 0xbf, 0xd4, 0x9e,
742 0x58, 0x90, 0x49, 0x4f, 0x4d, 0x08, 0xd4, 0xe5,
743 0x4a, 0x09, 0x21, 0xef, 0x8b, 0xb8, 0x74, 0x3b,
744 0x91, 0xdd, 0x36, 0x85, 0x60, 0x2d, 0xfa, 0xd4,
745 0x45, 0x7b, 0x45, 0x53, 0xf5, 0x47, 0x87, 0x7e,
746 0xa6, 0x37, 0xc8, 0x78, 0x7a, 0x68, 0x9d, 0x8d,
747 0x65, 0x2c, 0x0e, 0x91, 0x5c, 0xa2, 0x60, 0xf0,
748 0x8e, 0x3f, 0xe9, 0x1a, 0xcd, 0xaa, 0xe7, 0xd5,
749 0x77, 0x18, 0xaf, 0xc9, 0xbc, 0x18, 0xea, 0x48,
750 0x1b, 0xfb, 0x22, 0x48, 0x70, 0x16, 0x29, 0x9e,
751 0x5b, 0xc1, 0x2c, 0x66, 0x23, 0xbc, 0xf0, 0x1f,
752 0xef, 0xaf, 0xe4, 0xd6, 0x04, 0x19, 0x82, 0x7a,
753 0x0b, 0xba, 0x4b, 0x46, 0xb1, 0x6a, 0x85, 0x5d,
754 0xb4, 0x73, 0xd6, 0x21, 0xa1, 0x71, 0x60, 0x14,
755 0xee, 0x0a, 0x77, 0xc4, 0x66, 0x2e, 0xf9, 0x69,
756 0x30, 0xaf, 0x41, 0x0b, 0xc8, 0x83, 0x3c, 0x53,
757 0x99, 0x19, 0x27, 0x46, 0xf7, 0x41, 0x6e, 0x56,
758 0xdc, 0x94, 0x28, 0x67, 0x4e, 0xb7, 0x25, 0x48,
759 0x8a, 0xc2, 0xe0, 0x60, 0x96, 0xcc, 0x18, 0xf4,
760 0x84, 0xdd, 0xa7, 0x5e, 0x3e, 0x05, 0x0b, 0x26,
761 0x26, 0xb2, 0x5c, 0x1f, 0x57, 0x1a, 0x04, 0x7e,
762 0x6a, 0xe3, 0x2f, 0xb4, 0x35, 0xb6, 0x38, 0x40,
763 0x40, 0xcd, 0x6f, 0x87, 0x2e, 0xef, 0xa3, 0xd7,
764 0xa9, 0xc2, 0xe8, 0x0d, 0x27, 0xdf, 0x44, 0x62,
765 0x99, 0xa0, 0xfc, 0xcf, 0x81, 0x78, 0xcb, 0xfe,
766 0xe5, 0xa0, 0x03, 0x4e, 0x6c, 0xd7, 0xf4, 0xaf,
767 0x7a, 0xbb, 0x61, 0x82, 0xfe, 0x71, 0x89, 0xb2,
768 0x22, 0x7c, 0x8e, 0x83, 0x04, 0xce, 0xf6, 0x5d,
769 0x84, 0x8f, 0x95, 0x6a, 0x7f, 0xad, 0xfd, 0x32,
770 0x9c, 0x5e, 0xe4, 0x9c, 0x89, 0x60, 0x54, 0xaa,
771 0x96, 0x72, 0xd2, 0xd7, 0x36, 0x85, 0xa9, 0x45,
772 0xd2, 0x2a, 0xa1, 0x81, 0x49, 0x6f, 0x7e, 0x04,
773 0xfa, 0xe2, 0xfe, 0x90, 0x26, 0x77, 0x5a, 0x33,
774 0xb8, 0x04, 0x9a, 0x7a, 0xe6, 0x4c, 0x4f, 0xad,
775 0x72, 0x96, 0x08, 0x28, 0x58, 0x13, 0xf8, 0xc4,
776 0x1c, 0xf0, 0xc3, 0x45, 0x95, 0x49, 0x20, 0x8c,
777 0x9f, 0x39, 0x70, 0xe1, 0x77, 0xfe, 0xd5, 0x4b,
778 0xaf, 0x86, 0xda, 0xef, 0x22, 0x06, 0x83, 0x36,
779 0x29, 0x12, 0x11, 0x40, 0xbc, 0x3b, 0x86, 0xaa,
780 0xaa, 0x65, 0x60, 0xc3, 0x80, 0xca, 0xed, 0xa9,
781 0xf3, 0xb0, 0x79, 0x96, 0xa2, 0x55, 0x27, 0x28,
782 0x55, 0x73, 0x26, 0xa5, 0x50, 0xea, 0x92, 0x4b,
783 0x3c, 0x5c, 0x82, 0x33, 0xf0, 0x01, 0x3f, 0x03,
784 0xc1, 0x08, 0x05, 0xbf, 0x98, 0xf4, 0x9b, 0x6d,
785 0xa5, 0xa8, 0xb4, 0x82, 0x0c, 0x06, 0xfa, 0xff,
786 0x2d, 0x08, 0xf3, 0x05, 0x4f, 0x57, 0x2a, 0x39,
787 0xd4, 0x83, 0x0d, 0x75, 0x51, 0xd8, 0x5b, 0x1b,
788 0xd3, 0x51, 0x5a, 0x32, 0x2a, 0x9b, 0x32, 0xb2,
789 0xf2, 0xa4, 0x96, 0x12, 0xf2, 0xae, 0x40, 0x34,
790 0x67, 0xa8, 0xf5, 0x44, 0xd5, 0x35, 0x53, 0xfe,
791 0xa3, 0x60, 0x96, 0x63, 0x0f, 0x1f, 0x6e, 0xb0,
792 0x5a, 0x42, 0xa6, 0xfc, 0x51, 0x0b, 0x60, 0x27,
793 0xbc, 0x06, 0x71, 0xed, 0x65, 0x5b, 0x23, 0x86,
794 0x4a, 0x07, 0x3b, 0x22, 0x07, 0x46, 0xe6, 0x90,
795 0x3e, 0xf3, 0x25, 0x50, 0x1b, 0x4c, 0x7f, 0x03,
796 0x08, 0xa8, 0x36, 0x6b, 0x87, 0xe5, 0xe3, 0xdb,
797 0x9a, 0x38, 0x83, 0xff, 0x9f, 0x1a, 0x9f, 0x57,
798 0xa4, 0x2a, 0xf6, 0x37, 0xbc, 0x1a, 0xff, 0xc9,
799 0x1e, 0x35, 0x0c, 0xc3, 0x7c, 0xa3, 0xb2, 0xe5,
800 0xd2, 0xc6, 0xb4, 0x57, 0x47, 0xe4, 0x32, 0x16,
801 0x6d, 0xa9, 0xae, 0x64, 0xe6, 0x2d, 0x8d, 0xc5,
802 0x8d, 0x50, 0x8e, 0xe8, 0x1a, 0x22, 0x34, 0x2a,
803 0xd9, 0xeb, 0x51, 0x90, 0x4a, 0xb1, 0x41, 0x7d,
804 0x64, 0xf9, 0xb9, 0x0d, 0xf6, 0x23, 0x33, 0xb0,
805 0x33, 0xf4, 0xf7, 0x3f, 0x27, 0x84, 0xc6, 0x0f,
806 0x54, 0xa5, 0xc0, 0x2e, 0xec, 0x0b, 0x3a, 0x48,
807 0x6e, 0x80, 0x35, 0x81, 0x43, 0x9b, 0x90, 0xb1,
808 0xd0, 0x2b, 0xea, 0x21, 0xdc, 0xda, 0x5b, 0x09,
809 0xf4, 0xcc, 0x10, 0xb4, 0xc7, 0xfe, 0x79, 0x51,
810 0xc3, 0xc5, 0xac, 0x88, 0x74, 0x84, 0x0b, 0x4b,
811 0xca, 0x79, 0x16, 0x29, 0xfb, 0x69, 0x54, 0xdf,
812 0x41, 0x7e, 0xe9, 0xc7, 0x8e, 0xea, 0xa5, 0xfe,
813 0xfc, 0x76, 0x0e, 0x90, 0xc4, 0x92, 0x38, 0xad,
814 0x7b, 0x48, 0xe6, 0x6e, 0xf7, 0x21, 0xfd, 0x4e,
815 0x93, 0x0a, 0x7b, 0x41, 0x83, 0x68, 0xfb, 0x57,
816 0x51, 0x76, 0x34, 0xa9, 0x6c, 0x00, 0xaa, 0x4f,
817 0x66, 0x65, 0x98, 0x4a, 0x4f, 0xa3, 0xa0, 0xef,
818 0x69, 0x3f, 0xe3, 0x1c, 0x92, 0x8c, 0xfd, 0xd8,
819 0xe8, 0xde, 0x7c, 0x7f, 0x3e, 0x84, 0x8e, 0x69,
820 0x3c, 0xf1, 0xf2, 0x05, 0x46, 0xdc, 0x2f, 0x9d,
821 0x5e, 0x6e, 0x4c, 0xfb, 0xb5, 0x99, 0x2a, 0x59,
822 0x63, 0xc1, 0x34, 0xbc, 0x57, 0xc0, 0x0d, 0xb9,
823 0x61, 0x25, 0xf3, 0x33, 0x23, 0x51, 0xb6, 0x0d,
824 0x07, 0xa6, 0xab, 0x94, 0x4a, 0xb7, 0x2a, 0xea,
825 0xee, 0xac, 0xa3, 0xc3, 0x04, 0x8b, 0x0e, 0x56,
826 0xfe, 0x44, 0xa7, 0x39, 0xe2, 0xed, 0xed, 0xb4,
827 0x22, 0x2b, 0xac, 0x12, 0x32, 0x28, 0x91, 0xd8,
828 0xa5, 0xab, 0xff, 0x5f, 0xe0, 0x4b, 0xda, 0x78,
829 0x17, 0xda, 0xf1, 0x01, 0x5b, 0xcd, 0xe2, 0x5f,
830 0x50, 0x45, 0x73, 0x2b, 0xe4, 0x76, 0x77, 0xf4,
831 0x64, 0x1d, 0x43, 0xfb, 0x84, 0x7a, 0xea, 0x91,
832 0xae, 0xf9, 0x9e, 0xb7, 0xb4, 0xb0, 0x91, 0x5f,
833 0x16, 0x35, 0x9a, 0x11, 0xb8, 0xc7, 0xc1, 0x8c,
834 0xc6, 0x10, 0x8d, 0x2f, 0x63, 0x4a, 0xa7, 0x57,
835 0x3a, 0x51, 0xd6, 0x32, 0x2d, 0x64, 0x72, 0xd4,
836 0x66, 0xdc, 0x10, 0xa6, 0x67, 0xd6, 0x04, 0x23,
837 0x9d, 0x0a, 0x11, 0x77, 0xdd, 0x37, 0x94, 0x17,
838 0x3c, 0xbf, 0x8b, 0x65, 0xb0, 0x2e, 0x5e, 0x66,
839 0x47, 0x64, 0xac, 0xdd, 0xf0, 0x84, 0xfd, 0x39,
840 0xfa, 0x15, 0x5d, 0xef, 0xae, 0xca, 0xc1, 0x36,
841 0xa7, 0x5c, 0xbf, 0xc7, 0x08, 0xc2, 0x66, 0x00,
842 0x74, 0x74, 0x4e, 0x27, 0x3f, 0x55, 0x8a, 0xb7,
843 0x38, 0x66, 0x83, 0x6d, 0xcf, 0x99, 0x9e, 0x60,
844 0x8f, 0xdd, 0x2e, 0x62, 0x22, 0x0e, 0xef, 0x0c,
845 0x98, 0xa7, 0x85, 0x74, 0x3b, 0x9d, 0xec, 0x9e,
846 0xa9, 0x19, 0x72, 0xa5, 0x7f, 0x2c, 0x39, 0xb7,
847 0x7d, 0xb7, 0xf1, 0x12, 0x65, 0x27, 0x4b, 0x5a,
848 0xde, 0x17, 0xfe, 0xad, 0x44, 0xf3, 0x20, 0x4d,
849 0xfd, 0xe4, 0x1f, 0xb5, 0x81, 0xb0, 0x36, 0x37,
850 0x08, 0x6f, 0xc3, 0x0c, 0xe9, 0x85, 0x98, 0x82,
851 0xa9, 0x62, 0x0c, 0xc4, 0x97, 0xc0, 0x50, 0xc8,
852 0xa7, 0x3c, 0x50, 0x9f, 0x43, 0xb9, 0xcd, 0x5e,
853 0x4d, 0xfa, 0x1c, 0x4b, 0x0b, 0xa9, 0x98, 0x85,
854 0x38, 0x92, 0xac, 0x8d, 0xe4, 0xad, 0x9b, 0x98,
855 0xab, 0xd9, 0x38, 0xac, 0x62, 0x52, 0xa3, 0x22,
856 0x63, 0x0f, 0xbf, 0x95, 0x48, 0xdf, 0x69, 0xe7,
857 0x8b, 0x33, 0xd5, 0xb2, 0xbd, 0x05, 0x49, 0x49,
858 0x9d, 0x57, 0x73, 0x19, 0x33, 0xae, 0xfa, 0x33,
859 0xf1, 0x19, 0xa8, 0x80, 0xce, 0x04, 0x9f, 0xbc,
860 0x1d, 0x65, 0x82, 0x1b, 0xe5, 0x3a, 0x51, 0xc8,
861 0x1c, 0x21, 0xe3, 0x5d, 0xf3, 0x7d, 0x9b, 0x2f,
862 0x2c, 0x1d, 0x4a, 0x7f, 0x9b, 0x68, 0x35, 0xa3,
863 0xb2, 0x50, 0xf7, 0x62, 0x79, 0xcd, 0xf4, 0x98,
864 0x4f, 0xe5, 0x63, 0x7c, 0x3e, 0x45, 0x31, 0x8c,
865 0x16, 0xa0, 0x12, 0xc8, 0x58, 0xce, 0x39, 0xa6,
866 0xbc, 0x54, 0xdb, 0xc5, 0xe0, 0xd5, 0xba, 0xbc,
867 0xb9, 0x04, 0xf4, 0x8d, 0xe8, 0x2f, 0x15, 0x9d,
868};
869
870/* 100 test cases */
871static struct crc_test {
872 u32 crc; /* random starting crc */
873 u32 start; /* random 6 bit offset in buf */
874 u32 length; /* random 11 bit length of test */
875 u32 crc_le; /* expected crc32_le result */
876 u32 crc_be; /* expected crc32_be result */
877 u32 crc32c_le; /* expected crc32c_le result */
878} test[] =
879{
880 {0x674bf11d, 0x00000038, 0x00000542, 0x0af6d466, 0xd8b6e4c1, 0xf6e93d6c},
881 {0x35c672c6, 0x0000003a, 0x000001aa, 0xc6d3dfba, 0x28aaf3ad, 0x0fe92aca},
882 {0x496da28e, 0x00000039, 0x000005af, 0xd933660f, 0x5d57e81f, 0x52e1ebb8},
883 {0x09a9b90e, 0x00000027, 0x000001f8, 0xb45fe007, 0xf45fca9a, 0x0798af9a},
884 {0xdc97e5a9, 0x00000025, 0x000003b6, 0xf81a3562, 0xe0126ba2, 0x18eb3152},
885 {0x47c58900, 0x0000000a, 0x000000b9, 0x8e58eccf, 0xf3afc793, 0xd00d08c7},
886 {0x292561e8, 0x0000000c, 0x00000403, 0xa2ba8aaf, 0x0b797aed, 0x8ba966bc},
887 {0x415037f6, 0x00000003, 0x00000676, 0xa17d52e8, 0x7f0fdf35, 0x11d694a2},
888 {0x3466e707, 0x00000026, 0x00000042, 0x258319be, 0x75c484a2, 0x6ab3208d},
889 {0xafd1281b, 0x00000023, 0x000002ee, 0x4428eaf8, 0x06c7ad10, 0xba4603c5},
890 {0xd3857b18, 0x00000028, 0x000004a2, 0x5c430821, 0xb062b7cb, 0xe6071c6f},
891 {0x1d825a8f, 0x0000002b, 0x0000050b, 0xd2c45f0c, 0xd68634e0, 0x179ec30a},
892 {0x5033e3bc, 0x0000000b, 0x00000078, 0xa3ea4113, 0xac6d31fb, 0x0903beb8},
893 {0x94f1fb5e, 0x0000000f, 0x000003a2, 0xfbfc50b1, 0x3cfe50ed, 0x6a7cb4fa},
894 {0xc9a0fe14, 0x00000009, 0x00000473, 0x5fb61894, 0x87070591, 0xdb535801},
895 {0x88a034b1, 0x0000001c, 0x000005ad, 0xc1b16053, 0x46f95c67, 0x92bed597},
896 {0xf0f72239, 0x00000020, 0x0000026d, 0xa6fa58f3, 0xf8c2c1dd, 0x192a3f1b},
897 {0xcc20a5e3, 0x0000003b, 0x0000067a, 0x7740185a, 0x308b979a, 0xccbaec1a},
898 {0xce589c95, 0x0000002b, 0x00000641, 0xd055e987, 0x40aae25b, 0x7eabae4d},
899 {0x78edc885, 0x00000035, 0x000005be, 0xa39cb14b, 0x035b0d1f, 0x28c72982},
900 {0x9d40a377, 0x0000003b, 0x00000038, 0x1f47ccd2, 0x197fbc9d, 0xc3cd4d18},
901 {0x703d0e01, 0x0000003c, 0x000006f1, 0x88735e7c, 0xfed57c5a, 0xbca8f0e7},
902 {0x776bf505, 0x0000000f, 0x000005b2, 0x5cc4fc01, 0xf32efb97, 0x713f60b3},
903 {0x4a3e7854, 0x00000027, 0x000004b8, 0x8d923c82, 0x0cbfb4a2, 0xebd08fd5},
904 {0x209172dd, 0x0000003b, 0x00000356, 0xb89e9c2b, 0xd7868138, 0x64406c59},
905 {0x3ba4cc5b, 0x0000002f, 0x00000203, 0xe51601a9, 0x5b2a1032, 0x7421890e},
906 {0xfc62f297, 0x00000000, 0x00000079, 0x71a8e1a2, 0x5d88685f, 0xe9347603},
907 {0x64280b8b, 0x00000016, 0x000007ab, 0x0fa7a30c, 0xda3a455f, 0x1bef9060},
908 {0x97dd724b, 0x00000033, 0x000007ad, 0x5788b2f4, 0xd7326d32, 0x34720072},
909 {0x61394b52, 0x00000035, 0x00000571, 0xc66525f1, 0xcabe7fef, 0x48310f59},
910 {0x29b4faff, 0x00000024, 0x0000006e, 0xca13751e, 0x993648e0, 0x783a4213},
911 {0x29bfb1dc, 0x0000000b, 0x00000244, 0x436c43f7, 0x429f7a59, 0x9e8efd41},
912 {0x86ae934b, 0x00000035, 0x00000104, 0x0760ec93, 0x9cf7d0f4, 0xfc3d34a5},
913 {0xc4c1024e, 0x0000002e, 0x000006b1, 0x6516a3ec, 0x19321f9c, 0x17a52ae2},
914 {0x3287a80a, 0x00000026, 0x00000496, 0x0b257eb1, 0x754ebd51, 0x886d935a},
915 {0xa4db423e, 0x00000023, 0x0000045d, 0x9b3a66dc, 0x873e9f11, 0xeaaeaeb2},
916 {0x7a1078df, 0x00000015, 0x0000014a, 0x8c2484c5, 0x6a628659, 0x8e900a4b},
917 {0x6048bd5b, 0x00000006, 0x0000006a, 0x897e3559, 0xac9961af, 0xd74662b1},
918 {0xd8f9ea20, 0x0000003d, 0x00000277, 0x60eb905b, 0xed2aaf99, 0xd26752ba},
919 {0xea5ec3b4, 0x0000002a, 0x000004fe, 0x869965dc, 0x6c1f833b, 0x8b1fcd62},
920 {0x2dfb005d, 0x00000016, 0x00000345, 0x6a3b117e, 0xf05e8521, 0xf54342fe},
921 {0x5a214ade, 0x00000020, 0x000005b6, 0x467f70be, 0xcb22ccd3, 0x5b95b988},
922 {0xf0ab9cca, 0x00000032, 0x00000515, 0xed223df3, 0x7f3ef01d, 0x2e1176be},
923 {0x91b444f9, 0x0000002e, 0x000007f8, 0x84e9a983, 0x5676756f, 0x66120546},
924 {0x1b5d2ddb, 0x0000002e, 0x0000012c, 0xba638c4c, 0x3f42047b, 0xf256a5cc},
925 {0xd824d1bb, 0x0000003a, 0x000007b5, 0x6288653b, 0x3a3ebea0, 0x4af1dd69},
926 {0x0470180c, 0x00000034, 0x000001f0, 0x9d5b80d6, 0x3de08195, 0x56f0a04a},
927 {0xffaa3a3f, 0x00000036, 0x00000299, 0xf3a82ab8, 0x53e0c13d, 0x74f6b6b2},
928 {0x6406cfeb, 0x00000023, 0x00000600, 0xa920b8e8, 0xe4e2acf4, 0x085951fd},
929 {0xb24aaa38, 0x0000003e, 0x000004a1, 0x657cc328, 0x5077b2c3, 0xc65387eb},
930 {0x58b2ab7c, 0x00000039, 0x000002b4, 0x3a17ee7e, 0x9dcb3643, 0x1ca9257b},
931 {0x3db85970, 0x00000006, 0x000002b6, 0x95268b59, 0xb9812c10, 0xfd196d76},
932 {0x857830c5, 0x00000003, 0x00000590, 0x4ef439d5, 0xf042161d, 0x5ef88339},
933 {0xe1fcd978, 0x0000003e, 0x000007d8, 0xae8d8699, 0xce0a1ef5, 0x2c3714d9},
934 {0xb982a768, 0x00000016, 0x000006e0, 0x62fad3df, 0x5f8a067b, 0x58576548},
935 {0x1d581ce8, 0x0000001e, 0x0000058b, 0xf0f5da53, 0x26e39eee, 0xfd7c57de},
936 {0x2456719b, 0x00000025, 0x00000503, 0x4296ac64, 0xd50e4c14, 0xd5fedd59},
937 {0xfae6d8f2, 0x00000000, 0x0000055d, 0x057fdf2e, 0x2a31391a, 0x1cc3b17b},
938 {0xcba828e3, 0x00000039, 0x000002ce, 0xe3f22351, 0x8f00877b, 0x270eed73},
939 {0x13d25952, 0x0000000a, 0x0000072d, 0x76d4b4cc, 0x5eb67ec3, 0x91ecbb11},
940 {0x0342be3f, 0x00000015, 0x00000599, 0xec75d9f1, 0x9d4d2826, 0x05ed8d0c},
941 {0xeaa344e0, 0x00000014, 0x000004d8, 0x72a4c981, 0x2064ea06, 0x0b09ad5b},
942 {0xbbb52021, 0x0000003b, 0x00000272, 0x04af99fc, 0xaf042d35, 0xf8d511fb},
943 {0xb66384dc, 0x0000001d, 0x000007fc, 0xd7629116, 0x782bd801, 0x5ad832cc},
944 {0x616c01b6, 0x00000022, 0x000002c8, 0x5b1dab30, 0x783ce7d2, 0x1214d196},
945 {0xce2bdaad, 0x00000016, 0x0000062a, 0x932535c8, 0x3f02926d, 0x5747218a},
946 {0x00fe84d7, 0x00000005, 0x00000205, 0x850e50aa, 0x753d649c, 0xde8f14de},
947 {0xbebdcb4c, 0x00000006, 0x0000055d, 0xbeaa37a2, 0x2d8c9eba, 0x3563b7b9},
948 {0xd8b1a02a, 0x00000010, 0x00000387, 0x5017d2fc, 0x503541a5, 0x071475d0},
949 {0x3b96cad2, 0x00000036, 0x00000347, 0x1d2372ae, 0x926cd90b, 0x54c79d60},
950 {0xc94c1ed7, 0x00000005, 0x0000038b, 0x9e9fdb22, 0x144a9178, 0x4c53eee6},
951 {0x1aad454e, 0x00000025, 0x000002b2, 0xc3f6315c, 0x5c7a35b3, 0x10137a3c},
952 {0xa4fec9a6, 0x00000000, 0x000006d6, 0x90be5080, 0xa4107605, 0xaa9d6c73},
953 {0x1bbe71e2, 0x0000001f, 0x000002fd, 0x4e504c3b, 0x284ccaf1, 0xb63d23e7},
954 {0x4201c7e4, 0x00000002, 0x000002b7, 0x7822e3f9, 0x0cc912a9, 0x7f53e9cf},
955 {0x23fddc96, 0x00000003, 0x00000627, 0x8a385125, 0x07767e78, 0x13c1cd83},
956 {0xd82ba25c, 0x00000016, 0x0000063e, 0x98e4148a, 0x283330c9, 0x49ff5867},
957 {0x786f2032, 0x0000002d, 0x0000060f, 0xf201600a, 0xf561bfcd, 0x8467f211},
958 {0xfebe4e1f, 0x0000002a, 0x000004f2, 0x95e51961, 0xfd80dcab, 0x3f9683b2},
959 {0x1a6e0a39, 0x00000008, 0x00000672, 0x8af6c2a5, 0x78dd84cb, 0x76a3f874},
960 {0x56000ab8, 0x0000000e, 0x000000e5, 0x36bacb8f, 0x22ee1f77, 0x863b702f},
961 {0x4717fe0c, 0x00000000, 0x000006ec, 0x8439f342, 0x5c8e03da, 0xdc6c58ff},
962 {0xd5d5d68e, 0x0000003c, 0x000003a3, 0x46fff083, 0x177d1b39, 0x0622cc95},
963 {0xc25dd6c6, 0x00000024, 0x000006c0, 0x5ceb8eb4, 0x892b0d16, 0xe85605cd},
964 {0xe9b11300, 0x00000023, 0x00000683, 0x07a5d59a, 0x6c6a3208, 0x31da5f06},
965 {0x95cd285e, 0x00000001, 0x00000047, 0x7b3a4368, 0x0202c07e, 0xa1f2e784},
966 {0xd9245a25, 0x0000001e, 0x000003a6, 0xd33c1841, 0x1936c0d5, 0xb07cc616},
967 {0x103279db, 0x00000006, 0x0000039b, 0xca09b8a0, 0x77d62892, 0xbf943b6c},
968 {0x1cba3172, 0x00000027, 0x000001c8, 0xcb377194, 0xebe682db, 0x2c01af1c},
969 {0x8f613739, 0x0000000c, 0x000001df, 0xb4b0bc87, 0x7710bd43, 0x0fe5f56d},
970 {0x1c6aa90d, 0x0000001b, 0x0000053c, 0x70559245, 0xda7894ac, 0xf8943b2d},
971 {0xaabe5b93, 0x0000003d, 0x00000715, 0xcdbf42fa, 0x0c3b99e7, 0xe4d89272},
972 {0xf15dd038, 0x00000006, 0x000006db, 0x6e104aea, 0x8d5967f2, 0x7c2f6bbb},
973 {0x584dd49c, 0x00000020, 0x000007bc, 0x36b6cfd6, 0xad4e23b2, 0xabbf388b},
974 {0x5d8c9506, 0x00000020, 0x00000470, 0x4c62378e, 0x31d92640, 0x1dca1f4e},
975 {0xb80d17b0, 0x00000032, 0x00000346, 0x22a5bb88, 0x9a7ec89f, 0x5c170e23},
976 {0xdaf0592e, 0x00000023, 0x000007b0, 0x3cab3f99, 0x9b1fdd99, 0xc0e9d672},
977 {0x4793cc85, 0x0000000d, 0x00000706, 0xe82e04f6, 0xed3db6b7, 0xc18bdc86},
978 {0x82ebf64e, 0x00000009, 0x000007c3, 0x69d590a9, 0x9efa8499, 0xa874fcdd},
979 {0xb18a0319, 0x00000026, 0x000007db, 0x1cf98dcc, 0x8fa9ad6a, 0x9dc0bb48},
980};
981
982#include <linux/time.h>
983
984static int __init crc32c_test(void)
985{
986 int i;
987 int errors = 0;
988 int bytes = 0;
989 struct timespec start, stop;
990 u64 nsec;
991 unsigned long flags;
992
993 /* keep static to prevent cache warming code from
994 * getting eliminated by the compiler */
995 static u32 crc;
996
997 /* pre-warm the cache */
998 for (i = 0; i < 100; i++) {
999 bytes += 2*test[i].length;
1000
1001 crc ^= __crc32c_le(test[i].crc, test_buf +
1002 test[i].start, test[i].length);
1003 }
1004
1005 /* reduce OS noise */
1006 local_irq_save(flags);
1007 local_irq_disable();
1008
1009 getnstimeofday(&start);
1010 for (i = 0; i < 100; i++) {
1011 if (test[i].crc32c_le != __crc32c_le(test[i].crc, test_buf +
1012 test[i].start, test[i].length))
1013 errors++;
1014 }
1015 getnstimeofday(&stop);
1016
1017 local_irq_restore(flags);
1018 local_irq_enable();
1019
1020 nsec = stop.tv_nsec - start.tv_nsec +
1021 1000000000 * (stop.tv_sec - start.tv_sec);
1022
1023 pr_info("crc32c: CRC_LE_BITS = %d\n", CRC_LE_BITS);
1024
1025 if (errors)
1026 pr_warn("crc32c: %d self tests failed\n", errors);
1027 else {
1028 pr_info("crc32c: self tests passed, processed %d bytes in %lld nsec\n",
1029 bytes, nsec);
1030 }
1031
1032 return 0;
1033}
1034
1035static int __init crc32c_combine_test(void)
1036{
1037 int i, j;
1038 int errors = 0, runs = 0;
1039
1040 for (i = 0; i < 10; i++) {
1041 u32 crc_full;
1042
1043 crc_full = __crc32c_le(test[i].crc, test_buf + test[i].start,
1044 test[i].length);
1045 for (j = 0; j <= test[i].length; ++j) {
1046 u32 crc1, crc2;
1047 u32 len1 = j, len2 = test[i].length - j;
1048
1049 crc1 = __crc32c_le(test[i].crc, test_buf +
1050 test[i].start, len1);
1051 crc2 = __crc32c_le(0, test_buf + test[i].start +
1052 len1, len2);
1053
1054 if (!(crc_full == __crc32c_le_combine(crc1, crc2, len2) &&
1055 crc_full == test[i].crc32c_le))
1056 errors++;
1057 runs++;
1058 cond_resched();
1059 }
1060 }
1061
1062 if (errors)
1063 pr_warn("crc32c_combine: %d/%d self tests failed\n", errors, runs);
1064 else
1065 pr_info("crc32c_combine: %d self tests passed\n", runs);
1066
1067 return 0;
1068}
1069
1070static int __init crc32_test(void)
1071{
1072 int i;
1073 int errors = 0;
1074 int bytes = 0;
1075 struct timespec start, stop;
1076 u64 nsec;
1077 unsigned long flags;
1078
1079 /* keep static to prevent cache warming code from
1080 * getting eliminated by the compiler */
1081 static u32 crc;
1082
1083 /* pre-warm the cache */
1084 for (i = 0; i < 100; i++) {
1085 bytes += 2*test[i].length;
1086
1087 crc ^= crc32_le(test[i].crc, test_buf +
1088 test[i].start, test[i].length);
1089
1090 crc ^= crc32_be(test[i].crc, test_buf +
1091 test[i].start, test[i].length);
1092 }
1093
1094 /* reduce OS noise */
1095 local_irq_save(flags);
1096 local_irq_disable();
1097
1098 getnstimeofday(&start);
1099 for (i = 0; i < 100; i++) {
1100 if (test[i].crc_le != crc32_le(test[i].crc, test_buf +
1101 test[i].start, test[i].length))
1102 errors++;
1103
1104 if (test[i].crc_be != crc32_be(test[i].crc, test_buf +
1105 test[i].start, test[i].length))
1106 errors++;
1107 }
1108 getnstimeofday(&stop);
1109
1110 local_irq_restore(flags);
1111 local_irq_enable();
1112
1113 nsec = stop.tv_nsec - start.tv_nsec +
1114 1000000000 * (stop.tv_sec - start.tv_sec);
1115
1116 pr_info("crc32: CRC_LE_BITS = %d, CRC_BE BITS = %d\n",
1117 CRC_LE_BITS, CRC_BE_BITS);
1118
1119 if (errors)
1120 pr_warn("crc32: %d self tests failed\n", errors);
1121 else {
1122 pr_info("crc32: self tests passed, processed %d bytes in %lld nsec\n",
1123 bytes, nsec);
1124 }
1125
1126 return 0;
1127}
1128
1129static int __init crc32_combine_test(void)
1130{
1131 int i, j;
1132 int errors = 0, runs = 0;
1133
1134 for (i = 0; i < 10; i++) {
1135 u32 crc_full;
1136
1137 crc_full = crc32_le(test[i].crc, test_buf + test[i].start,
1138 test[i].length);
1139 for (j = 0; j <= test[i].length; ++j) {
1140 u32 crc1, crc2;
1141 u32 len1 = j, len2 = test[i].length - j;
1142
1143 crc1 = crc32_le(test[i].crc, test_buf +
1144 test[i].start, len1);
1145 crc2 = crc32_le(0, test_buf + test[i].start +
1146 len1, len2);
1147
1148 if (!(crc_full == crc32_le_combine(crc1, crc2, len2) &&
1149 crc_full == test[i].crc_le))
1150 errors++;
1151 runs++;
1152 cond_resched();
1153 }
1154 }
1155
1156 if (errors)
1157 pr_warn("crc32_combine: %d/%d self tests failed\n", errors, runs);
1158 else
1159 pr_info("crc32_combine: %d self tests passed\n", runs);
1160
1161 return 0;
1162}
1163
1164static int __init crc32test_init(void)
1165{
1166 crc32_test();
1167 crc32c_test();
1168
1169 crc32_combine_test();
1170 crc32c_combine_test();
1171
1172 return 0;
1173}
1174
1175static void __exit crc32_exit(void)
1176{
1177}
1178
1179module_init(crc32test_init);
1180module_exit(crc32_exit);
1181#endif /* CONFIG_CRC32_SELFTEST */