lib/reed_solomon/reed_solomon.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Generic Reed Solomon encoder / decoder library
   4  *
   5  * Copyright (C) 2004 Thomas Gleixner (tglx@linutronix.de)
   6  *
   7  * Reed Solomon code lifted from reed solomon library written by Phil Karn
   8  * Copyright 2002 Phil Karn, KA9Q
   9  *
  10  * Description:
  11  *
  12  * The generic Reed Solomon library provides runtime configurable
  13  * encoding / decoding of RS codes.
  14  *
  15  * Each user must call init_rs to get a pointer to a rs_control structure
  16  * for the given rs parameters. The control struct is unique per instance.
  17  * It points to a codec which can be shared by multiple control structures.
  18  * If a codec is newly allocated then the polynomial arrays for fast
  19  * encoding / decoding are built. This can take some time so make sure not
  20  * to call this function from a time critical path.  Usually a module /
  21  * driver should initialize the necessary rs_control structure on module /
  22  * driver init and release it on exit.
  23  *
  24  * The encoding puts the calculated syndrome into a given syndrome buffer.
  25  *
  26  * The decoding is a two step process. The first step calculates the
  27  * syndrome over the received (data + syndrome) and calls the second stage,
  28  * which does the decoding / error correction itself.  Many hw encoders
  29  * provide a syndrome calculation over the received data + syndrome and can
  30  * call the second stage directly.
  31  */
  32 #include <linux/errno.h>
  33 #include <linux/kernel.h>
  34 #include <linux/init.h>
  35 #include <linux/module.h>
  36 #include <linux/rslib.h>
  37 #include <linux/slab.h>
  38 #include <linux/mutex.h>
  39
  40 enum {
  41         RS_DECODE_LAMBDA,
  42         RS_DECODE_SYN,
  43         RS_DECODE_B,
  44         RS_DECODE_T,
  45         RS_DECODE_OMEGA,
  46         RS_DECODE_ROOT,
  47         RS_DECODE_REG,
  48         RS_DECODE_LOC,
  49         RS_DECODE_NUM_BUFFERS
  50 };
  51
  52 /* This list holds all currently allocated rs codec structures */
  53 static LIST_HEAD(codec_list);
  54 /* Protection for the list */
  55 static DEFINE_MUTEX(rslistlock);
  56
  57 /**
  58  * codec_init - Initialize a Reed-Solomon codec
  59  * @symsize:    symbol size, bits (1-8)
  60  * @gfpoly:     Field generator polynomial coefficients
  61  * @gffunc:     Field generator function
  62  * @fcr:        first root of RS code generator polynomial, index form
  63  * @prim:       primitive element to generate polynomial roots
  64  * @nroots:     RS code generator polynomial degree (number of roots)
  65  * @gfp:        GFP_ flags for allocations
  66  *
  67  * Allocate a codec structure and the polynom arrays for faster
  68  * en/decoding. Fill the arrays according to the given parameters.
  69  */
  70 static struct rs_codec *codec_init(int symsize, int gfpoly, int (*gffunc)(int),
  71                                    int fcr, int prim, int nroots, gfp_t gfp)
  72 {
  73         int i, j, sr, root, iprim;
  74         struct rs_codec *rs;
  75
  76         rs = kzalloc(sizeof(*rs), gfp);
  77         if (!rs)
  78                 return NULL;
  79
  80         INIT_LIST_HEAD(&rs->list);
  81
  82         rs->mm = symsize;
  83         rs->nn = (1 << symsize) - 1;
  84         rs->fcr = fcr;
  85         rs->prim = prim;
  86         rs->nroots = nroots;
  87         rs->gfpoly = gfpoly;
  88         rs->gffunc = gffunc;
  89
  90         /* Allocate the arrays */
  91         rs->alpha_to = kmalloc_array(rs->nn + 1, sizeof(uint16_t), gfp);
  92         if (rs->alpha_to == NULL)
  93                 goto err;
  94
  95         rs->index_of = kmalloc_array(rs->nn + 1, sizeof(uint16_t), gfp);
  96         if (rs->index_of == NULL)
  97                 goto err;
  98
  99         rs->genpoly = kmalloc_array(rs->nroots + 1, sizeof(uint16_t), gfp);
 100         if(rs->genpoly == NULL)
 101                 goto err;
 102
 103         /* Generate Galois field lookup tables */
 104         rs->index_of[0] = rs->nn;       /* log(zero) = -inf */
 105         rs->alpha_to[rs->nn] = 0;       /* alpha**-inf = 0 */
 106         if (gfpoly) {
 107                 sr = 1;
 108                 for (i = 0; i < rs->nn; i++) {
 109                         rs->index_of[sr] = i;
 110                         rs->alpha_to[i] = sr;
 111                         sr <<= 1;
 112                         if (sr & (1 << symsize))
 113                                 sr ^= gfpoly;
 114                         sr &= rs->nn;
 115                 }
 116         } else {
 117                 sr = gffunc(0);
 118                 for (i = 0; i < rs->nn; i++) {
 119                         rs->index_of[sr] = i;
 120                         rs->alpha_to[i] = sr;
 121                         sr = gffunc(sr);
 122                 }
 123         }
 124         /* If it's not primitive, exit */
 125         if(sr != rs->alpha_to[0])
 126                 goto err;
 127
 128         /* Find prim-th root of 1, used in decoding */
 129         for(iprim = 1; (iprim % prim) != 0; iprim += rs->nn);
 130         /* prim-th root of 1, index form */
 131         rs->iprim = iprim / prim;
 132
 133         /* Form RS code generator polynomial from its roots */
 134         rs->genpoly[0] = 1;
 135         for (i = 0, root = fcr * prim; i < nroots; i++, root += prim) {
 136                 rs->genpoly[i + 1] = 1;
 137                 /* Multiply rs->genpoly[] by  @**(root + x) */
 138                 for (j = i; j > 0; j--) {
 139                         if (rs->genpoly[j] != 0) {
 140                                 rs->genpoly[j] = rs->genpoly[j -1] ^
 141                                         rs->alpha_to[rs_modnn(rs,
 142                                         rs->index_of[rs->genpoly[j]] + root)];
 143                         } else
 144                                 rs->genpoly[j] = rs->genpoly[j - 1];
 145                 }
 146                 /* rs->genpoly[0] can never be zero */
 147                 rs->genpoly[0] =
 148                         rs->alpha_to[rs_modnn(rs,
 149                                 rs->index_of[rs->genpoly[0]] + root)];
 150         }
 151         /* convert rs->genpoly[] to index form for quicker encoding */
 152         for (i = 0; i <= nroots; i++)
 153                 rs->genpoly[i] = rs->index_of[rs->genpoly[i]];
 154
 155         rs->users = 1;
 156         list_add(&rs->list, &codec_list);
 157         return rs;
 158
 159 err:
 160         kfree(rs->genpoly);
 161         kfree(rs->index_of);
 162         kfree(rs->alpha_to);
 163         kfree(rs);
 164         return NULL;
 165 }
 166
 167
 168 /**
 169  *  free_rs - Free the rs control structure
 170  *  @rs:        The control structure which is not longer used by the
 171  *              caller
 172  *
 173  * Free the control structure. If @rs is the last user of the associated
 174  * codec, free the codec as well.
 175  */
 176 void free_rs(struct rs_control *rs)
 177 {
 178         struct rs_codec *cd;
 179
 180         if (!rs)
 181                 return;
 182
 183         cd = rs->codec;
 184         mutex_lock(&rslistlock);
 185         cd->users--;
 186         if(!cd->users) {
 187                 list_del(&cd->list);
 188                 kfree(cd->alpha_to);
 189                 kfree(cd->index_of);
 190                 kfree(cd->genpoly);
 191                 kfree(cd);
 192         }
 193         mutex_unlock(&rslistlock);
 194         kfree(rs);
 195 }
 196 EXPORT_SYMBOL_GPL(free_rs);
 197
 198 /**
 199  * init_rs_internal - Allocate rs control, find a matching codec or allocate a new one
 200  *  @symsize:   the symbol size (number of bits)
 201  *  @gfpoly:    the extended Galois field generator polynomial coefficients,
 202  *              with the 0th coefficient in the low order bit. The polynomial
 203  *              must be primitive;
 204  *  @gffunc:    pointer to function to generate the next field element,
 205  *              or the multiplicative identity element if given 0.  Used
 206  *              instead of gfpoly if gfpoly is 0
 207  *  @fcr:       the first consecutive root of the rs code generator polynomial
 208  *              in index form
 209  *  @prim:      primitive element to generate polynomial roots
 210  *  @nroots:    RS code generator polynomial degree (number of roots)
 211  *  @gfp:       GFP_ flags for allocations
 212  */
 213 static struct rs_control *init_rs_internal(int symsize, int gfpoly,
 214                                            int (*gffunc)(int), int fcr,
 215                                            int prim, int nroots, gfp_t gfp)
 216 {
 217         struct list_head *tmp;
 218         struct rs_control *rs;
 219         unsigned int bsize;
 220
 221         /* Sanity checks */
 222         if (symsize < 1)
 223                 return NULL;
 224         if (fcr < 0 || fcr >= (1<<symsize))
 225                 return NULL;
 226         if (prim <= 0 || prim >= (1<<symsize))
 227                 return NULL;
 228         if (nroots < 0 || nroots >= (1<<symsize))
 229                 return NULL;
 230
 231         /*
 232          * The decoder needs buffers in each control struct instance to
 233          * avoid variable size or large fixed size allocations on
 234          * stack. Size the buffers to arrays of [nroots + 1].
 235          */
 236         bsize = sizeof(uint16_t) * RS_DECODE_NUM_BUFFERS * (nroots + 1);
 237         rs = kzalloc(sizeof(*rs) + bsize, gfp);
 238         if (!rs)
 239                 return NULL;
 240
 241         mutex_lock(&rslistlock);
 242
 243         /* Walk through the list and look for a matching entry */
 244         list_for_each(tmp, &codec_list) {
 245                 struct rs_codec *cd = list_entry(tmp, struct rs_codec, list);
 246
 247                 if (symsize != cd->mm)
 248                         continue;
 249                 if (gfpoly != cd->gfpoly)
 250                         continue;
 251                 if (gffunc != cd->gffunc)
 252                         continue;
 253                 if (fcr != cd->fcr)
 254                         continue;
 255                 if (prim != cd->prim)
 256                         continue;
 257                 if (nroots != cd->nroots)
 258                         continue;
 259                 /* We have a matching one already */
 260                 cd->users++;
 261                 rs->codec = cd;
 262                 goto out;
 263         }
 264
 265         /* Create a new one */
 266         rs->codec = codec_init(symsize, gfpoly, gffunc, fcr, prim, nroots, gfp);
 267         if (!rs->codec) {
 268                 kfree(rs);
 269                 rs = NULL;
 270         }
 271 out:
 272         mutex_unlock(&rslistlock);
 273         return rs;
 274 }
 275
 276 /**
 277  * init_rs_gfp - Create a RS control struct and initialize it
 278  *  @symsize:   the symbol size (number of bits)
 279  *  @gfpoly:    the extended Galois field generator polynomial coefficients,
 280  *              with the 0th coefficient in the low order bit. The polynomial
 281  *              must be primitive;
 282  *  @fcr:       the first consecutive root of the rs code generator polynomial
 283  *              in index form
 284  *  @prim:      primitive element to generate polynomial roots
 285  *  @nroots:    RS code generator polynomial degree (number of roots)
 286  *  @gfp:       Memory allocation flags.
 287  */
 288 struct rs_control *init_rs_gfp(int symsize, int gfpoly, int fcr, int prim,
 289                                int nroots, gfp_t gfp)
 290 {
 291         return init_rs_internal(symsize, gfpoly, NULL, fcr, prim, nroots, gfp);
 292 }
 293 EXPORT_SYMBOL_GPL(init_rs_gfp);
 294
 295 /**
 296  * init_rs_non_canonical - Allocate rs control struct for fields with
 297  *                         non-canonical representation
 298  *  @symsize:   the symbol size (number of bits)
 299  *  @gffunc:    pointer to function to generate the next field element,
 300  *              or the multiplicative identity element if given 0.  Used
 301  *              instead of gfpoly if gfpoly is 0
 302  *  @fcr:       the first consecutive root of the rs code generator polynomial
 303  *              in index form
 304  *  @prim:      primitive element to generate polynomial roots
 305  *  @nroots:    RS code generator polynomial degree (number of roots)
 306  */
 307 struct rs_control *init_rs_non_canonical(int symsize, int (*gffunc)(int),
 308                                          int fcr, int prim, int nroots)
 309 {
 310         return init_rs_internal(symsize, 0, gffunc, fcr, prim, nroots,
 311                                 GFP_KERNEL);
 312 }
 313 EXPORT_SYMBOL_GPL(init_rs_non_canonical);
 314
 315 #ifdef CONFIG_REED_SOLOMON_ENC8
 316 /**
 317  *  encode_rs8 - Calculate the parity for data values (8bit data width)
 318  *  @rsc:       the rs control structure
 319  *  @data:      data field of a given type
 320  *  @len:       data length
 321  *  @par:       parity data, must be initialized by caller (usually all 0)
 322  *  @invmsk:    invert data mask (will be xored on data)
 323  *
 324  *  The parity uses a uint16_t data type to enable
 325  *  symbol size > 8. The calling code must take care of encoding of the
 326  *  syndrome result for storage itself.
 327  */
 328 int encode_rs8(struct rs_control *rsc, uint8_t *data, int len, uint16_t *par,
 329                uint16_t invmsk)
 330 {
 331 #include "encode_rs.c"
 332 }
 333 EXPORT_SYMBOL_GPL(encode_rs8);
 334 #endif
 335
 336 #ifdef CONFIG_REED_SOLOMON_DEC8
 337 /**
 338  *  decode_rs8 - Decode codeword (8bit data width)
 339  *  @rsc:       the rs control structure
 340  *  @data:      data field of a given type
 341  *  @par:       received parity data field
 342  *  @len:       data length
 343  *  @s:         syndrome data field, must be in index form
 344  *              (if NULL, syndrome is calculated)
 345  *  @no_eras:   number of erasures
 346  *  @eras_pos:  position of erasures, can be NULL
 347  *  @invmsk:    invert data mask (will be xored on data, not on parity!)
 348  *  @corr:      buffer to store correction bitmask on eras_pos
 349  *
 350  *  The syndrome and parity uses a uint16_t data type to enable
 351  *  symbol size > 8. The calling code must take care of decoding of the
 352  *  syndrome result and the received parity before calling this code.
 353  *
 354  *  Note: The rs_control struct @rsc contains buffers which are used for
 355  *  decoding, so the caller has to ensure that decoder invocations are
 356  *  serialized.
 357  *
 358  *  Returns the number of corrected symbols or -EBADMSG for uncorrectable
 359  *  errors. The count includes errors in the parity.
 360  */
 361 int decode_rs8(struct rs_control *rsc, uint8_t *data, uint16_t *par, int len,
 362                uint16_t *s, int no_eras, int *eras_pos, uint16_t invmsk,
 363                uint16_t *corr)
 364 {
 365 #include "decode_rs.c"
 366 }
 367 EXPORT_SYMBOL_GPL(decode_rs8);
 368 #endif
 369
 370 #ifdef CONFIG_REED_SOLOMON_ENC16
 371 /**
 372  *  encode_rs16 - Calculate the parity for data values (16bit data width)
 373  *  @rsc:       the rs control structure
 374  *  @data:      data field of a given type
 375  *  @len:       data length
 376  *  @par:       parity data, must be initialized by caller (usually all 0)
 377  *  @invmsk:    invert data mask (will be xored on data, not on parity!)
 378  *
 379  *  Each field in the data array contains up to symbol size bits of valid data.
 380  */
 381 int encode_rs16(struct rs_control *rsc, uint16_t *data, int len, uint16_t *par,
 382         uint16_t invmsk)
 383 {
 384 #include "encode_rs.c"
 385 }
 386 EXPORT_SYMBOL_GPL(encode_rs16);
 387 #endif
 388
 389 #ifdef CONFIG_REED_SOLOMON_DEC16
 390 /**
 391  *  decode_rs16 - Decode codeword (16bit data width)
 392  *  @rsc:       the rs control structure
 393  *  @data:      data field of a given type
 394  *  @par:       received parity data field
 395  *  @len:       data length
 396  *  @s:         syndrome data field, must be in index form
 397  *              (if NULL, syndrome is calculated)
 398  *  @no_eras:   number of erasures
 399  *  @eras_pos:  position of erasures, can be NULL
 400  *  @invmsk:    invert data mask (will be xored on data, not on parity!)
 401  *  @corr:      buffer to store correction bitmask on eras_pos
 402  *
 403  *  Each field in the data array contains up to symbol size bits of valid data.
 404  *
 405  *  Note: The rc_control struct @rsc contains buffers which are used for
 406  *  decoding, so the caller has to ensure that decoder invocations are
 407  *  serialized.
 408  *
 409  *  Returns the number of corrected symbols or -EBADMSG for uncorrectable
 410  *  errors. The count includes errors in the parity.
 411  */
 412 int decode_rs16(struct rs_control *rsc, uint16_t *data, uint16_t *par, int len,
 413                 uint16_t *s, int no_eras, int *eras_pos, uint16_t invmsk,
 414                 uint16_t *corr)
 415 {
 416 #include "decode_rs.c"
 417 }
 418 EXPORT_SYMBOL_GPL(decode_rs16);
 419 #endif
 420
 421 MODULE_LICENSE("GPL");
 422 MODULE_DESCRIPTION("Reed Solomon encoder/decoder");
 423 MODULE_AUTHOR("Phil Karn, Thomas Gleixner");
 424