linux-imx

// SPDX-License-Identifier: GPL-2.0

/*

 * Generic Reed Solomon encoder / decoder library

 *

 * Copyright 2002, Phil Karn, KA9Q

 * May be used under the terms of the GNU General Public License (GPL)

 *

 * Adaption to the kernel by Thomas Gleixner (tglx@linutronix.de)

 *

 * Generic data width independent code which is included by the wrappers.

 */

{

    struct rs_codec *rs = rsc->codec;

    int deg_lambda, el, deg_omega;

    int i, j, r, k, pad;

    int nn = rs->nn;

    int nroots = rs->nroots;

    int fcr = rs->fcr;

    int prim = rs->prim;

    int iprim = rs->iprim;

    uint16_t *alpha_to = rs->alpha_to;

    uint16_t *index_of = rs->index_of;

    uint16_t u, q, tmp, num1, num2, den, discr_r, syn_error;

    int count = 0;

    uint16_t msk = (uint16_t) rs->nn;

​

    /*

     * The decoder buffers are in the rs control struct. They are

     * arrays sized [nroots + 1]

     */

    uint16_t *lambda = rsc->buffers + RS_DECODE_LAMBDA * (nroots + 1);

    uint16_t *syn = rsc->buffers + RS_DECODE_SYN * (nroots + 1);

    uint16_t *b = rsc->buffers + RS_DECODE_B * (nroots + 1);

    uint16_t *t = rsc->buffers + RS_DECODE_T * (nroots + 1);

    uint16_t *omega = rsc->buffers + RS_DECODE_OMEGA * (nroots + 1);

    uint16_t *root = rsc->buffers + RS_DECODE_ROOT * (nroots + 1);

    uint16_t *reg = rsc->buffers + RS_DECODE_REG * (nroots + 1);

    uint16_t *loc = rsc->buffers + RS_DECODE_LOC * (nroots + 1);

​

    /* Check length parameter for validity */

    pad = nn - nroots - len;

    BUG_ON(pad < 0 || pad >= nn);

​

    /* Does the caller provide the syndrome ? */

    if (s != NULL)

        goto decode;

​

    /* form the syndromes; i.e., evaluate data(x) at roots of

     * g(x) */

    for (i = 0; i < nroots; i++)

        syn[i] = (((uint16_t) data[0]) ^ invmsk) & msk;

​

    for (j = 1; j < len; j++) {

        for (i = 0; i < nroots; i++) {

            if (syn[i] == 0) {

                syn[i] = (((uint16_t) data[j]) ^

                      invmsk) & msk;

            } else {

                syn[i] = ((((uint16_t) data[j]) ^

                       invmsk) & msk) ^

                    alpha_to[rs_modnn(rs, index_of[syn[i]] +

                               (fcr + i) * prim)];

            }