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