Commit 8f1603bd78a31f52927d398f600e47e2452997a6
Committed by
Tom Rini
1 parent
e090579d0a
Exists in
smarc_8mq_lf_v2020.04
and in
17 other branches
bch: don't use __BSD_VISIBLE to test for fls
Commit 4ecc988301bc8e981e6d7538c57cdb3aa82f7c1d assumes fls is in libc if __BSD_VISIBLE is defined. This appears to only be true on FreeBSD and DragonFlyBSD. OpenBSD defines __BSD_VISIBLE and does not have fls in strings.h/libc. Switch the test for __BSD_VISIBLE to one for __DragonFly__ and __FreeBSD__ to unbreak the build on OpenBSD. Signed-off-by: Jonathan Gray <jsg@jsg.id.au>
Showing 1 changed file with 1 additions and 1 deletions Inline Diff
lib/bch.c
1 | /* | 1 | /* |
2 | * Generic binary BCH encoding/decoding library | 2 | * Generic binary BCH encoding/decoding library |
3 | * | 3 | * |
4 | * SPDX-License-Identifier: GPL-2.0 | 4 | * SPDX-License-Identifier: GPL-2.0 |
5 | * | 5 | * |
6 | * Copyright © 2011 Parrot S.A. | 6 | * Copyright © 2011 Parrot S.A. |
7 | * | 7 | * |
8 | * Author: Ivan Djelic <ivan.djelic@parrot.com> | 8 | * Author: Ivan Djelic <ivan.djelic@parrot.com> |
9 | * | 9 | * |
10 | * Description: | 10 | * Description: |
11 | * | 11 | * |
12 | * This library provides runtime configurable encoding/decoding of binary | 12 | * This library provides runtime configurable encoding/decoding of binary |
13 | * Bose-Chaudhuri-Hocquenghem (BCH) codes. | 13 | * Bose-Chaudhuri-Hocquenghem (BCH) codes. |
14 | * | 14 | * |
15 | * Call init_bch to get a pointer to a newly allocated bch_control structure for | 15 | * Call init_bch to get a pointer to a newly allocated bch_control structure for |
16 | * the given m (Galois field order), t (error correction capability) and | 16 | * the given m (Galois field order), t (error correction capability) and |
17 | * (optional) primitive polynomial parameters. | 17 | * (optional) primitive polynomial parameters. |
18 | * | 18 | * |
19 | * Call encode_bch to compute and store ecc parity bytes to a given buffer. | 19 | * Call encode_bch to compute and store ecc parity bytes to a given buffer. |
20 | * Call decode_bch to detect and locate errors in received data. | 20 | * Call decode_bch to detect and locate errors in received data. |
21 | * | 21 | * |
22 | * On systems supporting hw BCH features, intermediate results may be provided | 22 | * On systems supporting hw BCH features, intermediate results may be provided |
23 | * to decode_bch in order to skip certain steps. See decode_bch() documentation | 23 | * to decode_bch in order to skip certain steps. See decode_bch() documentation |
24 | * for details. | 24 | * for details. |
25 | * | 25 | * |
26 | * Option CONFIG_BCH_CONST_PARAMS can be used to force fixed values of | 26 | * Option CONFIG_BCH_CONST_PARAMS can be used to force fixed values of |
27 | * parameters m and t; thus allowing extra compiler optimizations and providing | 27 | * parameters m and t; thus allowing extra compiler optimizations and providing |
28 | * better (up to 2x) encoding performance. Using this option makes sense when | 28 | * better (up to 2x) encoding performance. Using this option makes sense when |
29 | * (m,t) are fixed and known in advance, e.g. when using BCH error correction | 29 | * (m,t) are fixed and known in advance, e.g. when using BCH error correction |
30 | * on a particular NAND flash device. | 30 | * on a particular NAND flash device. |
31 | * | 31 | * |
32 | * Algorithmic details: | 32 | * Algorithmic details: |
33 | * | 33 | * |
34 | * Encoding is performed by processing 32 input bits in parallel, using 4 | 34 | * Encoding is performed by processing 32 input bits in parallel, using 4 |
35 | * remainder lookup tables. | 35 | * remainder lookup tables. |
36 | * | 36 | * |
37 | * The final stage of decoding involves the following internal steps: | 37 | * The final stage of decoding involves the following internal steps: |
38 | * a. Syndrome computation | 38 | * a. Syndrome computation |
39 | * b. Error locator polynomial computation using Berlekamp-Massey algorithm | 39 | * b. Error locator polynomial computation using Berlekamp-Massey algorithm |
40 | * c. Error locator root finding (by far the most expensive step) | 40 | * c. Error locator root finding (by far the most expensive step) |
41 | * | 41 | * |
42 | * In this implementation, step c is not performed using the usual Chien search. | 42 | * In this implementation, step c is not performed using the usual Chien search. |
43 | * Instead, an alternative approach described in [1] is used. It consists in | 43 | * Instead, an alternative approach described in [1] is used. It consists in |
44 | * factoring the error locator polynomial using the Berlekamp Trace algorithm | 44 | * factoring the error locator polynomial using the Berlekamp Trace algorithm |
45 | * (BTA) down to a certain degree (4), after which ad hoc low-degree polynomial | 45 | * (BTA) down to a certain degree (4), after which ad hoc low-degree polynomial |
46 | * solving techniques [2] are used. The resulting algorithm, called BTZ, yields | 46 | * solving techniques [2] are used. The resulting algorithm, called BTZ, yields |
47 | * much better performance than Chien search for usual (m,t) values (typically | 47 | * much better performance than Chien search for usual (m,t) values (typically |
48 | * m >= 13, t < 32, see [1]). | 48 | * m >= 13, t < 32, see [1]). |
49 | * | 49 | * |
50 | * [1] B. Biswas, V. Herbert. Efficient root finding of polynomials over fields | 50 | * [1] B. Biswas, V. Herbert. Efficient root finding of polynomials over fields |
51 | * of characteristic 2, in: Western European Workshop on Research in Cryptology | 51 | * of characteristic 2, in: Western European Workshop on Research in Cryptology |
52 | * - WEWoRC 2009, Graz, Austria, LNCS, Springer, July 2009, to appear. | 52 | * - WEWoRC 2009, Graz, Austria, LNCS, Springer, July 2009, to appear. |
53 | * [2] [Zin96] V.A. Zinoviev. On the solution of equations of degree 10 over | 53 | * [2] [Zin96] V.A. Zinoviev. On the solution of equations of degree 10 over |
54 | * finite fields GF(2^q). In Rapport de recherche INRIA no 2829, 1996. | 54 | * finite fields GF(2^q). In Rapport de recherche INRIA no 2829, 1996. |
55 | */ | 55 | */ |
56 | 56 | ||
57 | #ifndef USE_HOSTCC | 57 | #ifndef USE_HOSTCC |
58 | #include <common.h> | 58 | #include <common.h> |
59 | #include <ubi_uboot.h> | 59 | #include <ubi_uboot.h> |
60 | 60 | ||
61 | #include <linux/bitops.h> | 61 | #include <linux/bitops.h> |
62 | #else | 62 | #else |
63 | #include <errno.h> | 63 | #include <errno.h> |
64 | #if defined(__FreeBSD__) | 64 | #if defined(__FreeBSD__) |
65 | #include <sys/endian.h> | 65 | #include <sys/endian.h> |
66 | #else | 66 | #else |
67 | #include <endian.h> | 67 | #include <endian.h> |
68 | #endif | 68 | #endif |
69 | #include <stdint.h> | 69 | #include <stdint.h> |
70 | #include <stdlib.h> | 70 | #include <stdlib.h> |
71 | #include <string.h> | 71 | #include <string.h> |
72 | 72 | ||
73 | #undef cpu_to_be32 | 73 | #undef cpu_to_be32 |
74 | #define cpu_to_be32 htobe32 | 74 | #define cpu_to_be32 htobe32 |
75 | #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d)) | 75 | #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d)) |
76 | #define kmalloc(size, flags) malloc(size) | 76 | #define kmalloc(size, flags) malloc(size) |
77 | #define kzalloc(size, flags) calloc(1, size) | 77 | #define kzalloc(size, flags) calloc(1, size) |
78 | #define kfree free | 78 | #define kfree free |
79 | #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) | 79 | #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) |
80 | #endif | 80 | #endif |
81 | 81 | ||
82 | #include <asm/byteorder.h> | 82 | #include <asm/byteorder.h> |
83 | #include <linux/bch.h> | 83 | #include <linux/bch.h> |
84 | 84 | ||
85 | #if defined(CONFIG_BCH_CONST_PARAMS) | 85 | #if defined(CONFIG_BCH_CONST_PARAMS) |
86 | #define GF_M(_p) (CONFIG_BCH_CONST_M) | 86 | #define GF_M(_p) (CONFIG_BCH_CONST_M) |
87 | #define GF_T(_p) (CONFIG_BCH_CONST_T) | 87 | #define GF_T(_p) (CONFIG_BCH_CONST_T) |
88 | #define GF_N(_p) ((1 << (CONFIG_BCH_CONST_M))-1) | 88 | #define GF_N(_p) ((1 << (CONFIG_BCH_CONST_M))-1) |
89 | #else | 89 | #else |
90 | #define GF_M(_p) ((_p)->m) | 90 | #define GF_M(_p) ((_p)->m) |
91 | #define GF_T(_p) ((_p)->t) | 91 | #define GF_T(_p) ((_p)->t) |
92 | #define GF_N(_p) ((_p)->n) | 92 | #define GF_N(_p) ((_p)->n) |
93 | #endif | 93 | #endif |
94 | 94 | ||
95 | #define BCH_ECC_WORDS(_p) DIV_ROUND_UP(GF_M(_p)*GF_T(_p), 32) | 95 | #define BCH_ECC_WORDS(_p) DIV_ROUND_UP(GF_M(_p)*GF_T(_p), 32) |
96 | #define BCH_ECC_BYTES(_p) DIV_ROUND_UP(GF_M(_p)*GF_T(_p), 8) | 96 | #define BCH_ECC_BYTES(_p) DIV_ROUND_UP(GF_M(_p)*GF_T(_p), 8) |
97 | 97 | ||
98 | #ifndef dbg | 98 | #ifndef dbg |
99 | #define dbg(_fmt, args...) do {} while (0) | 99 | #define dbg(_fmt, args...) do {} while (0) |
100 | #endif | 100 | #endif |
101 | 101 | ||
102 | /* | 102 | /* |
103 | * represent a polynomial over GF(2^m) | 103 | * represent a polynomial over GF(2^m) |
104 | */ | 104 | */ |
105 | struct gf_poly { | 105 | struct gf_poly { |
106 | unsigned int deg; /* polynomial degree */ | 106 | unsigned int deg; /* polynomial degree */ |
107 | unsigned int c[0]; /* polynomial terms */ | 107 | unsigned int c[0]; /* polynomial terms */ |
108 | }; | 108 | }; |
109 | 109 | ||
110 | /* given its degree, compute a polynomial size in bytes */ | 110 | /* given its degree, compute a polynomial size in bytes */ |
111 | #define GF_POLY_SZ(_d) (sizeof(struct gf_poly)+((_d)+1)*sizeof(unsigned int)) | 111 | #define GF_POLY_SZ(_d) (sizeof(struct gf_poly)+((_d)+1)*sizeof(unsigned int)) |
112 | 112 | ||
113 | /* polynomial of degree 1 */ | 113 | /* polynomial of degree 1 */ |
114 | struct gf_poly_deg1 { | 114 | struct gf_poly_deg1 { |
115 | struct gf_poly poly; | 115 | struct gf_poly poly; |
116 | unsigned int c[2]; | 116 | unsigned int c[2]; |
117 | }; | 117 | }; |
118 | 118 | ||
119 | #ifdef USE_HOSTCC | 119 | #ifdef USE_HOSTCC |
120 | #ifndef __BSD_VISIBLE | 120 | #if !defined(__DragonFly__) && !defined(__FreeBSD__) |
121 | static int fls(int x) | 121 | static int fls(int x) |
122 | { | 122 | { |
123 | int r = 32; | 123 | int r = 32; |
124 | 124 | ||
125 | if (!x) | 125 | if (!x) |
126 | return 0; | 126 | return 0; |
127 | if (!(x & 0xffff0000u)) { | 127 | if (!(x & 0xffff0000u)) { |
128 | x <<= 16; | 128 | x <<= 16; |
129 | r -= 16; | 129 | r -= 16; |
130 | } | 130 | } |
131 | if (!(x & 0xff000000u)) { | 131 | if (!(x & 0xff000000u)) { |
132 | x <<= 8; | 132 | x <<= 8; |
133 | r -= 8; | 133 | r -= 8; |
134 | } | 134 | } |
135 | if (!(x & 0xf0000000u)) { | 135 | if (!(x & 0xf0000000u)) { |
136 | x <<= 4; | 136 | x <<= 4; |
137 | r -= 4; | 137 | r -= 4; |
138 | } | 138 | } |
139 | if (!(x & 0xc0000000u)) { | 139 | if (!(x & 0xc0000000u)) { |
140 | x <<= 2; | 140 | x <<= 2; |
141 | r -= 2; | 141 | r -= 2; |
142 | } | 142 | } |
143 | if (!(x & 0x80000000u)) { | 143 | if (!(x & 0x80000000u)) { |
144 | x <<= 1; | 144 | x <<= 1; |
145 | r -= 1; | 145 | r -= 1; |
146 | } | 146 | } |
147 | return r; | 147 | return r; |
148 | } | 148 | } |
149 | #endif | 149 | #endif |
150 | #endif | 150 | #endif |
151 | 151 | ||
152 | /* | 152 | /* |
153 | * same as encode_bch(), but process input data one byte at a time | 153 | * same as encode_bch(), but process input data one byte at a time |
154 | */ | 154 | */ |
155 | static void encode_bch_unaligned(struct bch_control *bch, | 155 | static void encode_bch_unaligned(struct bch_control *bch, |
156 | const unsigned char *data, unsigned int len, | 156 | const unsigned char *data, unsigned int len, |
157 | uint32_t *ecc) | 157 | uint32_t *ecc) |
158 | { | 158 | { |
159 | int i; | 159 | int i; |
160 | const uint32_t *p; | 160 | const uint32_t *p; |
161 | const int l = BCH_ECC_WORDS(bch)-1; | 161 | const int l = BCH_ECC_WORDS(bch)-1; |
162 | 162 | ||
163 | while (len--) { | 163 | while (len--) { |
164 | p = bch->mod8_tab + (l+1)*(((ecc[0] >> 24)^(*data++)) & 0xff); | 164 | p = bch->mod8_tab + (l+1)*(((ecc[0] >> 24)^(*data++)) & 0xff); |
165 | 165 | ||
166 | for (i = 0; i < l; i++) | 166 | for (i = 0; i < l; i++) |
167 | ecc[i] = ((ecc[i] << 8)|(ecc[i+1] >> 24))^(*p++); | 167 | ecc[i] = ((ecc[i] << 8)|(ecc[i+1] >> 24))^(*p++); |
168 | 168 | ||
169 | ecc[l] = (ecc[l] << 8)^(*p); | 169 | ecc[l] = (ecc[l] << 8)^(*p); |
170 | } | 170 | } |
171 | } | 171 | } |
172 | 172 | ||
173 | /* | 173 | /* |
174 | * convert ecc bytes to aligned, zero-padded 32-bit ecc words | 174 | * convert ecc bytes to aligned, zero-padded 32-bit ecc words |
175 | */ | 175 | */ |
176 | static void load_ecc8(struct bch_control *bch, uint32_t *dst, | 176 | static void load_ecc8(struct bch_control *bch, uint32_t *dst, |
177 | const uint8_t *src) | 177 | const uint8_t *src) |
178 | { | 178 | { |
179 | uint8_t pad[4] = {0, 0, 0, 0}; | 179 | uint8_t pad[4] = {0, 0, 0, 0}; |
180 | unsigned int i, nwords = BCH_ECC_WORDS(bch)-1; | 180 | unsigned int i, nwords = BCH_ECC_WORDS(bch)-1; |
181 | 181 | ||
182 | for (i = 0; i < nwords; i++, src += 4) | 182 | for (i = 0; i < nwords; i++, src += 4) |
183 | dst[i] = (src[0] << 24)|(src[1] << 16)|(src[2] << 8)|src[3]; | 183 | dst[i] = (src[0] << 24)|(src[1] << 16)|(src[2] << 8)|src[3]; |
184 | 184 | ||
185 | memcpy(pad, src, BCH_ECC_BYTES(bch)-4*nwords); | 185 | memcpy(pad, src, BCH_ECC_BYTES(bch)-4*nwords); |
186 | dst[nwords] = (pad[0] << 24)|(pad[1] << 16)|(pad[2] << 8)|pad[3]; | 186 | dst[nwords] = (pad[0] << 24)|(pad[1] << 16)|(pad[2] << 8)|pad[3]; |
187 | } | 187 | } |
188 | 188 | ||
189 | /* | 189 | /* |
190 | * convert 32-bit ecc words to ecc bytes | 190 | * convert 32-bit ecc words to ecc bytes |
191 | */ | 191 | */ |
192 | static void store_ecc8(struct bch_control *bch, uint8_t *dst, | 192 | static void store_ecc8(struct bch_control *bch, uint8_t *dst, |
193 | const uint32_t *src) | 193 | const uint32_t *src) |
194 | { | 194 | { |
195 | uint8_t pad[4]; | 195 | uint8_t pad[4]; |
196 | unsigned int i, nwords = BCH_ECC_WORDS(bch)-1; | 196 | unsigned int i, nwords = BCH_ECC_WORDS(bch)-1; |
197 | 197 | ||
198 | for (i = 0; i < nwords; i++) { | 198 | for (i = 0; i < nwords; i++) { |
199 | *dst++ = (src[i] >> 24); | 199 | *dst++ = (src[i] >> 24); |
200 | *dst++ = (src[i] >> 16) & 0xff; | 200 | *dst++ = (src[i] >> 16) & 0xff; |
201 | *dst++ = (src[i] >> 8) & 0xff; | 201 | *dst++ = (src[i] >> 8) & 0xff; |
202 | *dst++ = (src[i] >> 0) & 0xff; | 202 | *dst++ = (src[i] >> 0) & 0xff; |
203 | } | 203 | } |
204 | pad[0] = (src[nwords] >> 24); | 204 | pad[0] = (src[nwords] >> 24); |
205 | pad[1] = (src[nwords] >> 16) & 0xff; | 205 | pad[1] = (src[nwords] >> 16) & 0xff; |
206 | pad[2] = (src[nwords] >> 8) & 0xff; | 206 | pad[2] = (src[nwords] >> 8) & 0xff; |
207 | pad[3] = (src[nwords] >> 0) & 0xff; | 207 | pad[3] = (src[nwords] >> 0) & 0xff; |
208 | memcpy(dst, pad, BCH_ECC_BYTES(bch)-4*nwords); | 208 | memcpy(dst, pad, BCH_ECC_BYTES(bch)-4*nwords); |
209 | } | 209 | } |
210 | 210 | ||
211 | /** | 211 | /** |
212 | * encode_bch - calculate BCH ecc parity of data | 212 | * encode_bch - calculate BCH ecc parity of data |
213 | * @bch: BCH control structure | 213 | * @bch: BCH control structure |
214 | * @data: data to encode | 214 | * @data: data to encode |
215 | * @len: data length in bytes | 215 | * @len: data length in bytes |
216 | * @ecc: ecc parity data, must be initialized by caller | 216 | * @ecc: ecc parity data, must be initialized by caller |
217 | * | 217 | * |
218 | * The @ecc parity array is used both as input and output parameter, in order to | 218 | * The @ecc parity array is used both as input and output parameter, in order to |
219 | * allow incremental computations. It should be of the size indicated by member | 219 | * allow incremental computations. It should be of the size indicated by member |
220 | * @ecc_bytes of @bch, and should be initialized to 0 before the first call. | 220 | * @ecc_bytes of @bch, and should be initialized to 0 before the first call. |
221 | * | 221 | * |
222 | * The exact number of computed ecc parity bits is given by member @ecc_bits of | 222 | * The exact number of computed ecc parity bits is given by member @ecc_bits of |
223 | * @bch; it may be less than m*t for large values of t. | 223 | * @bch; it may be less than m*t for large values of t. |
224 | */ | 224 | */ |
225 | void encode_bch(struct bch_control *bch, const uint8_t *data, | 225 | void encode_bch(struct bch_control *bch, const uint8_t *data, |
226 | unsigned int len, uint8_t *ecc) | 226 | unsigned int len, uint8_t *ecc) |
227 | { | 227 | { |
228 | const unsigned int l = BCH_ECC_WORDS(bch)-1; | 228 | const unsigned int l = BCH_ECC_WORDS(bch)-1; |
229 | unsigned int i, mlen; | 229 | unsigned int i, mlen; |
230 | unsigned long m; | 230 | unsigned long m; |
231 | uint32_t w, r[l+1]; | 231 | uint32_t w, r[l+1]; |
232 | const uint32_t * const tab0 = bch->mod8_tab; | 232 | const uint32_t * const tab0 = bch->mod8_tab; |
233 | const uint32_t * const tab1 = tab0 + 256*(l+1); | 233 | const uint32_t * const tab1 = tab0 + 256*(l+1); |
234 | const uint32_t * const tab2 = tab1 + 256*(l+1); | 234 | const uint32_t * const tab2 = tab1 + 256*(l+1); |
235 | const uint32_t * const tab3 = tab2 + 256*(l+1); | 235 | const uint32_t * const tab3 = tab2 + 256*(l+1); |
236 | const uint32_t *pdata, *p0, *p1, *p2, *p3; | 236 | const uint32_t *pdata, *p0, *p1, *p2, *p3; |
237 | 237 | ||
238 | if (ecc) { | 238 | if (ecc) { |
239 | /* load ecc parity bytes into internal 32-bit buffer */ | 239 | /* load ecc parity bytes into internal 32-bit buffer */ |
240 | load_ecc8(bch, bch->ecc_buf, ecc); | 240 | load_ecc8(bch, bch->ecc_buf, ecc); |
241 | } else { | 241 | } else { |
242 | memset(bch->ecc_buf, 0, sizeof(r)); | 242 | memset(bch->ecc_buf, 0, sizeof(r)); |
243 | } | 243 | } |
244 | 244 | ||
245 | /* process first unaligned data bytes */ | 245 | /* process first unaligned data bytes */ |
246 | m = ((unsigned long)data) & 3; | 246 | m = ((unsigned long)data) & 3; |
247 | if (m) { | 247 | if (m) { |
248 | mlen = (len < (4-m)) ? len : 4-m; | 248 | mlen = (len < (4-m)) ? len : 4-m; |
249 | encode_bch_unaligned(bch, data, mlen, bch->ecc_buf); | 249 | encode_bch_unaligned(bch, data, mlen, bch->ecc_buf); |
250 | data += mlen; | 250 | data += mlen; |
251 | len -= mlen; | 251 | len -= mlen; |
252 | } | 252 | } |
253 | 253 | ||
254 | /* process 32-bit aligned data words */ | 254 | /* process 32-bit aligned data words */ |
255 | pdata = (uint32_t *)data; | 255 | pdata = (uint32_t *)data; |
256 | mlen = len/4; | 256 | mlen = len/4; |
257 | data += 4*mlen; | 257 | data += 4*mlen; |
258 | len -= 4*mlen; | 258 | len -= 4*mlen; |
259 | memcpy(r, bch->ecc_buf, sizeof(r)); | 259 | memcpy(r, bch->ecc_buf, sizeof(r)); |
260 | 260 | ||
261 | /* | 261 | /* |
262 | * split each 32-bit word into 4 polynomials of weight 8 as follows: | 262 | * split each 32-bit word into 4 polynomials of weight 8 as follows: |
263 | * | 263 | * |
264 | * 31 ...24 23 ...16 15 ... 8 7 ... 0 | 264 | * 31 ...24 23 ...16 15 ... 8 7 ... 0 |
265 | * xxxxxxxx yyyyyyyy zzzzzzzz tttttttt | 265 | * xxxxxxxx yyyyyyyy zzzzzzzz tttttttt |
266 | * tttttttt mod g = r0 (precomputed) | 266 | * tttttttt mod g = r0 (precomputed) |
267 | * zzzzzzzz 00000000 mod g = r1 (precomputed) | 267 | * zzzzzzzz 00000000 mod g = r1 (precomputed) |
268 | * yyyyyyyy 00000000 00000000 mod g = r2 (precomputed) | 268 | * yyyyyyyy 00000000 00000000 mod g = r2 (precomputed) |
269 | * xxxxxxxx 00000000 00000000 00000000 mod g = r3 (precomputed) | 269 | * xxxxxxxx 00000000 00000000 00000000 mod g = r3 (precomputed) |
270 | * xxxxxxxx yyyyyyyy zzzzzzzz tttttttt mod g = r0^r1^r2^r3 | 270 | * xxxxxxxx yyyyyyyy zzzzzzzz tttttttt mod g = r0^r1^r2^r3 |
271 | */ | 271 | */ |
272 | while (mlen--) { | 272 | while (mlen--) { |
273 | /* input data is read in big-endian format */ | 273 | /* input data is read in big-endian format */ |
274 | w = r[0]^cpu_to_be32(*pdata++); | 274 | w = r[0]^cpu_to_be32(*pdata++); |
275 | p0 = tab0 + (l+1)*((w >> 0) & 0xff); | 275 | p0 = tab0 + (l+1)*((w >> 0) & 0xff); |
276 | p1 = tab1 + (l+1)*((w >> 8) & 0xff); | 276 | p1 = tab1 + (l+1)*((w >> 8) & 0xff); |
277 | p2 = tab2 + (l+1)*((w >> 16) & 0xff); | 277 | p2 = tab2 + (l+1)*((w >> 16) & 0xff); |
278 | p3 = tab3 + (l+1)*((w >> 24) & 0xff); | 278 | p3 = tab3 + (l+1)*((w >> 24) & 0xff); |
279 | 279 | ||
280 | for (i = 0; i < l; i++) | 280 | for (i = 0; i < l; i++) |
281 | r[i] = r[i+1]^p0[i]^p1[i]^p2[i]^p3[i]; | 281 | r[i] = r[i+1]^p0[i]^p1[i]^p2[i]^p3[i]; |
282 | 282 | ||
283 | r[l] = p0[l]^p1[l]^p2[l]^p3[l]; | 283 | r[l] = p0[l]^p1[l]^p2[l]^p3[l]; |
284 | } | 284 | } |
285 | memcpy(bch->ecc_buf, r, sizeof(r)); | 285 | memcpy(bch->ecc_buf, r, sizeof(r)); |
286 | 286 | ||
287 | /* process last unaligned bytes */ | 287 | /* process last unaligned bytes */ |
288 | if (len) | 288 | if (len) |
289 | encode_bch_unaligned(bch, data, len, bch->ecc_buf); | 289 | encode_bch_unaligned(bch, data, len, bch->ecc_buf); |
290 | 290 | ||
291 | /* store ecc parity bytes into original parity buffer */ | 291 | /* store ecc parity bytes into original parity buffer */ |
292 | if (ecc) | 292 | if (ecc) |
293 | store_ecc8(bch, ecc, bch->ecc_buf); | 293 | store_ecc8(bch, ecc, bch->ecc_buf); |
294 | } | 294 | } |
295 | 295 | ||
296 | static inline int modulo(struct bch_control *bch, unsigned int v) | 296 | static inline int modulo(struct bch_control *bch, unsigned int v) |
297 | { | 297 | { |
298 | const unsigned int n = GF_N(bch); | 298 | const unsigned int n = GF_N(bch); |
299 | while (v >= n) { | 299 | while (v >= n) { |
300 | v -= n; | 300 | v -= n; |
301 | v = (v & n) + (v >> GF_M(bch)); | 301 | v = (v & n) + (v >> GF_M(bch)); |
302 | } | 302 | } |
303 | return v; | 303 | return v; |
304 | } | 304 | } |
305 | 305 | ||
306 | /* | 306 | /* |
307 | * shorter and faster modulo function, only works when v < 2N. | 307 | * shorter and faster modulo function, only works when v < 2N. |
308 | */ | 308 | */ |
309 | static inline int mod_s(struct bch_control *bch, unsigned int v) | 309 | static inline int mod_s(struct bch_control *bch, unsigned int v) |
310 | { | 310 | { |
311 | const unsigned int n = GF_N(bch); | 311 | const unsigned int n = GF_N(bch); |
312 | return (v < n) ? v : v-n; | 312 | return (v < n) ? v : v-n; |
313 | } | 313 | } |
314 | 314 | ||
315 | static inline int deg(unsigned int poly) | 315 | static inline int deg(unsigned int poly) |
316 | { | 316 | { |
317 | /* polynomial degree is the most-significant bit index */ | 317 | /* polynomial degree is the most-significant bit index */ |
318 | return fls(poly)-1; | 318 | return fls(poly)-1; |
319 | } | 319 | } |
320 | 320 | ||
321 | static inline int parity(unsigned int x) | 321 | static inline int parity(unsigned int x) |
322 | { | 322 | { |
323 | /* | 323 | /* |
324 | * public domain code snippet, lifted from | 324 | * public domain code snippet, lifted from |
325 | * http://www-graphics.stanford.edu/~seander/bithacks.html | 325 | * http://www-graphics.stanford.edu/~seander/bithacks.html |
326 | */ | 326 | */ |
327 | x ^= x >> 1; | 327 | x ^= x >> 1; |
328 | x ^= x >> 2; | 328 | x ^= x >> 2; |
329 | x = (x & 0x11111111U) * 0x11111111U; | 329 | x = (x & 0x11111111U) * 0x11111111U; |
330 | return (x >> 28) & 1; | 330 | return (x >> 28) & 1; |
331 | } | 331 | } |
332 | 332 | ||
333 | /* Galois field basic operations: multiply, divide, inverse, etc. */ | 333 | /* Galois field basic operations: multiply, divide, inverse, etc. */ |
334 | 334 | ||
335 | static inline unsigned int gf_mul(struct bch_control *bch, unsigned int a, | 335 | static inline unsigned int gf_mul(struct bch_control *bch, unsigned int a, |
336 | unsigned int b) | 336 | unsigned int b) |
337 | { | 337 | { |
338 | return (a && b) ? bch->a_pow_tab[mod_s(bch, bch->a_log_tab[a]+ | 338 | return (a && b) ? bch->a_pow_tab[mod_s(bch, bch->a_log_tab[a]+ |
339 | bch->a_log_tab[b])] : 0; | 339 | bch->a_log_tab[b])] : 0; |
340 | } | 340 | } |
341 | 341 | ||
342 | static inline unsigned int gf_sqr(struct bch_control *bch, unsigned int a) | 342 | static inline unsigned int gf_sqr(struct bch_control *bch, unsigned int a) |
343 | { | 343 | { |
344 | return a ? bch->a_pow_tab[mod_s(bch, 2*bch->a_log_tab[a])] : 0; | 344 | return a ? bch->a_pow_tab[mod_s(bch, 2*bch->a_log_tab[a])] : 0; |
345 | } | 345 | } |
346 | 346 | ||
347 | static inline unsigned int gf_div(struct bch_control *bch, unsigned int a, | 347 | static inline unsigned int gf_div(struct bch_control *bch, unsigned int a, |
348 | unsigned int b) | 348 | unsigned int b) |
349 | { | 349 | { |
350 | return a ? bch->a_pow_tab[mod_s(bch, bch->a_log_tab[a]+ | 350 | return a ? bch->a_pow_tab[mod_s(bch, bch->a_log_tab[a]+ |
351 | GF_N(bch)-bch->a_log_tab[b])] : 0; | 351 | GF_N(bch)-bch->a_log_tab[b])] : 0; |
352 | } | 352 | } |
353 | 353 | ||
354 | static inline unsigned int gf_inv(struct bch_control *bch, unsigned int a) | 354 | static inline unsigned int gf_inv(struct bch_control *bch, unsigned int a) |
355 | { | 355 | { |
356 | return bch->a_pow_tab[GF_N(bch)-bch->a_log_tab[a]]; | 356 | return bch->a_pow_tab[GF_N(bch)-bch->a_log_tab[a]]; |
357 | } | 357 | } |
358 | 358 | ||
359 | static inline unsigned int a_pow(struct bch_control *bch, int i) | 359 | static inline unsigned int a_pow(struct bch_control *bch, int i) |
360 | { | 360 | { |
361 | return bch->a_pow_tab[modulo(bch, i)]; | 361 | return bch->a_pow_tab[modulo(bch, i)]; |
362 | } | 362 | } |
363 | 363 | ||
364 | static inline int a_log(struct bch_control *bch, unsigned int x) | 364 | static inline int a_log(struct bch_control *bch, unsigned int x) |
365 | { | 365 | { |
366 | return bch->a_log_tab[x]; | 366 | return bch->a_log_tab[x]; |
367 | } | 367 | } |
368 | 368 | ||
369 | static inline int a_ilog(struct bch_control *bch, unsigned int x) | 369 | static inline int a_ilog(struct bch_control *bch, unsigned int x) |
370 | { | 370 | { |
371 | return mod_s(bch, GF_N(bch)-bch->a_log_tab[x]); | 371 | return mod_s(bch, GF_N(bch)-bch->a_log_tab[x]); |
372 | } | 372 | } |
373 | 373 | ||
374 | /* | 374 | /* |
375 | * compute 2t syndromes of ecc polynomial, i.e. ecc(a^j) for j=1..2t | 375 | * compute 2t syndromes of ecc polynomial, i.e. ecc(a^j) for j=1..2t |
376 | */ | 376 | */ |
377 | static void compute_syndromes(struct bch_control *bch, uint32_t *ecc, | 377 | static void compute_syndromes(struct bch_control *bch, uint32_t *ecc, |
378 | unsigned int *syn) | 378 | unsigned int *syn) |
379 | { | 379 | { |
380 | int i, j, s; | 380 | int i, j, s; |
381 | unsigned int m; | 381 | unsigned int m; |
382 | uint32_t poly; | 382 | uint32_t poly; |
383 | const int t = GF_T(bch); | 383 | const int t = GF_T(bch); |
384 | 384 | ||
385 | s = bch->ecc_bits; | 385 | s = bch->ecc_bits; |
386 | 386 | ||
387 | /* make sure extra bits in last ecc word are cleared */ | 387 | /* make sure extra bits in last ecc word are cleared */ |
388 | m = ((unsigned int)s) & 31; | 388 | m = ((unsigned int)s) & 31; |
389 | if (m) | 389 | if (m) |
390 | ecc[s/32] &= ~((1u << (32-m))-1); | 390 | ecc[s/32] &= ~((1u << (32-m))-1); |
391 | memset(syn, 0, 2*t*sizeof(*syn)); | 391 | memset(syn, 0, 2*t*sizeof(*syn)); |
392 | 392 | ||
393 | /* compute v(a^j) for j=1 .. 2t-1 */ | 393 | /* compute v(a^j) for j=1 .. 2t-1 */ |
394 | do { | 394 | do { |
395 | poly = *ecc++; | 395 | poly = *ecc++; |
396 | s -= 32; | 396 | s -= 32; |
397 | while (poly) { | 397 | while (poly) { |
398 | i = deg(poly); | 398 | i = deg(poly); |
399 | for (j = 0; j < 2*t; j += 2) | 399 | for (j = 0; j < 2*t; j += 2) |
400 | syn[j] ^= a_pow(bch, (j+1)*(i+s)); | 400 | syn[j] ^= a_pow(bch, (j+1)*(i+s)); |
401 | 401 | ||
402 | poly ^= (1 << i); | 402 | poly ^= (1 << i); |
403 | } | 403 | } |
404 | } while (s > 0); | 404 | } while (s > 0); |
405 | 405 | ||
406 | /* v(a^(2j)) = v(a^j)^2 */ | 406 | /* v(a^(2j)) = v(a^j)^2 */ |
407 | for (j = 0; j < t; j++) | 407 | for (j = 0; j < t; j++) |
408 | syn[2*j+1] = gf_sqr(bch, syn[j]); | 408 | syn[2*j+1] = gf_sqr(bch, syn[j]); |
409 | } | 409 | } |
410 | 410 | ||
411 | static void gf_poly_copy(struct gf_poly *dst, struct gf_poly *src) | 411 | static void gf_poly_copy(struct gf_poly *dst, struct gf_poly *src) |
412 | { | 412 | { |
413 | memcpy(dst, src, GF_POLY_SZ(src->deg)); | 413 | memcpy(dst, src, GF_POLY_SZ(src->deg)); |
414 | } | 414 | } |
415 | 415 | ||
416 | static int compute_error_locator_polynomial(struct bch_control *bch, | 416 | static int compute_error_locator_polynomial(struct bch_control *bch, |
417 | const unsigned int *syn) | 417 | const unsigned int *syn) |
418 | { | 418 | { |
419 | const unsigned int t = GF_T(bch); | 419 | const unsigned int t = GF_T(bch); |
420 | const unsigned int n = GF_N(bch); | 420 | const unsigned int n = GF_N(bch); |
421 | unsigned int i, j, tmp, l, pd = 1, d = syn[0]; | 421 | unsigned int i, j, tmp, l, pd = 1, d = syn[0]; |
422 | struct gf_poly *elp = bch->elp; | 422 | struct gf_poly *elp = bch->elp; |
423 | struct gf_poly *pelp = bch->poly_2t[0]; | 423 | struct gf_poly *pelp = bch->poly_2t[0]; |
424 | struct gf_poly *elp_copy = bch->poly_2t[1]; | 424 | struct gf_poly *elp_copy = bch->poly_2t[1]; |
425 | int k, pp = -1; | 425 | int k, pp = -1; |
426 | 426 | ||
427 | memset(pelp, 0, GF_POLY_SZ(2*t)); | 427 | memset(pelp, 0, GF_POLY_SZ(2*t)); |
428 | memset(elp, 0, GF_POLY_SZ(2*t)); | 428 | memset(elp, 0, GF_POLY_SZ(2*t)); |
429 | 429 | ||
430 | pelp->deg = 0; | 430 | pelp->deg = 0; |
431 | pelp->c[0] = 1; | 431 | pelp->c[0] = 1; |
432 | elp->deg = 0; | 432 | elp->deg = 0; |
433 | elp->c[0] = 1; | 433 | elp->c[0] = 1; |
434 | 434 | ||
435 | /* use simplified binary Berlekamp-Massey algorithm */ | 435 | /* use simplified binary Berlekamp-Massey algorithm */ |
436 | for (i = 0; (i < t) && (elp->deg <= t); i++) { | 436 | for (i = 0; (i < t) && (elp->deg <= t); i++) { |
437 | if (d) { | 437 | if (d) { |
438 | k = 2*i-pp; | 438 | k = 2*i-pp; |
439 | gf_poly_copy(elp_copy, elp); | 439 | gf_poly_copy(elp_copy, elp); |
440 | /* e[i+1](X) = e[i](X)+di*dp^-1*X^2(i-p)*e[p](X) */ | 440 | /* e[i+1](X) = e[i](X)+di*dp^-1*X^2(i-p)*e[p](X) */ |
441 | tmp = a_log(bch, d)+n-a_log(bch, pd); | 441 | tmp = a_log(bch, d)+n-a_log(bch, pd); |
442 | for (j = 0; j <= pelp->deg; j++) { | 442 | for (j = 0; j <= pelp->deg; j++) { |
443 | if (pelp->c[j]) { | 443 | if (pelp->c[j]) { |
444 | l = a_log(bch, pelp->c[j]); | 444 | l = a_log(bch, pelp->c[j]); |
445 | elp->c[j+k] ^= a_pow(bch, tmp+l); | 445 | elp->c[j+k] ^= a_pow(bch, tmp+l); |
446 | } | 446 | } |
447 | } | 447 | } |
448 | /* compute l[i+1] = max(l[i]->c[l[p]+2*(i-p]) */ | 448 | /* compute l[i+1] = max(l[i]->c[l[p]+2*(i-p]) */ |
449 | tmp = pelp->deg+k; | 449 | tmp = pelp->deg+k; |
450 | if (tmp > elp->deg) { | 450 | if (tmp > elp->deg) { |
451 | elp->deg = tmp; | 451 | elp->deg = tmp; |
452 | gf_poly_copy(pelp, elp_copy); | 452 | gf_poly_copy(pelp, elp_copy); |
453 | pd = d; | 453 | pd = d; |
454 | pp = 2*i; | 454 | pp = 2*i; |
455 | } | 455 | } |
456 | } | 456 | } |
457 | /* di+1 = S(2i+3)+elp[i+1].1*S(2i+2)+...+elp[i+1].lS(2i+3-l) */ | 457 | /* di+1 = S(2i+3)+elp[i+1].1*S(2i+2)+...+elp[i+1].lS(2i+3-l) */ |
458 | if (i < t-1) { | 458 | if (i < t-1) { |
459 | d = syn[2*i+2]; | 459 | d = syn[2*i+2]; |
460 | for (j = 1; j <= elp->deg; j++) | 460 | for (j = 1; j <= elp->deg; j++) |
461 | d ^= gf_mul(bch, elp->c[j], syn[2*i+2-j]); | 461 | d ^= gf_mul(bch, elp->c[j], syn[2*i+2-j]); |
462 | } | 462 | } |
463 | } | 463 | } |
464 | dbg("elp=%s\n", gf_poly_str(elp)); | 464 | dbg("elp=%s\n", gf_poly_str(elp)); |
465 | return (elp->deg > t) ? -1 : (int)elp->deg; | 465 | return (elp->deg > t) ? -1 : (int)elp->deg; |
466 | } | 466 | } |
467 | 467 | ||
468 | /* | 468 | /* |
469 | * solve a m x m linear system in GF(2) with an expected number of solutions, | 469 | * solve a m x m linear system in GF(2) with an expected number of solutions, |
470 | * and return the number of found solutions | 470 | * and return the number of found solutions |
471 | */ | 471 | */ |
472 | static int solve_linear_system(struct bch_control *bch, unsigned int *rows, | 472 | static int solve_linear_system(struct bch_control *bch, unsigned int *rows, |
473 | unsigned int *sol, int nsol) | 473 | unsigned int *sol, int nsol) |
474 | { | 474 | { |
475 | const int m = GF_M(bch); | 475 | const int m = GF_M(bch); |
476 | unsigned int tmp, mask; | 476 | unsigned int tmp, mask; |
477 | int rem, c, r, p, k, param[m]; | 477 | int rem, c, r, p, k, param[m]; |
478 | 478 | ||
479 | k = 0; | 479 | k = 0; |
480 | mask = 1 << m; | 480 | mask = 1 << m; |
481 | 481 | ||
482 | /* Gaussian elimination */ | 482 | /* Gaussian elimination */ |
483 | for (c = 0; c < m; c++) { | 483 | for (c = 0; c < m; c++) { |
484 | rem = 0; | 484 | rem = 0; |
485 | p = c-k; | 485 | p = c-k; |
486 | /* find suitable row for elimination */ | 486 | /* find suitable row for elimination */ |
487 | for (r = p; r < m; r++) { | 487 | for (r = p; r < m; r++) { |
488 | if (rows[r] & mask) { | 488 | if (rows[r] & mask) { |
489 | if (r != p) { | 489 | if (r != p) { |
490 | tmp = rows[r]; | 490 | tmp = rows[r]; |
491 | rows[r] = rows[p]; | 491 | rows[r] = rows[p]; |
492 | rows[p] = tmp; | 492 | rows[p] = tmp; |
493 | } | 493 | } |
494 | rem = r+1; | 494 | rem = r+1; |
495 | break; | 495 | break; |
496 | } | 496 | } |
497 | } | 497 | } |
498 | if (rem) { | 498 | if (rem) { |
499 | /* perform elimination on remaining rows */ | 499 | /* perform elimination on remaining rows */ |
500 | tmp = rows[p]; | 500 | tmp = rows[p]; |
501 | for (r = rem; r < m; r++) { | 501 | for (r = rem; r < m; r++) { |
502 | if (rows[r] & mask) | 502 | if (rows[r] & mask) |
503 | rows[r] ^= tmp; | 503 | rows[r] ^= tmp; |
504 | } | 504 | } |
505 | } else { | 505 | } else { |
506 | /* elimination not needed, store defective row index */ | 506 | /* elimination not needed, store defective row index */ |
507 | param[k++] = c; | 507 | param[k++] = c; |
508 | } | 508 | } |
509 | mask >>= 1; | 509 | mask >>= 1; |
510 | } | 510 | } |
511 | /* rewrite system, inserting fake parameter rows */ | 511 | /* rewrite system, inserting fake parameter rows */ |
512 | if (k > 0) { | 512 | if (k > 0) { |
513 | p = k; | 513 | p = k; |
514 | for (r = m-1; r >= 0; r--) { | 514 | for (r = m-1; r >= 0; r--) { |
515 | if ((r > m-1-k) && rows[r]) | 515 | if ((r > m-1-k) && rows[r]) |
516 | /* system has no solution */ | 516 | /* system has no solution */ |
517 | return 0; | 517 | return 0; |
518 | 518 | ||
519 | rows[r] = (p && (r == param[p-1])) ? | 519 | rows[r] = (p && (r == param[p-1])) ? |
520 | p--, 1u << (m-r) : rows[r-p]; | 520 | p--, 1u << (m-r) : rows[r-p]; |
521 | } | 521 | } |
522 | } | 522 | } |
523 | 523 | ||
524 | if (nsol != (1 << k)) | 524 | if (nsol != (1 << k)) |
525 | /* unexpected number of solutions */ | 525 | /* unexpected number of solutions */ |
526 | return 0; | 526 | return 0; |
527 | 527 | ||
528 | for (p = 0; p < nsol; p++) { | 528 | for (p = 0; p < nsol; p++) { |
529 | /* set parameters for p-th solution */ | 529 | /* set parameters for p-th solution */ |
530 | for (c = 0; c < k; c++) | 530 | for (c = 0; c < k; c++) |
531 | rows[param[c]] = (rows[param[c]] & ~1)|((p >> c) & 1); | 531 | rows[param[c]] = (rows[param[c]] & ~1)|((p >> c) & 1); |
532 | 532 | ||
533 | /* compute unique solution */ | 533 | /* compute unique solution */ |
534 | tmp = 0; | 534 | tmp = 0; |
535 | for (r = m-1; r >= 0; r--) { | 535 | for (r = m-1; r >= 0; r--) { |
536 | mask = rows[r] & (tmp|1); | 536 | mask = rows[r] & (tmp|1); |
537 | tmp |= parity(mask) << (m-r); | 537 | tmp |= parity(mask) << (m-r); |
538 | } | 538 | } |
539 | sol[p] = tmp >> 1; | 539 | sol[p] = tmp >> 1; |
540 | } | 540 | } |
541 | return nsol; | 541 | return nsol; |
542 | } | 542 | } |
543 | 543 | ||
544 | /* | 544 | /* |
545 | * this function builds and solves a linear system for finding roots of a degree | 545 | * this function builds and solves a linear system for finding roots of a degree |
546 | * 4 affine monic polynomial X^4+aX^2+bX+c over GF(2^m). | 546 | * 4 affine monic polynomial X^4+aX^2+bX+c over GF(2^m). |
547 | */ | 547 | */ |
548 | static int find_affine4_roots(struct bch_control *bch, unsigned int a, | 548 | static int find_affine4_roots(struct bch_control *bch, unsigned int a, |
549 | unsigned int b, unsigned int c, | 549 | unsigned int b, unsigned int c, |
550 | unsigned int *roots) | 550 | unsigned int *roots) |
551 | { | 551 | { |
552 | int i, j, k; | 552 | int i, j, k; |
553 | const int m = GF_M(bch); | 553 | const int m = GF_M(bch); |
554 | unsigned int mask = 0xff, t, rows[16] = {0,}; | 554 | unsigned int mask = 0xff, t, rows[16] = {0,}; |
555 | 555 | ||
556 | j = a_log(bch, b); | 556 | j = a_log(bch, b); |
557 | k = a_log(bch, a); | 557 | k = a_log(bch, a); |
558 | rows[0] = c; | 558 | rows[0] = c; |
559 | 559 | ||
560 | /* buid linear system to solve X^4+aX^2+bX+c = 0 */ | 560 | /* buid linear system to solve X^4+aX^2+bX+c = 0 */ |
561 | for (i = 0; i < m; i++) { | 561 | for (i = 0; i < m; i++) { |
562 | rows[i+1] = bch->a_pow_tab[4*i]^ | 562 | rows[i+1] = bch->a_pow_tab[4*i]^ |
563 | (a ? bch->a_pow_tab[mod_s(bch, k)] : 0)^ | 563 | (a ? bch->a_pow_tab[mod_s(bch, k)] : 0)^ |
564 | (b ? bch->a_pow_tab[mod_s(bch, j)] : 0); | 564 | (b ? bch->a_pow_tab[mod_s(bch, j)] : 0); |
565 | j++; | 565 | j++; |
566 | k += 2; | 566 | k += 2; |
567 | } | 567 | } |
568 | /* | 568 | /* |
569 | * transpose 16x16 matrix before passing it to linear solver | 569 | * transpose 16x16 matrix before passing it to linear solver |
570 | * warning: this code assumes m < 16 | 570 | * warning: this code assumes m < 16 |
571 | */ | 571 | */ |
572 | for (j = 8; j != 0; j >>= 1, mask ^= (mask << j)) { | 572 | for (j = 8; j != 0; j >>= 1, mask ^= (mask << j)) { |
573 | for (k = 0; k < 16; k = (k+j+1) & ~j) { | 573 | for (k = 0; k < 16; k = (k+j+1) & ~j) { |
574 | t = ((rows[k] >> j)^rows[k+j]) & mask; | 574 | t = ((rows[k] >> j)^rows[k+j]) & mask; |
575 | rows[k] ^= (t << j); | 575 | rows[k] ^= (t << j); |
576 | rows[k+j] ^= t; | 576 | rows[k+j] ^= t; |
577 | } | 577 | } |
578 | } | 578 | } |
579 | return solve_linear_system(bch, rows, roots, 4); | 579 | return solve_linear_system(bch, rows, roots, 4); |
580 | } | 580 | } |
581 | 581 | ||
582 | /* | 582 | /* |
583 | * compute root r of a degree 1 polynomial over GF(2^m) (returned as log(1/r)) | 583 | * compute root r of a degree 1 polynomial over GF(2^m) (returned as log(1/r)) |
584 | */ | 584 | */ |
585 | static int find_poly_deg1_roots(struct bch_control *bch, struct gf_poly *poly, | 585 | static int find_poly_deg1_roots(struct bch_control *bch, struct gf_poly *poly, |
586 | unsigned int *roots) | 586 | unsigned int *roots) |
587 | { | 587 | { |
588 | int n = 0; | 588 | int n = 0; |
589 | 589 | ||
590 | if (poly->c[0]) | 590 | if (poly->c[0]) |
591 | /* poly[X] = bX+c with c!=0, root=c/b */ | 591 | /* poly[X] = bX+c with c!=0, root=c/b */ |
592 | roots[n++] = mod_s(bch, GF_N(bch)-bch->a_log_tab[poly->c[0]]+ | 592 | roots[n++] = mod_s(bch, GF_N(bch)-bch->a_log_tab[poly->c[0]]+ |
593 | bch->a_log_tab[poly->c[1]]); | 593 | bch->a_log_tab[poly->c[1]]); |
594 | return n; | 594 | return n; |
595 | } | 595 | } |
596 | 596 | ||
597 | /* | 597 | /* |
598 | * compute roots of a degree 2 polynomial over GF(2^m) | 598 | * compute roots of a degree 2 polynomial over GF(2^m) |
599 | */ | 599 | */ |
600 | static int find_poly_deg2_roots(struct bch_control *bch, struct gf_poly *poly, | 600 | static int find_poly_deg2_roots(struct bch_control *bch, struct gf_poly *poly, |
601 | unsigned int *roots) | 601 | unsigned int *roots) |
602 | { | 602 | { |
603 | int n = 0, i, l0, l1, l2; | 603 | int n = 0, i, l0, l1, l2; |
604 | unsigned int u, v, r; | 604 | unsigned int u, v, r; |
605 | 605 | ||
606 | if (poly->c[0] && poly->c[1]) { | 606 | if (poly->c[0] && poly->c[1]) { |
607 | 607 | ||
608 | l0 = bch->a_log_tab[poly->c[0]]; | 608 | l0 = bch->a_log_tab[poly->c[0]]; |
609 | l1 = bch->a_log_tab[poly->c[1]]; | 609 | l1 = bch->a_log_tab[poly->c[1]]; |
610 | l2 = bch->a_log_tab[poly->c[2]]; | 610 | l2 = bch->a_log_tab[poly->c[2]]; |
611 | 611 | ||
612 | /* using z=a/bX, transform aX^2+bX+c into z^2+z+u (u=ac/b^2) */ | 612 | /* using z=a/bX, transform aX^2+bX+c into z^2+z+u (u=ac/b^2) */ |
613 | u = a_pow(bch, l0+l2+2*(GF_N(bch)-l1)); | 613 | u = a_pow(bch, l0+l2+2*(GF_N(bch)-l1)); |
614 | /* | 614 | /* |
615 | * let u = sum(li.a^i) i=0..m-1; then compute r = sum(li.xi): | 615 | * let u = sum(li.a^i) i=0..m-1; then compute r = sum(li.xi): |
616 | * r^2+r = sum(li.(xi^2+xi)) = sum(li.(a^i+Tr(a^i).a^k)) = | 616 | * r^2+r = sum(li.(xi^2+xi)) = sum(li.(a^i+Tr(a^i).a^k)) = |
617 | * u + sum(li.Tr(a^i).a^k) = u+a^k.Tr(sum(li.a^i)) = u+a^k.Tr(u) | 617 | * u + sum(li.Tr(a^i).a^k) = u+a^k.Tr(sum(li.a^i)) = u+a^k.Tr(u) |
618 | * i.e. r and r+1 are roots iff Tr(u)=0 | 618 | * i.e. r and r+1 are roots iff Tr(u)=0 |
619 | */ | 619 | */ |
620 | r = 0; | 620 | r = 0; |
621 | v = u; | 621 | v = u; |
622 | while (v) { | 622 | while (v) { |
623 | i = deg(v); | 623 | i = deg(v); |
624 | r ^= bch->xi_tab[i]; | 624 | r ^= bch->xi_tab[i]; |
625 | v ^= (1 << i); | 625 | v ^= (1 << i); |
626 | } | 626 | } |
627 | /* verify root */ | 627 | /* verify root */ |
628 | if ((gf_sqr(bch, r)^r) == u) { | 628 | if ((gf_sqr(bch, r)^r) == u) { |
629 | /* reverse z=a/bX transformation and compute log(1/r) */ | 629 | /* reverse z=a/bX transformation and compute log(1/r) */ |
630 | roots[n++] = modulo(bch, 2*GF_N(bch)-l1- | 630 | roots[n++] = modulo(bch, 2*GF_N(bch)-l1- |
631 | bch->a_log_tab[r]+l2); | 631 | bch->a_log_tab[r]+l2); |
632 | roots[n++] = modulo(bch, 2*GF_N(bch)-l1- | 632 | roots[n++] = modulo(bch, 2*GF_N(bch)-l1- |
633 | bch->a_log_tab[r^1]+l2); | 633 | bch->a_log_tab[r^1]+l2); |
634 | } | 634 | } |
635 | } | 635 | } |
636 | return n; | 636 | return n; |
637 | } | 637 | } |
638 | 638 | ||
639 | /* | 639 | /* |
640 | * compute roots of a degree 3 polynomial over GF(2^m) | 640 | * compute roots of a degree 3 polynomial over GF(2^m) |
641 | */ | 641 | */ |
642 | static int find_poly_deg3_roots(struct bch_control *bch, struct gf_poly *poly, | 642 | static int find_poly_deg3_roots(struct bch_control *bch, struct gf_poly *poly, |
643 | unsigned int *roots) | 643 | unsigned int *roots) |
644 | { | 644 | { |
645 | int i, n = 0; | 645 | int i, n = 0; |
646 | unsigned int a, b, c, a2, b2, c2, e3, tmp[4]; | 646 | unsigned int a, b, c, a2, b2, c2, e3, tmp[4]; |
647 | 647 | ||
648 | if (poly->c[0]) { | 648 | if (poly->c[0]) { |
649 | /* transform polynomial into monic X^3 + a2X^2 + b2X + c2 */ | 649 | /* transform polynomial into monic X^3 + a2X^2 + b2X + c2 */ |
650 | e3 = poly->c[3]; | 650 | e3 = poly->c[3]; |
651 | c2 = gf_div(bch, poly->c[0], e3); | 651 | c2 = gf_div(bch, poly->c[0], e3); |
652 | b2 = gf_div(bch, poly->c[1], e3); | 652 | b2 = gf_div(bch, poly->c[1], e3); |
653 | a2 = gf_div(bch, poly->c[2], e3); | 653 | a2 = gf_div(bch, poly->c[2], e3); |
654 | 654 | ||
655 | /* (X+a2)(X^3+a2X^2+b2X+c2) = X^4+aX^2+bX+c (affine) */ | 655 | /* (X+a2)(X^3+a2X^2+b2X+c2) = X^4+aX^2+bX+c (affine) */ |
656 | c = gf_mul(bch, a2, c2); /* c = a2c2 */ | 656 | c = gf_mul(bch, a2, c2); /* c = a2c2 */ |
657 | b = gf_mul(bch, a2, b2)^c2; /* b = a2b2 + c2 */ | 657 | b = gf_mul(bch, a2, b2)^c2; /* b = a2b2 + c2 */ |
658 | a = gf_sqr(bch, a2)^b2; /* a = a2^2 + b2 */ | 658 | a = gf_sqr(bch, a2)^b2; /* a = a2^2 + b2 */ |
659 | 659 | ||
660 | /* find the 4 roots of this affine polynomial */ | 660 | /* find the 4 roots of this affine polynomial */ |
661 | if (find_affine4_roots(bch, a, b, c, tmp) == 4) { | 661 | if (find_affine4_roots(bch, a, b, c, tmp) == 4) { |
662 | /* remove a2 from final list of roots */ | 662 | /* remove a2 from final list of roots */ |
663 | for (i = 0; i < 4; i++) { | 663 | for (i = 0; i < 4; i++) { |
664 | if (tmp[i] != a2) | 664 | if (tmp[i] != a2) |
665 | roots[n++] = a_ilog(bch, tmp[i]); | 665 | roots[n++] = a_ilog(bch, tmp[i]); |
666 | } | 666 | } |
667 | } | 667 | } |
668 | } | 668 | } |
669 | return n; | 669 | return n; |
670 | } | 670 | } |
671 | 671 | ||
672 | /* | 672 | /* |
673 | * compute roots of a degree 4 polynomial over GF(2^m) | 673 | * compute roots of a degree 4 polynomial over GF(2^m) |
674 | */ | 674 | */ |
675 | static int find_poly_deg4_roots(struct bch_control *bch, struct gf_poly *poly, | 675 | static int find_poly_deg4_roots(struct bch_control *bch, struct gf_poly *poly, |
676 | unsigned int *roots) | 676 | unsigned int *roots) |
677 | { | 677 | { |
678 | int i, l, n = 0; | 678 | int i, l, n = 0; |
679 | unsigned int a, b, c, d, e = 0, f, a2, b2, c2, e4; | 679 | unsigned int a, b, c, d, e = 0, f, a2, b2, c2, e4; |
680 | 680 | ||
681 | if (poly->c[0] == 0) | 681 | if (poly->c[0] == 0) |
682 | return 0; | 682 | return 0; |
683 | 683 | ||
684 | /* transform polynomial into monic X^4 + aX^3 + bX^2 + cX + d */ | 684 | /* transform polynomial into monic X^4 + aX^3 + bX^2 + cX + d */ |
685 | e4 = poly->c[4]; | 685 | e4 = poly->c[4]; |
686 | d = gf_div(bch, poly->c[0], e4); | 686 | d = gf_div(bch, poly->c[0], e4); |
687 | c = gf_div(bch, poly->c[1], e4); | 687 | c = gf_div(bch, poly->c[1], e4); |
688 | b = gf_div(bch, poly->c[2], e4); | 688 | b = gf_div(bch, poly->c[2], e4); |
689 | a = gf_div(bch, poly->c[3], e4); | 689 | a = gf_div(bch, poly->c[3], e4); |
690 | 690 | ||
691 | /* use Y=1/X transformation to get an affine polynomial */ | 691 | /* use Y=1/X transformation to get an affine polynomial */ |
692 | if (a) { | 692 | if (a) { |
693 | /* first, eliminate cX by using z=X+e with ae^2+c=0 */ | 693 | /* first, eliminate cX by using z=X+e with ae^2+c=0 */ |
694 | if (c) { | 694 | if (c) { |
695 | /* compute e such that e^2 = c/a */ | 695 | /* compute e such that e^2 = c/a */ |
696 | f = gf_div(bch, c, a); | 696 | f = gf_div(bch, c, a); |
697 | l = a_log(bch, f); | 697 | l = a_log(bch, f); |
698 | l += (l & 1) ? GF_N(bch) : 0; | 698 | l += (l & 1) ? GF_N(bch) : 0; |
699 | e = a_pow(bch, l/2); | 699 | e = a_pow(bch, l/2); |
700 | /* | 700 | /* |
701 | * use transformation z=X+e: | 701 | * use transformation z=X+e: |
702 | * z^4+e^4 + a(z^3+ez^2+e^2z+e^3) + b(z^2+e^2) +cz+ce+d | 702 | * z^4+e^4 + a(z^3+ez^2+e^2z+e^3) + b(z^2+e^2) +cz+ce+d |
703 | * z^4 + az^3 + (ae+b)z^2 + (ae^2+c)z+e^4+be^2+ae^3+ce+d | 703 | * z^4 + az^3 + (ae+b)z^2 + (ae^2+c)z+e^4+be^2+ae^3+ce+d |
704 | * z^4 + az^3 + (ae+b)z^2 + e^4+be^2+d | 704 | * z^4 + az^3 + (ae+b)z^2 + e^4+be^2+d |
705 | * z^4 + az^3 + b'z^2 + d' | 705 | * z^4 + az^3 + b'z^2 + d' |
706 | */ | 706 | */ |
707 | d = a_pow(bch, 2*l)^gf_mul(bch, b, f)^d; | 707 | d = a_pow(bch, 2*l)^gf_mul(bch, b, f)^d; |
708 | b = gf_mul(bch, a, e)^b; | 708 | b = gf_mul(bch, a, e)^b; |
709 | } | 709 | } |
710 | /* now, use Y=1/X to get Y^4 + b/dY^2 + a/dY + 1/d */ | 710 | /* now, use Y=1/X to get Y^4 + b/dY^2 + a/dY + 1/d */ |
711 | if (d == 0) | 711 | if (d == 0) |
712 | /* assume all roots have multiplicity 1 */ | 712 | /* assume all roots have multiplicity 1 */ |
713 | return 0; | 713 | return 0; |
714 | 714 | ||
715 | c2 = gf_inv(bch, d); | 715 | c2 = gf_inv(bch, d); |
716 | b2 = gf_div(bch, a, d); | 716 | b2 = gf_div(bch, a, d); |
717 | a2 = gf_div(bch, b, d); | 717 | a2 = gf_div(bch, b, d); |
718 | } else { | 718 | } else { |
719 | /* polynomial is already affine */ | 719 | /* polynomial is already affine */ |
720 | c2 = d; | 720 | c2 = d; |
721 | b2 = c; | 721 | b2 = c; |
722 | a2 = b; | 722 | a2 = b; |
723 | } | 723 | } |
724 | /* find the 4 roots of this affine polynomial */ | 724 | /* find the 4 roots of this affine polynomial */ |
725 | if (find_affine4_roots(bch, a2, b2, c2, roots) == 4) { | 725 | if (find_affine4_roots(bch, a2, b2, c2, roots) == 4) { |
726 | for (i = 0; i < 4; i++) { | 726 | for (i = 0; i < 4; i++) { |
727 | /* post-process roots (reverse transformations) */ | 727 | /* post-process roots (reverse transformations) */ |
728 | f = a ? gf_inv(bch, roots[i]) : roots[i]; | 728 | f = a ? gf_inv(bch, roots[i]) : roots[i]; |
729 | roots[i] = a_ilog(bch, f^e); | 729 | roots[i] = a_ilog(bch, f^e); |
730 | } | 730 | } |
731 | n = 4; | 731 | n = 4; |
732 | } | 732 | } |
733 | return n; | 733 | return n; |
734 | } | 734 | } |
735 | 735 | ||
736 | /* | 736 | /* |
737 | * build monic, log-based representation of a polynomial | 737 | * build monic, log-based representation of a polynomial |
738 | */ | 738 | */ |
739 | static void gf_poly_logrep(struct bch_control *bch, | 739 | static void gf_poly_logrep(struct bch_control *bch, |
740 | const struct gf_poly *a, int *rep) | 740 | const struct gf_poly *a, int *rep) |
741 | { | 741 | { |
742 | int i, d = a->deg, l = GF_N(bch)-a_log(bch, a->c[a->deg]); | 742 | int i, d = a->deg, l = GF_N(bch)-a_log(bch, a->c[a->deg]); |
743 | 743 | ||
744 | /* represent 0 values with -1; warning, rep[d] is not set to 1 */ | 744 | /* represent 0 values with -1; warning, rep[d] is not set to 1 */ |
745 | for (i = 0; i < d; i++) | 745 | for (i = 0; i < d; i++) |
746 | rep[i] = a->c[i] ? mod_s(bch, a_log(bch, a->c[i])+l) : -1; | 746 | rep[i] = a->c[i] ? mod_s(bch, a_log(bch, a->c[i])+l) : -1; |
747 | } | 747 | } |
748 | 748 | ||
749 | /* | 749 | /* |
750 | * compute polynomial Euclidean division remainder in GF(2^m)[X] | 750 | * compute polynomial Euclidean division remainder in GF(2^m)[X] |
751 | */ | 751 | */ |
752 | static void gf_poly_mod(struct bch_control *bch, struct gf_poly *a, | 752 | static void gf_poly_mod(struct bch_control *bch, struct gf_poly *a, |
753 | const struct gf_poly *b, int *rep) | 753 | const struct gf_poly *b, int *rep) |
754 | { | 754 | { |
755 | int la, p, m; | 755 | int la, p, m; |
756 | unsigned int i, j, *c = a->c; | 756 | unsigned int i, j, *c = a->c; |
757 | const unsigned int d = b->deg; | 757 | const unsigned int d = b->deg; |
758 | 758 | ||
759 | if (a->deg < d) | 759 | if (a->deg < d) |
760 | return; | 760 | return; |
761 | 761 | ||
762 | /* reuse or compute log representation of denominator */ | 762 | /* reuse or compute log representation of denominator */ |
763 | if (!rep) { | 763 | if (!rep) { |
764 | rep = bch->cache; | 764 | rep = bch->cache; |
765 | gf_poly_logrep(bch, b, rep); | 765 | gf_poly_logrep(bch, b, rep); |
766 | } | 766 | } |
767 | 767 | ||
768 | for (j = a->deg; j >= d; j--) { | 768 | for (j = a->deg; j >= d; j--) { |
769 | if (c[j]) { | 769 | if (c[j]) { |
770 | la = a_log(bch, c[j]); | 770 | la = a_log(bch, c[j]); |
771 | p = j-d; | 771 | p = j-d; |
772 | for (i = 0; i < d; i++, p++) { | 772 | for (i = 0; i < d; i++, p++) { |
773 | m = rep[i]; | 773 | m = rep[i]; |
774 | if (m >= 0) | 774 | if (m >= 0) |
775 | c[p] ^= bch->a_pow_tab[mod_s(bch, | 775 | c[p] ^= bch->a_pow_tab[mod_s(bch, |
776 | m+la)]; | 776 | m+la)]; |
777 | } | 777 | } |
778 | } | 778 | } |
779 | } | 779 | } |
780 | a->deg = d-1; | 780 | a->deg = d-1; |
781 | while (!c[a->deg] && a->deg) | 781 | while (!c[a->deg] && a->deg) |
782 | a->deg--; | 782 | a->deg--; |
783 | } | 783 | } |
784 | 784 | ||
785 | /* | 785 | /* |
786 | * compute polynomial Euclidean division quotient in GF(2^m)[X] | 786 | * compute polynomial Euclidean division quotient in GF(2^m)[X] |
787 | */ | 787 | */ |
788 | static void gf_poly_div(struct bch_control *bch, struct gf_poly *a, | 788 | static void gf_poly_div(struct bch_control *bch, struct gf_poly *a, |
789 | const struct gf_poly *b, struct gf_poly *q) | 789 | const struct gf_poly *b, struct gf_poly *q) |
790 | { | 790 | { |
791 | if (a->deg >= b->deg) { | 791 | if (a->deg >= b->deg) { |
792 | q->deg = a->deg-b->deg; | 792 | q->deg = a->deg-b->deg; |
793 | /* compute a mod b (modifies a) */ | 793 | /* compute a mod b (modifies a) */ |
794 | gf_poly_mod(bch, a, b, NULL); | 794 | gf_poly_mod(bch, a, b, NULL); |
795 | /* quotient is stored in upper part of polynomial a */ | 795 | /* quotient is stored in upper part of polynomial a */ |
796 | memcpy(q->c, &a->c[b->deg], (1+q->deg)*sizeof(unsigned int)); | 796 | memcpy(q->c, &a->c[b->deg], (1+q->deg)*sizeof(unsigned int)); |
797 | } else { | 797 | } else { |
798 | q->deg = 0; | 798 | q->deg = 0; |
799 | q->c[0] = 0; | 799 | q->c[0] = 0; |
800 | } | 800 | } |
801 | } | 801 | } |
802 | 802 | ||
803 | /* | 803 | /* |
804 | * compute polynomial GCD (Greatest Common Divisor) in GF(2^m)[X] | 804 | * compute polynomial GCD (Greatest Common Divisor) in GF(2^m)[X] |
805 | */ | 805 | */ |
806 | static struct gf_poly *gf_poly_gcd(struct bch_control *bch, struct gf_poly *a, | 806 | static struct gf_poly *gf_poly_gcd(struct bch_control *bch, struct gf_poly *a, |
807 | struct gf_poly *b) | 807 | struct gf_poly *b) |
808 | { | 808 | { |
809 | struct gf_poly *tmp; | 809 | struct gf_poly *tmp; |
810 | 810 | ||
811 | dbg("gcd(%s,%s)=", gf_poly_str(a), gf_poly_str(b)); | 811 | dbg("gcd(%s,%s)=", gf_poly_str(a), gf_poly_str(b)); |
812 | 812 | ||
813 | if (a->deg < b->deg) { | 813 | if (a->deg < b->deg) { |
814 | tmp = b; | 814 | tmp = b; |
815 | b = a; | 815 | b = a; |
816 | a = tmp; | 816 | a = tmp; |
817 | } | 817 | } |
818 | 818 | ||
819 | while (b->deg > 0) { | 819 | while (b->deg > 0) { |
820 | gf_poly_mod(bch, a, b, NULL); | 820 | gf_poly_mod(bch, a, b, NULL); |
821 | tmp = b; | 821 | tmp = b; |
822 | b = a; | 822 | b = a; |
823 | a = tmp; | 823 | a = tmp; |
824 | } | 824 | } |
825 | 825 | ||
826 | dbg("%s\n", gf_poly_str(a)); | 826 | dbg("%s\n", gf_poly_str(a)); |
827 | 827 | ||
828 | return a; | 828 | return a; |
829 | } | 829 | } |
830 | 830 | ||
831 | /* | 831 | /* |
832 | * Given a polynomial f and an integer k, compute Tr(a^kX) mod f | 832 | * Given a polynomial f and an integer k, compute Tr(a^kX) mod f |
833 | * This is used in Berlekamp Trace algorithm for splitting polynomials | 833 | * This is used in Berlekamp Trace algorithm for splitting polynomials |
834 | */ | 834 | */ |
835 | static void compute_trace_bk_mod(struct bch_control *bch, int k, | 835 | static void compute_trace_bk_mod(struct bch_control *bch, int k, |
836 | const struct gf_poly *f, struct gf_poly *z, | 836 | const struct gf_poly *f, struct gf_poly *z, |
837 | struct gf_poly *out) | 837 | struct gf_poly *out) |
838 | { | 838 | { |
839 | const int m = GF_M(bch); | 839 | const int m = GF_M(bch); |
840 | int i, j; | 840 | int i, j; |
841 | 841 | ||
842 | /* z contains z^2j mod f */ | 842 | /* z contains z^2j mod f */ |
843 | z->deg = 1; | 843 | z->deg = 1; |
844 | z->c[0] = 0; | 844 | z->c[0] = 0; |
845 | z->c[1] = bch->a_pow_tab[k]; | 845 | z->c[1] = bch->a_pow_tab[k]; |
846 | 846 | ||
847 | out->deg = 0; | 847 | out->deg = 0; |
848 | memset(out, 0, GF_POLY_SZ(f->deg)); | 848 | memset(out, 0, GF_POLY_SZ(f->deg)); |
849 | 849 | ||
850 | /* compute f log representation only once */ | 850 | /* compute f log representation only once */ |
851 | gf_poly_logrep(bch, f, bch->cache); | 851 | gf_poly_logrep(bch, f, bch->cache); |
852 | 852 | ||
853 | for (i = 0; i < m; i++) { | 853 | for (i = 0; i < m; i++) { |
854 | /* add a^(k*2^i)(z^(2^i) mod f) and compute (z^(2^i) mod f)^2 */ | 854 | /* add a^(k*2^i)(z^(2^i) mod f) and compute (z^(2^i) mod f)^2 */ |
855 | for (j = z->deg; j >= 0; j--) { | 855 | for (j = z->deg; j >= 0; j--) { |
856 | out->c[j] ^= z->c[j]; | 856 | out->c[j] ^= z->c[j]; |
857 | z->c[2*j] = gf_sqr(bch, z->c[j]); | 857 | z->c[2*j] = gf_sqr(bch, z->c[j]); |
858 | z->c[2*j+1] = 0; | 858 | z->c[2*j+1] = 0; |
859 | } | 859 | } |
860 | if (z->deg > out->deg) | 860 | if (z->deg > out->deg) |
861 | out->deg = z->deg; | 861 | out->deg = z->deg; |
862 | 862 | ||
863 | if (i < m-1) { | 863 | if (i < m-1) { |
864 | z->deg *= 2; | 864 | z->deg *= 2; |
865 | /* z^(2(i+1)) mod f = (z^(2^i) mod f)^2 mod f */ | 865 | /* z^(2(i+1)) mod f = (z^(2^i) mod f)^2 mod f */ |
866 | gf_poly_mod(bch, z, f, bch->cache); | 866 | gf_poly_mod(bch, z, f, bch->cache); |
867 | } | 867 | } |
868 | } | 868 | } |
869 | while (!out->c[out->deg] && out->deg) | 869 | while (!out->c[out->deg] && out->deg) |
870 | out->deg--; | 870 | out->deg--; |
871 | 871 | ||
872 | dbg("Tr(a^%d.X) mod f = %s\n", k, gf_poly_str(out)); | 872 | dbg("Tr(a^%d.X) mod f = %s\n", k, gf_poly_str(out)); |
873 | } | 873 | } |
874 | 874 | ||
875 | /* | 875 | /* |
876 | * factor a polynomial using Berlekamp Trace algorithm (BTA) | 876 | * factor a polynomial using Berlekamp Trace algorithm (BTA) |
877 | */ | 877 | */ |
878 | static void factor_polynomial(struct bch_control *bch, int k, struct gf_poly *f, | 878 | static void factor_polynomial(struct bch_control *bch, int k, struct gf_poly *f, |
879 | struct gf_poly **g, struct gf_poly **h) | 879 | struct gf_poly **g, struct gf_poly **h) |
880 | { | 880 | { |
881 | struct gf_poly *f2 = bch->poly_2t[0]; | 881 | struct gf_poly *f2 = bch->poly_2t[0]; |
882 | struct gf_poly *q = bch->poly_2t[1]; | 882 | struct gf_poly *q = bch->poly_2t[1]; |
883 | struct gf_poly *tk = bch->poly_2t[2]; | 883 | struct gf_poly *tk = bch->poly_2t[2]; |
884 | struct gf_poly *z = bch->poly_2t[3]; | 884 | struct gf_poly *z = bch->poly_2t[3]; |
885 | struct gf_poly *gcd; | 885 | struct gf_poly *gcd; |
886 | 886 | ||
887 | dbg("factoring %s...\n", gf_poly_str(f)); | 887 | dbg("factoring %s...\n", gf_poly_str(f)); |
888 | 888 | ||
889 | *g = f; | 889 | *g = f; |
890 | *h = NULL; | 890 | *h = NULL; |
891 | 891 | ||
892 | /* tk = Tr(a^k.X) mod f */ | 892 | /* tk = Tr(a^k.X) mod f */ |
893 | compute_trace_bk_mod(bch, k, f, z, tk); | 893 | compute_trace_bk_mod(bch, k, f, z, tk); |
894 | 894 | ||
895 | if (tk->deg > 0) { | 895 | if (tk->deg > 0) { |
896 | /* compute g = gcd(f, tk) (destructive operation) */ | 896 | /* compute g = gcd(f, tk) (destructive operation) */ |
897 | gf_poly_copy(f2, f); | 897 | gf_poly_copy(f2, f); |
898 | gcd = gf_poly_gcd(bch, f2, tk); | 898 | gcd = gf_poly_gcd(bch, f2, tk); |
899 | if (gcd->deg < f->deg) { | 899 | if (gcd->deg < f->deg) { |
900 | /* compute h=f/gcd(f,tk); this will modify f and q */ | 900 | /* compute h=f/gcd(f,tk); this will modify f and q */ |
901 | gf_poly_div(bch, f, gcd, q); | 901 | gf_poly_div(bch, f, gcd, q); |
902 | /* store g and h in-place (clobbering f) */ | 902 | /* store g and h in-place (clobbering f) */ |
903 | *h = &((struct gf_poly_deg1 *)f)[gcd->deg].poly; | 903 | *h = &((struct gf_poly_deg1 *)f)[gcd->deg].poly; |
904 | gf_poly_copy(*g, gcd); | 904 | gf_poly_copy(*g, gcd); |
905 | gf_poly_copy(*h, q); | 905 | gf_poly_copy(*h, q); |
906 | } | 906 | } |
907 | } | 907 | } |
908 | } | 908 | } |
909 | 909 | ||
910 | /* | 910 | /* |
911 | * find roots of a polynomial, using BTZ algorithm; see the beginning of this | 911 | * find roots of a polynomial, using BTZ algorithm; see the beginning of this |
912 | * file for details | 912 | * file for details |
913 | */ | 913 | */ |
914 | static int find_poly_roots(struct bch_control *bch, unsigned int k, | 914 | static int find_poly_roots(struct bch_control *bch, unsigned int k, |
915 | struct gf_poly *poly, unsigned int *roots) | 915 | struct gf_poly *poly, unsigned int *roots) |
916 | { | 916 | { |
917 | int cnt; | 917 | int cnt; |
918 | struct gf_poly *f1, *f2; | 918 | struct gf_poly *f1, *f2; |
919 | 919 | ||
920 | switch (poly->deg) { | 920 | switch (poly->deg) { |
921 | /* handle low degree polynomials with ad hoc techniques */ | 921 | /* handle low degree polynomials with ad hoc techniques */ |
922 | case 1: | 922 | case 1: |
923 | cnt = find_poly_deg1_roots(bch, poly, roots); | 923 | cnt = find_poly_deg1_roots(bch, poly, roots); |
924 | break; | 924 | break; |
925 | case 2: | 925 | case 2: |
926 | cnt = find_poly_deg2_roots(bch, poly, roots); | 926 | cnt = find_poly_deg2_roots(bch, poly, roots); |
927 | break; | 927 | break; |
928 | case 3: | 928 | case 3: |
929 | cnt = find_poly_deg3_roots(bch, poly, roots); | 929 | cnt = find_poly_deg3_roots(bch, poly, roots); |
930 | break; | 930 | break; |
931 | case 4: | 931 | case 4: |
932 | cnt = find_poly_deg4_roots(bch, poly, roots); | 932 | cnt = find_poly_deg4_roots(bch, poly, roots); |
933 | break; | 933 | break; |
934 | default: | 934 | default: |
935 | /* factor polynomial using Berlekamp Trace Algorithm (BTA) */ | 935 | /* factor polynomial using Berlekamp Trace Algorithm (BTA) */ |
936 | cnt = 0; | 936 | cnt = 0; |
937 | if (poly->deg && (k <= GF_M(bch))) { | 937 | if (poly->deg && (k <= GF_M(bch))) { |
938 | factor_polynomial(bch, k, poly, &f1, &f2); | 938 | factor_polynomial(bch, k, poly, &f1, &f2); |
939 | if (f1) | 939 | if (f1) |
940 | cnt += find_poly_roots(bch, k+1, f1, roots); | 940 | cnt += find_poly_roots(bch, k+1, f1, roots); |
941 | if (f2) | 941 | if (f2) |
942 | cnt += find_poly_roots(bch, k+1, f2, roots+cnt); | 942 | cnt += find_poly_roots(bch, k+1, f2, roots+cnt); |
943 | } | 943 | } |
944 | break; | 944 | break; |
945 | } | 945 | } |
946 | return cnt; | 946 | return cnt; |
947 | } | 947 | } |
948 | 948 | ||
949 | #if defined(USE_CHIEN_SEARCH) | 949 | #if defined(USE_CHIEN_SEARCH) |
950 | /* | 950 | /* |
951 | * exhaustive root search (Chien) implementation - not used, included only for | 951 | * exhaustive root search (Chien) implementation - not used, included only for |
952 | * reference/comparison tests | 952 | * reference/comparison tests |
953 | */ | 953 | */ |
954 | static int chien_search(struct bch_control *bch, unsigned int len, | 954 | static int chien_search(struct bch_control *bch, unsigned int len, |
955 | struct gf_poly *p, unsigned int *roots) | 955 | struct gf_poly *p, unsigned int *roots) |
956 | { | 956 | { |
957 | int m; | 957 | int m; |
958 | unsigned int i, j, syn, syn0, count = 0; | 958 | unsigned int i, j, syn, syn0, count = 0; |
959 | const unsigned int k = 8*len+bch->ecc_bits; | 959 | const unsigned int k = 8*len+bch->ecc_bits; |
960 | 960 | ||
961 | /* use a log-based representation of polynomial */ | 961 | /* use a log-based representation of polynomial */ |
962 | gf_poly_logrep(bch, p, bch->cache); | 962 | gf_poly_logrep(bch, p, bch->cache); |
963 | bch->cache[p->deg] = 0; | 963 | bch->cache[p->deg] = 0; |
964 | syn0 = gf_div(bch, p->c[0], p->c[p->deg]); | 964 | syn0 = gf_div(bch, p->c[0], p->c[p->deg]); |
965 | 965 | ||
966 | for (i = GF_N(bch)-k+1; i <= GF_N(bch); i++) { | 966 | for (i = GF_N(bch)-k+1; i <= GF_N(bch); i++) { |
967 | /* compute elp(a^i) */ | 967 | /* compute elp(a^i) */ |
968 | for (j = 1, syn = syn0; j <= p->deg; j++) { | 968 | for (j = 1, syn = syn0; j <= p->deg; j++) { |
969 | m = bch->cache[j]; | 969 | m = bch->cache[j]; |
970 | if (m >= 0) | 970 | if (m >= 0) |
971 | syn ^= a_pow(bch, m+j*i); | 971 | syn ^= a_pow(bch, m+j*i); |
972 | } | 972 | } |
973 | if (syn == 0) { | 973 | if (syn == 0) { |
974 | roots[count++] = GF_N(bch)-i; | 974 | roots[count++] = GF_N(bch)-i; |
975 | if (count == p->deg) | 975 | if (count == p->deg) |
976 | break; | 976 | break; |
977 | } | 977 | } |
978 | } | 978 | } |
979 | return (count == p->deg) ? count : 0; | 979 | return (count == p->deg) ? count : 0; |
980 | } | 980 | } |
981 | #define find_poly_roots(_p, _k, _elp, _loc) chien_search(_p, len, _elp, _loc) | 981 | #define find_poly_roots(_p, _k, _elp, _loc) chien_search(_p, len, _elp, _loc) |
982 | #endif /* USE_CHIEN_SEARCH */ | 982 | #endif /* USE_CHIEN_SEARCH */ |
983 | 983 | ||
984 | /** | 984 | /** |
985 | * decode_bch - decode received codeword and find bit error locations | 985 | * decode_bch - decode received codeword and find bit error locations |
986 | * @bch: BCH control structure | 986 | * @bch: BCH control structure |
987 | * @data: received data, ignored if @calc_ecc is provided | 987 | * @data: received data, ignored if @calc_ecc is provided |
988 | * @len: data length in bytes, must always be provided | 988 | * @len: data length in bytes, must always be provided |
989 | * @recv_ecc: received ecc, if NULL then assume it was XORed in @calc_ecc | 989 | * @recv_ecc: received ecc, if NULL then assume it was XORed in @calc_ecc |
990 | * @calc_ecc: calculated ecc, if NULL then calc_ecc is computed from @data | 990 | * @calc_ecc: calculated ecc, if NULL then calc_ecc is computed from @data |
991 | * @syn: hw computed syndrome data (if NULL, syndrome is calculated) | 991 | * @syn: hw computed syndrome data (if NULL, syndrome is calculated) |
992 | * @errloc: output array of error locations | 992 | * @errloc: output array of error locations |
993 | * | 993 | * |
994 | * Returns: | 994 | * Returns: |
995 | * The number of errors found, or -EBADMSG if decoding failed, or -EINVAL if | 995 | * The number of errors found, or -EBADMSG if decoding failed, or -EINVAL if |
996 | * invalid parameters were provided | 996 | * invalid parameters were provided |
997 | * | 997 | * |
998 | * Depending on the available hw BCH support and the need to compute @calc_ecc | 998 | * Depending on the available hw BCH support and the need to compute @calc_ecc |
999 | * separately (using encode_bch()), this function should be called with one of | 999 | * separately (using encode_bch()), this function should be called with one of |
1000 | * the following parameter configurations - | 1000 | * the following parameter configurations - |
1001 | * | 1001 | * |
1002 | * by providing @data and @recv_ecc only: | 1002 | * by providing @data and @recv_ecc only: |
1003 | * decode_bch(@bch, @data, @len, @recv_ecc, NULL, NULL, @errloc) | 1003 | * decode_bch(@bch, @data, @len, @recv_ecc, NULL, NULL, @errloc) |
1004 | * | 1004 | * |
1005 | * by providing @recv_ecc and @calc_ecc: | 1005 | * by providing @recv_ecc and @calc_ecc: |
1006 | * decode_bch(@bch, NULL, @len, @recv_ecc, @calc_ecc, NULL, @errloc) | 1006 | * decode_bch(@bch, NULL, @len, @recv_ecc, @calc_ecc, NULL, @errloc) |
1007 | * | 1007 | * |
1008 | * by providing ecc = recv_ecc XOR calc_ecc: | 1008 | * by providing ecc = recv_ecc XOR calc_ecc: |
1009 | * decode_bch(@bch, NULL, @len, NULL, ecc, NULL, @errloc) | 1009 | * decode_bch(@bch, NULL, @len, NULL, ecc, NULL, @errloc) |
1010 | * | 1010 | * |
1011 | * by providing syndrome results @syn: | 1011 | * by providing syndrome results @syn: |
1012 | * decode_bch(@bch, NULL, @len, NULL, NULL, @syn, @errloc) | 1012 | * decode_bch(@bch, NULL, @len, NULL, NULL, @syn, @errloc) |
1013 | * | 1013 | * |
1014 | * Once decode_bch() has successfully returned with a positive value, error | 1014 | * Once decode_bch() has successfully returned with a positive value, error |
1015 | * locations returned in array @errloc should be interpreted as follows - | 1015 | * locations returned in array @errloc should be interpreted as follows - |
1016 | * | 1016 | * |
1017 | * if (errloc[n] >= 8*len), then n-th error is located in ecc (no need for | 1017 | * if (errloc[n] >= 8*len), then n-th error is located in ecc (no need for |
1018 | * data correction) | 1018 | * data correction) |
1019 | * | 1019 | * |
1020 | * if (errloc[n] < 8*len), then n-th error is located in data and can be | 1020 | * if (errloc[n] < 8*len), then n-th error is located in data and can be |
1021 | * corrected with statement data[errloc[n]/8] ^= 1 << (errloc[n] % 8); | 1021 | * corrected with statement data[errloc[n]/8] ^= 1 << (errloc[n] % 8); |
1022 | * | 1022 | * |
1023 | * Note that this function does not perform any data correction by itself, it | 1023 | * Note that this function does not perform any data correction by itself, it |
1024 | * merely indicates error locations. | 1024 | * merely indicates error locations. |
1025 | */ | 1025 | */ |
1026 | int decode_bch(struct bch_control *bch, const uint8_t *data, unsigned int len, | 1026 | int decode_bch(struct bch_control *bch, const uint8_t *data, unsigned int len, |
1027 | const uint8_t *recv_ecc, const uint8_t *calc_ecc, | 1027 | const uint8_t *recv_ecc, const uint8_t *calc_ecc, |
1028 | const unsigned int *syn, unsigned int *errloc) | 1028 | const unsigned int *syn, unsigned int *errloc) |
1029 | { | 1029 | { |
1030 | const unsigned int ecc_words = BCH_ECC_WORDS(bch); | 1030 | const unsigned int ecc_words = BCH_ECC_WORDS(bch); |
1031 | unsigned int nbits; | 1031 | unsigned int nbits; |
1032 | int i, err, nroots; | 1032 | int i, err, nroots; |
1033 | uint32_t sum; | 1033 | uint32_t sum; |
1034 | 1034 | ||
1035 | /* sanity check: make sure data length can be handled */ | 1035 | /* sanity check: make sure data length can be handled */ |
1036 | if (8*len > (bch->n-bch->ecc_bits)) | 1036 | if (8*len > (bch->n-bch->ecc_bits)) |
1037 | return -EINVAL; | 1037 | return -EINVAL; |
1038 | 1038 | ||
1039 | /* if caller does not provide syndromes, compute them */ | 1039 | /* if caller does not provide syndromes, compute them */ |
1040 | if (!syn) { | 1040 | if (!syn) { |
1041 | if (!calc_ecc) { | 1041 | if (!calc_ecc) { |
1042 | /* compute received data ecc into an internal buffer */ | 1042 | /* compute received data ecc into an internal buffer */ |
1043 | if (!data || !recv_ecc) | 1043 | if (!data || !recv_ecc) |
1044 | return -EINVAL; | 1044 | return -EINVAL; |
1045 | encode_bch(bch, data, len, NULL); | 1045 | encode_bch(bch, data, len, NULL); |
1046 | } else { | 1046 | } else { |
1047 | /* load provided calculated ecc */ | 1047 | /* load provided calculated ecc */ |
1048 | load_ecc8(bch, bch->ecc_buf, calc_ecc); | 1048 | load_ecc8(bch, bch->ecc_buf, calc_ecc); |
1049 | } | 1049 | } |
1050 | /* load received ecc or assume it was XORed in calc_ecc */ | 1050 | /* load received ecc or assume it was XORed in calc_ecc */ |
1051 | if (recv_ecc) { | 1051 | if (recv_ecc) { |
1052 | load_ecc8(bch, bch->ecc_buf2, recv_ecc); | 1052 | load_ecc8(bch, bch->ecc_buf2, recv_ecc); |
1053 | /* XOR received and calculated ecc */ | 1053 | /* XOR received and calculated ecc */ |
1054 | for (i = 0, sum = 0; i < (int)ecc_words; i++) { | 1054 | for (i = 0, sum = 0; i < (int)ecc_words; i++) { |
1055 | bch->ecc_buf[i] ^= bch->ecc_buf2[i]; | 1055 | bch->ecc_buf[i] ^= bch->ecc_buf2[i]; |
1056 | sum |= bch->ecc_buf[i]; | 1056 | sum |= bch->ecc_buf[i]; |
1057 | } | 1057 | } |
1058 | if (!sum) | 1058 | if (!sum) |
1059 | /* no error found */ | 1059 | /* no error found */ |
1060 | return 0; | 1060 | return 0; |
1061 | } | 1061 | } |
1062 | compute_syndromes(bch, bch->ecc_buf, bch->syn); | 1062 | compute_syndromes(bch, bch->ecc_buf, bch->syn); |
1063 | syn = bch->syn; | 1063 | syn = bch->syn; |
1064 | } | 1064 | } |
1065 | 1065 | ||
1066 | err = compute_error_locator_polynomial(bch, syn); | 1066 | err = compute_error_locator_polynomial(bch, syn); |
1067 | if (err > 0) { | 1067 | if (err > 0) { |
1068 | nroots = find_poly_roots(bch, 1, bch->elp, errloc); | 1068 | nroots = find_poly_roots(bch, 1, bch->elp, errloc); |
1069 | if (err != nroots) | 1069 | if (err != nroots) |
1070 | err = -1; | 1070 | err = -1; |
1071 | } | 1071 | } |
1072 | if (err > 0) { | 1072 | if (err > 0) { |
1073 | /* post-process raw error locations for easier correction */ | 1073 | /* post-process raw error locations for easier correction */ |
1074 | nbits = (len*8)+bch->ecc_bits; | 1074 | nbits = (len*8)+bch->ecc_bits; |
1075 | for (i = 0; i < err; i++) { | 1075 | for (i = 0; i < err; i++) { |
1076 | if (errloc[i] >= nbits) { | 1076 | if (errloc[i] >= nbits) { |
1077 | err = -1; | 1077 | err = -1; |
1078 | break; | 1078 | break; |
1079 | } | 1079 | } |
1080 | errloc[i] = nbits-1-errloc[i]; | 1080 | errloc[i] = nbits-1-errloc[i]; |
1081 | errloc[i] = (errloc[i] & ~7)|(7-(errloc[i] & 7)); | 1081 | errloc[i] = (errloc[i] & ~7)|(7-(errloc[i] & 7)); |
1082 | } | 1082 | } |
1083 | } | 1083 | } |
1084 | return (err >= 0) ? err : -EBADMSG; | 1084 | return (err >= 0) ? err : -EBADMSG; |
1085 | } | 1085 | } |
1086 | 1086 | ||
1087 | /* | 1087 | /* |
1088 | * generate Galois field lookup tables | 1088 | * generate Galois field lookup tables |
1089 | */ | 1089 | */ |
1090 | static int build_gf_tables(struct bch_control *bch, unsigned int poly) | 1090 | static int build_gf_tables(struct bch_control *bch, unsigned int poly) |
1091 | { | 1091 | { |
1092 | unsigned int i, x = 1; | 1092 | unsigned int i, x = 1; |
1093 | const unsigned int k = 1 << deg(poly); | 1093 | const unsigned int k = 1 << deg(poly); |
1094 | 1094 | ||
1095 | /* primitive polynomial must be of degree m */ | 1095 | /* primitive polynomial must be of degree m */ |
1096 | if (k != (1u << GF_M(bch))) | 1096 | if (k != (1u << GF_M(bch))) |
1097 | return -1; | 1097 | return -1; |
1098 | 1098 | ||
1099 | for (i = 0; i < GF_N(bch); i++) { | 1099 | for (i = 0; i < GF_N(bch); i++) { |
1100 | bch->a_pow_tab[i] = x; | 1100 | bch->a_pow_tab[i] = x; |
1101 | bch->a_log_tab[x] = i; | 1101 | bch->a_log_tab[x] = i; |
1102 | if (i && (x == 1)) | 1102 | if (i && (x == 1)) |
1103 | /* polynomial is not primitive (a^i=1 with 0<i<2^m-1) */ | 1103 | /* polynomial is not primitive (a^i=1 with 0<i<2^m-1) */ |
1104 | return -1; | 1104 | return -1; |
1105 | x <<= 1; | 1105 | x <<= 1; |
1106 | if (x & k) | 1106 | if (x & k) |
1107 | x ^= poly; | 1107 | x ^= poly; |
1108 | } | 1108 | } |
1109 | bch->a_pow_tab[GF_N(bch)] = 1; | 1109 | bch->a_pow_tab[GF_N(bch)] = 1; |
1110 | bch->a_log_tab[0] = 0; | 1110 | bch->a_log_tab[0] = 0; |
1111 | 1111 | ||
1112 | return 0; | 1112 | return 0; |
1113 | } | 1113 | } |
1114 | 1114 | ||
1115 | /* | 1115 | /* |
1116 | * compute generator polynomial remainder tables for fast encoding | 1116 | * compute generator polynomial remainder tables for fast encoding |
1117 | */ | 1117 | */ |
1118 | static void build_mod8_tables(struct bch_control *bch, const uint32_t *g) | 1118 | static void build_mod8_tables(struct bch_control *bch, const uint32_t *g) |
1119 | { | 1119 | { |
1120 | int i, j, b, d; | 1120 | int i, j, b, d; |
1121 | uint32_t data, hi, lo, *tab; | 1121 | uint32_t data, hi, lo, *tab; |
1122 | const int l = BCH_ECC_WORDS(bch); | 1122 | const int l = BCH_ECC_WORDS(bch); |
1123 | const int plen = DIV_ROUND_UP(bch->ecc_bits+1, 32); | 1123 | const int plen = DIV_ROUND_UP(bch->ecc_bits+1, 32); |
1124 | const int ecclen = DIV_ROUND_UP(bch->ecc_bits, 32); | 1124 | const int ecclen = DIV_ROUND_UP(bch->ecc_bits, 32); |
1125 | 1125 | ||
1126 | memset(bch->mod8_tab, 0, 4*256*l*sizeof(*bch->mod8_tab)); | 1126 | memset(bch->mod8_tab, 0, 4*256*l*sizeof(*bch->mod8_tab)); |
1127 | 1127 | ||
1128 | for (i = 0; i < 256; i++) { | 1128 | for (i = 0; i < 256; i++) { |
1129 | /* p(X)=i is a small polynomial of weight <= 8 */ | 1129 | /* p(X)=i is a small polynomial of weight <= 8 */ |
1130 | for (b = 0; b < 4; b++) { | 1130 | for (b = 0; b < 4; b++) { |
1131 | /* we want to compute (p(X).X^(8*b+deg(g))) mod g(X) */ | 1131 | /* we want to compute (p(X).X^(8*b+deg(g))) mod g(X) */ |
1132 | tab = bch->mod8_tab + (b*256+i)*l; | 1132 | tab = bch->mod8_tab + (b*256+i)*l; |
1133 | data = i << (8*b); | 1133 | data = i << (8*b); |
1134 | while (data) { | 1134 | while (data) { |
1135 | d = deg(data); | 1135 | d = deg(data); |
1136 | /* subtract X^d.g(X) from p(X).X^(8*b+deg(g)) */ | 1136 | /* subtract X^d.g(X) from p(X).X^(8*b+deg(g)) */ |
1137 | data ^= g[0] >> (31-d); | 1137 | data ^= g[0] >> (31-d); |
1138 | for (j = 0; j < ecclen; j++) { | 1138 | for (j = 0; j < ecclen; j++) { |
1139 | hi = (d < 31) ? g[j] << (d+1) : 0; | 1139 | hi = (d < 31) ? g[j] << (d+1) : 0; |
1140 | lo = (j+1 < plen) ? | 1140 | lo = (j+1 < plen) ? |
1141 | g[j+1] >> (31-d) : 0; | 1141 | g[j+1] >> (31-d) : 0; |
1142 | tab[j] ^= hi|lo; | 1142 | tab[j] ^= hi|lo; |
1143 | } | 1143 | } |
1144 | } | 1144 | } |
1145 | } | 1145 | } |
1146 | } | 1146 | } |
1147 | } | 1147 | } |
1148 | 1148 | ||
1149 | /* | 1149 | /* |
1150 | * build a base for factoring degree 2 polynomials | 1150 | * build a base for factoring degree 2 polynomials |
1151 | */ | 1151 | */ |
1152 | static int build_deg2_base(struct bch_control *bch) | 1152 | static int build_deg2_base(struct bch_control *bch) |
1153 | { | 1153 | { |
1154 | const int m = GF_M(bch); | 1154 | const int m = GF_M(bch); |
1155 | int i, j, r; | 1155 | int i, j, r; |
1156 | unsigned int sum, x, y, remaining, ak = 0, xi[m]; | 1156 | unsigned int sum, x, y, remaining, ak = 0, xi[m]; |
1157 | 1157 | ||
1158 | /* find k s.t. Tr(a^k) = 1 and 0 <= k < m */ | 1158 | /* find k s.t. Tr(a^k) = 1 and 0 <= k < m */ |
1159 | for (i = 0; i < m; i++) { | 1159 | for (i = 0; i < m; i++) { |
1160 | for (j = 0, sum = 0; j < m; j++) | 1160 | for (j = 0, sum = 0; j < m; j++) |
1161 | sum ^= a_pow(bch, i*(1 << j)); | 1161 | sum ^= a_pow(bch, i*(1 << j)); |
1162 | 1162 | ||
1163 | if (sum) { | 1163 | if (sum) { |
1164 | ak = bch->a_pow_tab[i]; | 1164 | ak = bch->a_pow_tab[i]; |
1165 | break; | 1165 | break; |
1166 | } | 1166 | } |
1167 | } | 1167 | } |
1168 | /* find xi, i=0..m-1 such that xi^2+xi = a^i+Tr(a^i).a^k */ | 1168 | /* find xi, i=0..m-1 such that xi^2+xi = a^i+Tr(a^i).a^k */ |
1169 | remaining = m; | 1169 | remaining = m; |
1170 | memset(xi, 0, sizeof(xi)); | 1170 | memset(xi, 0, sizeof(xi)); |
1171 | 1171 | ||
1172 | for (x = 0; (x <= GF_N(bch)) && remaining; x++) { | 1172 | for (x = 0; (x <= GF_N(bch)) && remaining; x++) { |
1173 | y = gf_sqr(bch, x)^x; | 1173 | y = gf_sqr(bch, x)^x; |
1174 | for (i = 0; i < 2; i++) { | 1174 | for (i = 0; i < 2; i++) { |
1175 | r = a_log(bch, y); | 1175 | r = a_log(bch, y); |
1176 | if (y && (r < m) && !xi[r]) { | 1176 | if (y && (r < m) && !xi[r]) { |
1177 | bch->xi_tab[r] = x; | 1177 | bch->xi_tab[r] = x; |
1178 | xi[r] = 1; | 1178 | xi[r] = 1; |
1179 | remaining--; | 1179 | remaining--; |
1180 | dbg("x%d = %x\n", r, x); | 1180 | dbg("x%d = %x\n", r, x); |
1181 | break; | 1181 | break; |
1182 | } | 1182 | } |
1183 | y ^= ak; | 1183 | y ^= ak; |
1184 | } | 1184 | } |
1185 | } | 1185 | } |
1186 | /* should not happen but check anyway */ | 1186 | /* should not happen but check anyway */ |
1187 | return remaining ? -1 : 0; | 1187 | return remaining ? -1 : 0; |
1188 | } | 1188 | } |
1189 | 1189 | ||
1190 | static void *bch_alloc(size_t size, int *err) | 1190 | static void *bch_alloc(size_t size, int *err) |
1191 | { | 1191 | { |
1192 | void *ptr; | 1192 | void *ptr; |
1193 | 1193 | ||
1194 | ptr = kmalloc(size, GFP_KERNEL); | 1194 | ptr = kmalloc(size, GFP_KERNEL); |
1195 | if (ptr == NULL) | 1195 | if (ptr == NULL) |
1196 | *err = 1; | 1196 | *err = 1; |
1197 | return ptr; | 1197 | return ptr; |
1198 | } | 1198 | } |
1199 | 1199 | ||
1200 | /* | 1200 | /* |
1201 | * compute generator polynomial for given (m,t) parameters. | 1201 | * compute generator polynomial for given (m,t) parameters. |
1202 | */ | 1202 | */ |
1203 | static uint32_t *compute_generator_polynomial(struct bch_control *bch) | 1203 | static uint32_t *compute_generator_polynomial(struct bch_control *bch) |
1204 | { | 1204 | { |
1205 | const unsigned int m = GF_M(bch); | 1205 | const unsigned int m = GF_M(bch); |
1206 | const unsigned int t = GF_T(bch); | 1206 | const unsigned int t = GF_T(bch); |
1207 | int n, err = 0; | 1207 | int n, err = 0; |
1208 | unsigned int i, j, nbits, r, word, *roots; | 1208 | unsigned int i, j, nbits, r, word, *roots; |
1209 | struct gf_poly *g; | 1209 | struct gf_poly *g; |
1210 | uint32_t *genpoly; | 1210 | uint32_t *genpoly; |
1211 | 1211 | ||
1212 | g = bch_alloc(GF_POLY_SZ(m*t), &err); | 1212 | g = bch_alloc(GF_POLY_SZ(m*t), &err); |
1213 | roots = bch_alloc((bch->n+1)*sizeof(*roots), &err); | 1213 | roots = bch_alloc((bch->n+1)*sizeof(*roots), &err); |
1214 | genpoly = bch_alloc(DIV_ROUND_UP(m*t+1, 32)*sizeof(*genpoly), &err); | 1214 | genpoly = bch_alloc(DIV_ROUND_UP(m*t+1, 32)*sizeof(*genpoly), &err); |
1215 | 1215 | ||
1216 | if (err) { | 1216 | if (err) { |
1217 | kfree(genpoly); | 1217 | kfree(genpoly); |
1218 | genpoly = NULL; | 1218 | genpoly = NULL; |
1219 | goto finish; | 1219 | goto finish; |
1220 | } | 1220 | } |
1221 | 1221 | ||
1222 | /* enumerate all roots of g(X) */ | 1222 | /* enumerate all roots of g(X) */ |
1223 | memset(roots , 0, (bch->n+1)*sizeof(*roots)); | 1223 | memset(roots , 0, (bch->n+1)*sizeof(*roots)); |
1224 | for (i = 0; i < t; i++) { | 1224 | for (i = 0; i < t; i++) { |
1225 | for (j = 0, r = 2*i+1; j < m; j++) { | 1225 | for (j = 0, r = 2*i+1; j < m; j++) { |
1226 | roots[r] = 1; | 1226 | roots[r] = 1; |
1227 | r = mod_s(bch, 2*r); | 1227 | r = mod_s(bch, 2*r); |
1228 | } | 1228 | } |
1229 | } | 1229 | } |
1230 | /* build generator polynomial g(X) */ | 1230 | /* build generator polynomial g(X) */ |
1231 | g->deg = 0; | 1231 | g->deg = 0; |
1232 | g->c[0] = 1; | 1232 | g->c[0] = 1; |
1233 | for (i = 0; i < GF_N(bch); i++) { | 1233 | for (i = 0; i < GF_N(bch); i++) { |
1234 | if (roots[i]) { | 1234 | if (roots[i]) { |
1235 | /* multiply g(X) by (X+root) */ | 1235 | /* multiply g(X) by (X+root) */ |
1236 | r = bch->a_pow_tab[i]; | 1236 | r = bch->a_pow_tab[i]; |
1237 | g->c[g->deg+1] = 1; | 1237 | g->c[g->deg+1] = 1; |
1238 | for (j = g->deg; j > 0; j--) | 1238 | for (j = g->deg; j > 0; j--) |
1239 | g->c[j] = gf_mul(bch, g->c[j], r)^g->c[j-1]; | 1239 | g->c[j] = gf_mul(bch, g->c[j], r)^g->c[j-1]; |
1240 | 1240 | ||
1241 | g->c[0] = gf_mul(bch, g->c[0], r); | 1241 | g->c[0] = gf_mul(bch, g->c[0], r); |
1242 | g->deg++; | 1242 | g->deg++; |
1243 | } | 1243 | } |
1244 | } | 1244 | } |
1245 | /* store left-justified binary representation of g(X) */ | 1245 | /* store left-justified binary representation of g(X) */ |
1246 | n = g->deg+1; | 1246 | n = g->deg+1; |
1247 | i = 0; | 1247 | i = 0; |
1248 | 1248 | ||
1249 | while (n > 0) { | 1249 | while (n > 0) { |
1250 | nbits = (n > 32) ? 32 : n; | 1250 | nbits = (n > 32) ? 32 : n; |
1251 | for (j = 0, word = 0; j < nbits; j++) { | 1251 | for (j = 0, word = 0; j < nbits; j++) { |
1252 | if (g->c[n-1-j]) | 1252 | if (g->c[n-1-j]) |
1253 | word |= 1u << (31-j); | 1253 | word |= 1u << (31-j); |
1254 | } | 1254 | } |
1255 | genpoly[i++] = word; | 1255 | genpoly[i++] = word; |
1256 | n -= nbits; | 1256 | n -= nbits; |
1257 | } | 1257 | } |
1258 | bch->ecc_bits = g->deg; | 1258 | bch->ecc_bits = g->deg; |
1259 | 1259 | ||
1260 | finish: | 1260 | finish: |
1261 | kfree(g); | 1261 | kfree(g); |
1262 | kfree(roots); | 1262 | kfree(roots); |
1263 | 1263 | ||
1264 | return genpoly; | 1264 | return genpoly; |
1265 | } | 1265 | } |
1266 | 1266 | ||
1267 | /** | 1267 | /** |
1268 | * init_bch - initialize a BCH encoder/decoder | 1268 | * init_bch - initialize a BCH encoder/decoder |
1269 | * @m: Galois field order, should be in the range 5-15 | 1269 | * @m: Galois field order, should be in the range 5-15 |
1270 | * @t: maximum error correction capability, in bits | 1270 | * @t: maximum error correction capability, in bits |
1271 | * @prim_poly: user-provided primitive polynomial (or 0 to use default) | 1271 | * @prim_poly: user-provided primitive polynomial (or 0 to use default) |
1272 | * | 1272 | * |
1273 | * Returns: | 1273 | * Returns: |
1274 | * a newly allocated BCH control structure if successful, NULL otherwise | 1274 | * a newly allocated BCH control structure if successful, NULL otherwise |
1275 | * | 1275 | * |
1276 | * This initialization can take some time, as lookup tables are built for fast | 1276 | * This initialization can take some time, as lookup tables are built for fast |
1277 | * encoding/decoding; make sure not to call this function from a time critical | 1277 | * encoding/decoding; make sure not to call this function from a time critical |
1278 | * path. Usually, init_bch() should be called on module/driver init and | 1278 | * path. Usually, init_bch() should be called on module/driver init and |
1279 | * free_bch() should be called to release memory on exit. | 1279 | * free_bch() should be called to release memory on exit. |
1280 | * | 1280 | * |
1281 | * You may provide your own primitive polynomial of degree @m in argument | 1281 | * You may provide your own primitive polynomial of degree @m in argument |
1282 | * @prim_poly, or let init_bch() use its default polynomial. | 1282 | * @prim_poly, or let init_bch() use its default polynomial. |
1283 | * | 1283 | * |
1284 | * Once init_bch() has successfully returned a pointer to a newly allocated | 1284 | * Once init_bch() has successfully returned a pointer to a newly allocated |
1285 | * BCH control structure, ecc length in bytes is given by member @ecc_bytes of | 1285 | * BCH control structure, ecc length in bytes is given by member @ecc_bytes of |
1286 | * the structure. | 1286 | * the structure. |
1287 | */ | 1287 | */ |
1288 | struct bch_control *init_bch(int m, int t, unsigned int prim_poly) | 1288 | struct bch_control *init_bch(int m, int t, unsigned int prim_poly) |
1289 | { | 1289 | { |
1290 | int err = 0; | 1290 | int err = 0; |
1291 | unsigned int i, words; | 1291 | unsigned int i, words; |
1292 | uint32_t *genpoly; | 1292 | uint32_t *genpoly; |
1293 | struct bch_control *bch = NULL; | 1293 | struct bch_control *bch = NULL; |
1294 | 1294 | ||
1295 | const int min_m = 5; | 1295 | const int min_m = 5; |
1296 | const int max_m = 15; | 1296 | const int max_m = 15; |
1297 | 1297 | ||
1298 | /* default primitive polynomials */ | 1298 | /* default primitive polynomials */ |
1299 | static const unsigned int prim_poly_tab[] = { | 1299 | static const unsigned int prim_poly_tab[] = { |
1300 | 0x25, 0x43, 0x83, 0x11d, 0x211, 0x409, 0x805, 0x1053, 0x201b, | 1300 | 0x25, 0x43, 0x83, 0x11d, 0x211, 0x409, 0x805, 0x1053, 0x201b, |
1301 | 0x402b, 0x8003, | 1301 | 0x402b, 0x8003, |
1302 | }; | 1302 | }; |
1303 | 1303 | ||
1304 | #if defined(CONFIG_BCH_CONST_PARAMS) | 1304 | #if defined(CONFIG_BCH_CONST_PARAMS) |
1305 | if ((m != (CONFIG_BCH_CONST_M)) || (t != (CONFIG_BCH_CONST_T))) { | 1305 | if ((m != (CONFIG_BCH_CONST_M)) || (t != (CONFIG_BCH_CONST_T))) { |
1306 | printk(KERN_ERR "bch encoder/decoder was configured to support " | 1306 | printk(KERN_ERR "bch encoder/decoder was configured to support " |
1307 | "parameters m=%d, t=%d only!\n", | 1307 | "parameters m=%d, t=%d only!\n", |
1308 | CONFIG_BCH_CONST_M, CONFIG_BCH_CONST_T); | 1308 | CONFIG_BCH_CONST_M, CONFIG_BCH_CONST_T); |
1309 | goto fail; | 1309 | goto fail; |
1310 | } | 1310 | } |
1311 | #endif | 1311 | #endif |
1312 | if ((m < min_m) || (m > max_m)) | 1312 | if ((m < min_m) || (m > max_m)) |
1313 | /* | 1313 | /* |
1314 | * values of m greater than 15 are not currently supported; | 1314 | * values of m greater than 15 are not currently supported; |
1315 | * supporting m > 15 would require changing table base type | 1315 | * supporting m > 15 would require changing table base type |
1316 | * (uint16_t) and a small patch in matrix transposition | 1316 | * (uint16_t) and a small patch in matrix transposition |
1317 | */ | 1317 | */ |
1318 | goto fail; | 1318 | goto fail; |
1319 | 1319 | ||
1320 | /* sanity checks */ | 1320 | /* sanity checks */ |
1321 | if ((t < 1) || (m*t >= ((1 << m)-1))) | 1321 | if ((t < 1) || (m*t >= ((1 << m)-1))) |
1322 | /* invalid t value */ | 1322 | /* invalid t value */ |
1323 | goto fail; | 1323 | goto fail; |
1324 | 1324 | ||
1325 | /* select a primitive polynomial for generating GF(2^m) */ | 1325 | /* select a primitive polynomial for generating GF(2^m) */ |
1326 | if (prim_poly == 0) | 1326 | if (prim_poly == 0) |
1327 | prim_poly = prim_poly_tab[m-min_m]; | 1327 | prim_poly = prim_poly_tab[m-min_m]; |
1328 | 1328 | ||
1329 | bch = kzalloc(sizeof(*bch), GFP_KERNEL); | 1329 | bch = kzalloc(sizeof(*bch), GFP_KERNEL); |
1330 | if (bch == NULL) | 1330 | if (bch == NULL) |
1331 | goto fail; | 1331 | goto fail; |
1332 | 1332 | ||
1333 | bch->m = m; | 1333 | bch->m = m; |
1334 | bch->t = t; | 1334 | bch->t = t; |
1335 | bch->n = (1 << m)-1; | 1335 | bch->n = (1 << m)-1; |
1336 | words = DIV_ROUND_UP(m*t, 32); | 1336 | words = DIV_ROUND_UP(m*t, 32); |
1337 | bch->ecc_bytes = DIV_ROUND_UP(m*t, 8); | 1337 | bch->ecc_bytes = DIV_ROUND_UP(m*t, 8); |
1338 | bch->a_pow_tab = bch_alloc((1+bch->n)*sizeof(*bch->a_pow_tab), &err); | 1338 | bch->a_pow_tab = bch_alloc((1+bch->n)*sizeof(*bch->a_pow_tab), &err); |
1339 | bch->a_log_tab = bch_alloc((1+bch->n)*sizeof(*bch->a_log_tab), &err); | 1339 | bch->a_log_tab = bch_alloc((1+bch->n)*sizeof(*bch->a_log_tab), &err); |
1340 | bch->mod8_tab = bch_alloc(words*1024*sizeof(*bch->mod8_tab), &err); | 1340 | bch->mod8_tab = bch_alloc(words*1024*sizeof(*bch->mod8_tab), &err); |
1341 | bch->ecc_buf = bch_alloc(words*sizeof(*bch->ecc_buf), &err); | 1341 | bch->ecc_buf = bch_alloc(words*sizeof(*bch->ecc_buf), &err); |
1342 | bch->ecc_buf2 = bch_alloc(words*sizeof(*bch->ecc_buf2), &err); | 1342 | bch->ecc_buf2 = bch_alloc(words*sizeof(*bch->ecc_buf2), &err); |
1343 | bch->xi_tab = bch_alloc(m*sizeof(*bch->xi_tab), &err); | 1343 | bch->xi_tab = bch_alloc(m*sizeof(*bch->xi_tab), &err); |
1344 | bch->syn = bch_alloc(2*t*sizeof(*bch->syn), &err); | 1344 | bch->syn = bch_alloc(2*t*sizeof(*bch->syn), &err); |
1345 | bch->cache = bch_alloc(2*t*sizeof(*bch->cache), &err); | 1345 | bch->cache = bch_alloc(2*t*sizeof(*bch->cache), &err); |
1346 | bch->elp = bch_alloc((t+1)*sizeof(struct gf_poly_deg1), &err); | 1346 | bch->elp = bch_alloc((t+1)*sizeof(struct gf_poly_deg1), &err); |
1347 | 1347 | ||
1348 | for (i = 0; i < ARRAY_SIZE(bch->poly_2t); i++) | 1348 | for (i = 0; i < ARRAY_SIZE(bch->poly_2t); i++) |
1349 | bch->poly_2t[i] = bch_alloc(GF_POLY_SZ(2*t), &err); | 1349 | bch->poly_2t[i] = bch_alloc(GF_POLY_SZ(2*t), &err); |
1350 | 1350 | ||
1351 | if (err) | 1351 | if (err) |
1352 | goto fail; | 1352 | goto fail; |
1353 | 1353 | ||
1354 | err = build_gf_tables(bch, prim_poly); | 1354 | err = build_gf_tables(bch, prim_poly); |
1355 | if (err) | 1355 | if (err) |
1356 | goto fail; | 1356 | goto fail; |
1357 | 1357 | ||
1358 | /* use generator polynomial for computing encoding tables */ | 1358 | /* use generator polynomial for computing encoding tables */ |
1359 | genpoly = compute_generator_polynomial(bch); | 1359 | genpoly = compute_generator_polynomial(bch); |
1360 | if (genpoly == NULL) | 1360 | if (genpoly == NULL) |
1361 | goto fail; | 1361 | goto fail; |
1362 | 1362 | ||
1363 | build_mod8_tables(bch, genpoly); | 1363 | build_mod8_tables(bch, genpoly); |
1364 | kfree(genpoly); | 1364 | kfree(genpoly); |
1365 | 1365 | ||
1366 | err = build_deg2_base(bch); | 1366 | err = build_deg2_base(bch); |
1367 | if (err) | 1367 | if (err) |
1368 | goto fail; | 1368 | goto fail; |
1369 | 1369 | ||
1370 | return bch; | 1370 | return bch; |
1371 | 1371 | ||
1372 | fail: | 1372 | fail: |
1373 | free_bch(bch); | 1373 | free_bch(bch); |
1374 | return NULL; | 1374 | return NULL; |
1375 | } | 1375 | } |
1376 | 1376 | ||
1377 | /** | 1377 | /** |
1378 | * free_bch - free the BCH control structure | 1378 | * free_bch - free the BCH control structure |
1379 | * @bch: BCH control structure to release | 1379 | * @bch: BCH control structure to release |
1380 | */ | 1380 | */ |
1381 | void free_bch(struct bch_control *bch) | 1381 | void free_bch(struct bch_control *bch) |
1382 | { | 1382 | { |
1383 | unsigned int i; | 1383 | unsigned int i; |
1384 | 1384 | ||
1385 | if (bch) { | 1385 | if (bch) { |
1386 | kfree(bch->a_pow_tab); | 1386 | kfree(bch->a_pow_tab); |
1387 | kfree(bch->a_log_tab); | 1387 | kfree(bch->a_log_tab); |
1388 | kfree(bch->mod8_tab); | 1388 | kfree(bch->mod8_tab); |
1389 | kfree(bch->ecc_buf); | 1389 | kfree(bch->ecc_buf); |
1390 | kfree(bch->ecc_buf2); | 1390 | kfree(bch->ecc_buf2); |
1391 | kfree(bch->xi_tab); | 1391 | kfree(bch->xi_tab); |
1392 | kfree(bch->syn); | 1392 | kfree(bch->syn); |
1393 | kfree(bch->cache); | 1393 | kfree(bch->cache); |
1394 | kfree(bch->elp); | 1394 | kfree(bch->elp); |
1395 | 1395 | ||
1396 | for (i = 0; i < ARRAY_SIZE(bch->poly_2t); i++) | 1396 | for (i = 0; i < ARRAY_SIZE(bch->poly_2t); i++) |
1397 | kfree(bch->poly_2t[i]); | 1397 | kfree(bch->poly_2t[i]); |
1398 | 1398 | ||
1399 | kfree(bch); | 1399 | kfree(bch); |
1400 | } | 1400 | } |
1401 | } | 1401 | } |
1402 | 1402 |