ReedSolomon Library Programming Interface¶
 Author
Thomas Gleixner
Introduction¶
The generic ReedSolomon Library provides encoding, decoding and error correction functions.
ReedSolomon codes are used in communication and storage applications to ensure data integrity.
This documentation is provided for developers who want to utilize the functions provided by the library.
Known Bugs And Assumptions¶
None.
Usage¶
This chapter provides examples of how to use the library.
Initializing¶
The init function init_rs returns a pointer to an rs decoder structure, which holds the necessary information for encoding, decoding and error correction with the given polynomial. It either uses an existing matching decoder or creates a new one. On creation all the lookup tables for fast en/decoding are created. The function may take a while, so make sure not to call it in critical code paths.
/* the Reed Solomon control structure */
static struct rs_control *rs_decoder;
/* Symbolsize is 10 (bits)
* Primitive polynomial is x^10+x^3+1
* first consecutive root is 0
* primitive element to generate roots = 1
* generator polynomial degree (number of roots) = 6
*/
rs_decoder = init_rs (10, 0x409, 0, 1, 6);
Encoding¶
The encoder calculates the ReedSolomon code over the given data length and stores the result in the parity buffer. Note that the parity buffer must be initialized before calling the encoder.
The expanded data can be inverted on the fly by providing a nonzero inversion mask. The expanded data is XOR’ed with the mask. This is used e.g. for FLASH ECC, where the all 0xFF is inverted to an all 0x00. The ReedSolomon code for all 0x00 is all 0x00. The code is inverted before storing to FLASH so it is 0xFF too. This prevents that reading from an erased FLASH results in ECC errors.
The databytes are expanded to the given symbol size on the fly. There is no support for encoding continuous bitstreams with a symbol size != 8 at the moment. If it is necessary it should be not a big deal to implement such functionality.
/* Parity buffer. Size = number of roots */
uint16_t par[6];
/* Initialize the parity buffer */
memset(par, 0, sizeof(par));
/* Encode 512 byte in data8. Store parity in buffer par */
encode_rs8 (rs_decoder, data8, 512, par, 0);
Decoding¶
The decoder calculates the syndrome over the given data length and the received parity symbols and corrects errors in the data.
If a syndrome is available from a hardware decoder then the syndrome calculation is skipped.
The correction of the data buffer can be suppressed by providing a correction pattern buffer and an error location buffer to the decoder. The decoder stores the calculated error location and the correction bitmask in the given buffers. This is useful for hardware decoders which use a weird bit ordering scheme.
The databytes are expanded to the given symbol size on the fly. There is no support for decoding continuous bitstreams with a symbolsize != 8 at the moment. If it is necessary it should be not a big deal to implement such functionality.
Decoding with syndrome calculation, direct data correction¶
/* Parity buffer. Size = number of roots */
uint16_t par[6];
uint8_t data[512];
int numerr;
/* Receive data */
.....
/* Receive parity */
.....
/* Decode 512 byte in data8.*/
numerr = decode_rs8 (rs_decoder, data8, par, 512, NULL, 0, NULL, 0, NULL);
Decoding with syndrome given by hardware decoder, direct data correction¶
/* Parity buffer. Size = number of roots */
uint16_t par[6], syn[6];
uint8_t data[512];
int numerr;
/* Receive data */
.....
/* Receive parity */
.....
/* Get syndrome from hardware decoder */
.....
/* Decode 512 byte in data8.*/
numerr = decode_rs8 (rs_decoder, data8, par, 512, syn, 0, NULL, 0, NULL);
Decoding with syndrome given by hardware decoder, no direct data correction.¶
Note: It’s not necessary to give data and received parity to the decoder.
/* Parity buffer. Size = number of roots */
uint16_t par[6], syn[6], corr[8];
uint8_t data[512];
int numerr, errpos[8];
/* Receive data */
.....
/* Receive parity */
.....
/* Get syndrome from hardware decoder */
.....
/* Decode 512 byte in data8.*/
numerr = decode_rs8 (rs_decoder, NULL, NULL, 512, syn, 0, errpos, 0, corr);
for (i = 0; i < numerr; i++) {
do_error_correction_in_your_buffer(errpos[i], corr[i]);
}
Cleanup¶
The function free_rs frees the allocated resources, if the caller is the last user of the decoder.
/* Release resources */
free_rs(rs_decoder);
Structures¶
This chapter contains the autogenerated documentation of the structures which are used in the ReedSolomon Library and are relevant for a developer.

struct
rs_codec
¶ rs codec data
Definition
struct rs_codec {
int mm;
int nn;
uint16_t *alpha_to;
uint16_t *index_of;
uint16_t *genpoly;
int nroots;
int fcr;
int prim;
int iprim;
int gfpoly;
int (*gffunc)(int);
int users;
struct list_head list;
};
Members
mm
Bits per symbol
nn
Symbols per block (= (1<<mm)1)
alpha_to
log lookup table
index_of
Antilog lookup table
genpoly
Generator polynomial
nroots
Number of generator roots = number of parity symbols
fcr
First consecutive root, index form
prim
Primitive element, index form
iprim
primth root of 1, index form
gfpoly
The primitive generator polynominal
gffunc
Function to generate the field, if noncanonical representation
users
Users of this structure
list
List entry for the rs codec list

struct
rs_control
¶ rs control structure per instance
Definition
struct rs_control {
struct rs_codec *codec;
uint16_t buffers[];
};
Members
codec
The codec used for this instance
buffers
Internal scratch buffers used in calls to decode_rs()

