lib/reed_solomon/reed_solomon.c

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