struct rs_control *
init_rs
(int symsize, int gfpoly, int fcr, int prim, int nroots)¶ Create a RS control struct and initialize it
Parameters
int symsize
the symbol size (number of bits)
int gfpoly
the extended Galois field generator polynomial coefficients, with the 0th coefficient in the low order bit. The polynomial must be primitive;
int fcr
the first consecutive root of the rs code generator polynomial in index form
int prim
primitive element to generate polynomial roots
int nroots
RS code generator polynomial degree (number of roots)
Description
Allocations use GFP_KERNEL.
Public Functions Provided¶
This chapter contains the autogenerated documentation of the ReedSolomon functions which are exported.

void
free_rs
(struct rs_control *rs)¶ Free the rs control structure
Parameters
struct rs_control *rs
The control structure which is not longer used by the caller
Description
Free the control structure. If rs is the last user of the associated codec, free the codec as well.

struct rs_control *
init_rs_gfp
(int symsize, int gfpoly, int fcr, int prim, int nroots, gfp_t gfp)¶ Create a RS control struct and initialize it
Parameters
int symsize
the symbol size (number of bits)
int gfpoly
the extended Galois field generator polynomial coefficients, with the 0th coefficient in the low order bit. The polynomial must be primitive;
int fcr
the first consecutive root of the rs code generator polynomial in index form
int prim
primitive element to generate polynomial roots
int nroots
RS code generator polynomial degree (number of roots)
gfp_t gfp
Memory allocation flags.

struct rs_control *
init_rs_non_canonical
(int symsize, int (*gffunc)(int), int fcr, int prim, int nroots)¶ Allocate rs control struct for fields with noncanonical representation
Parameters
int symsize
the symbol size (number of bits)
int (*gffunc)(int)
pointer to function to generate the next field element, or the multiplicative identity element if given 0. Used instead of gfpoly if gfpoly is 0
int fcr
the first consecutive root of the rs code generator polynomial in index form
int prim
primitive element to generate polynomial roots
int nroots
RS code generator polynomial degree (number of roots)

int
encode_rs8
(struct rs_control *rsc, uint8_t *data, int len, uint16_t *par, uint16_t invmsk)¶ Calculate the parity for data values (8bit data width)
Parameters
struct rs_control *rsc
the rs control structure
uint8_t *data
data field of a given type
int len
data length
uint16_t *par
parity data, must be initialized by caller (usually all 0)
uint16_t invmsk
invert data mask (will be xored on data)
The parity uses a uint16_t data type to enable symbol size > 8. The calling code must take care of encoding of the syndrome result for storage itself.

int
decode_rs8
(struct rs_control *rsc, uint8_t *data, uint16_t *par, int len, uint16_t *s, int no_eras, int *eras_pos, uint16_t invmsk, uint16_t *corr)¶ Decode codeword (8bit data width)
Parameters
struct rs_control *rsc
the rs control structure
uint8_t *data
data field of a given type
uint16_t *par
received parity data field
int len
data length
uint16_t *s
syndrome data field, must be in index form (if NULL, syndrome is calculated)
int no_eras
number of erasures
int *eras_pos
position of erasures, can be NULL
uint16_t invmsk
invert data mask (will be xored on data, not on parity!)
uint16_t *corr
buffer to store correction bitmask on eras_pos
The syndrome and parity uses a uint16_t data type to enable symbol size > 8. The calling code must take care of decoding of the syndrome result and the received parity before calling this code.
Note
 The rs_control struct rsc contains buffers which are used for
decoding, so the caller has to ensure that decoder invocations are serialized.
Returns the number of corrected symbols or EBADMSG for uncorrectable errors. The count includes errors in the parity.

int
encode_rs16
(struct rs_control *rsc, uint16_t *data, int len, uint16_t *par, uint16_t invmsk)¶ Calculate the parity for data values (16bit data width)
Parameters
struct rs_control *rsc
the rs control structure
uint16_t *data
data field of a given type
int len
data length
uint16_t *par
parity data, must be initialized by caller (usually all 0)
uint16_t invmsk
invert data mask (will be xored on data, not on parity!)
Each field in the data array contains up to symbol size bits of valid data.

int
decode_rs16
(struct rs_control *rsc, uint16_t *data, uint16_t *par, int len, uint16_t *s, int no_eras, int *eras_pos, uint16_t invmsk, uint16_t *corr)¶ Decode codeword (16bit data width)
Parameters
struct rs_control *rsc
the rs control structure
uint16_t *data
data field of a given type
uint16_t *par
received parity data field
int len
data length
uint16_t *s
syndrome data field, must be in index form (if NULL, syndrome is calculated)
int no_eras
number of erasures
int *eras_pos
position of erasures, can be NULL
uint16_t invmsk
invert data mask (will be xored on data, not on parity!)
uint16_t *corr
buffer to store correction bitmask on eras_pos
Each field in the data array contains up to symbol size bits of valid data.
Note
 The rc_control struct rsc contains buffers which are used for
decoding, so the caller has to ensure that decoder invocations are serialized.
Returns the number of corrected symbols or EBADMSG for uncorrectable errors. The count includes errors in the parity.
Credits¶
The library code for encoding and decoding was written by Phil Karn.
Copyright 2002, Phil Karn, KA9Q
May be used under the terms of the GNU General Public License (GPL)
The wrapper functions and interfaces are written by Thomas Gleixner.
Many users have provided bugfixes, improvements and helping hands for testing. Thanks a lot.
The following people have contributed to this document:
Thomas Gleixnertglx@linutronix.de