/* HOOK. Fixed comments; otherwise impossible to compile */
/*
* $Log: V:/Flite/archives/TrueFFS5/Src/REEDSOL.C_V $
*
* Rev 1.3 Jul 13 2001 01:10:00 oris
* Moved saved syndrome array definition (used by d2tst).
*
* Rev 1.2 Apr 09 2001 15:10:20 oris
* End with an empty line.
*
* Rev 1.1 Apr 01 2001 08:00:14 oris
* copywrite notice.
*
* Rev 1.0 Feb 04 2001 12:37:38 oris
* Initial revision.
*
*/
/************************************************************************/
/* */
/* FAT-FTL Lite Software Development Kit */
/* Copyright (C) M-Systems Ltd. 1995-2001 */
/* */
/************************************************************************/
#include "reedsol.h"
#define T 2 /* Number of recoverable errors */
#define SYND_LEN (T*2) /* length of syndrom vector */
#define K512 (((512+1)*8+6)/10) /* number of inf symbols for record
of 512 bytes (K512=411) */
#define N512 (K512 + SYND_LEN) /* code word length for record of 512 bytes */
#define INIT_DEG 510
#define MOD 1023
#define BLOCK_SIZE 512
#ifdef D2TST
byte saveSyndromForDumping[SYNDROM_BYTES];
#endif /* D2TST */
static short gfi(short val);
static short gfmul( short f, short s );
static short gfdiv( short f, short s );
static short flog(short val);
static short alog(short val);
/*------------------------------------------------------------------------------*/
/* Function Name: RTLeightToTen */
/* Purpose......: convert an array of five 8-bit values into an array of */
/* four 10-bit values, from right to left. */
/* Returns......: Nothing */
/*------------------------------------------------------------------------------*/
static void RTLeightToTen(char *reg8, unsigned short reg10[])
{
reg10[0] = (reg8[0] & 0xFF) | ((reg8[1] & 0x03) << 8);
reg10[1] = ((reg8[1] & 0xFC) >> 2) | ((reg8[2] & 0x0F) << 6);
reg10[2] = ((reg8[2] & 0xF0) >> 4) | ((reg8[3] & 0x3F) << 4);
reg10[3] = ((reg8[3] & 0xC0) >> 6) | ((reg8[4] & 0xFF) << 2);
}
/*----------------------------------------------------------------------------*/
static void unpack( short word, short length, short vector[] )
/* */
/* Function unpacks word into vector */
/* */
/* Parameters: */
/* word - word to be unpacked */
/* vector - array to be filled */
/* length - number of bits in word */
{
short i, *ptr;
ptr = vector + length - 1;
for( i = 0; i < length; i++ )
{
*ptr-- = word & 1;
word >>= 1;
}
}
/*----------------------------------------------------------------------------*/
static short pack( short *vector, short length )
/* */
/* Function packs vector into word */
/* */
/* Parameters: */
/* vector - array to be packed */
/* length - number of bits in word */
{
short tmp, i;
vector += length - 1;
tmp = 0;
i = 1;
while( length-- > 0 )
{
if( *vector-- )
tmp |= i;
i <<= 1;
}
return( tmp );
}
/*----------------------------------------------------------------------------*/
static short gfi( short val) /* GF inverse */
{
return alog((short)(MOD-flog(val)));
}
/*----------------------------------------------------------------------------*/
static short gfmul( short f, short s ) /* GF multiplication */
{
short i;
if( f==0 || s==0 )
return 0;
else
{
i = flog(f) + flog(s);
if( i > MOD ) i -= MOD;
return( alog(i) );
}
}
/*----------------------------------------------------------------------------*/
static short gfdiv( short f, short s ) /* GF division */
{
return gfmul(f,gfi(s));
}
/*----------------------------------------------------------------------------*/
static void residue_to_syndrom( short reg[], short realsynd[] )
{
short i,l,alpha,x,s,x4;
short deg,deg4;
for(i=0,deg=INIT_DEG;i<SYND_LEN;i++,deg++)
{
s = reg[0];
alpha = x = alog(deg);
deg4 = deg+deg;
if( deg4 >= MOD ) deg4 -= MOD;
deg4 += deg4;
if( deg4 >= MOD ) deg4 -= MOD;
x4 = alog(deg4);
for(l=1;l<SYND_LEN;l++)
{
s ^= gfmul( reg[l], x );
x = gfmul( alpha, x );
}
realsynd[i] = gfdiv( s, x4 );
}
}
/*----------------------------------------------------------------------------*/
static short alog(short i)
{
short j=0, val=1;
for( ; j < i ; j++ )
{
val <<= 1 ;
if ( val > 0x3FF )
{
if ( val & 8 ) val -= (0x400+7);
else val -= (0x400-9);
}
}
return val ;
}
static short flog(short val)
{
short j, val1;
if (val == 0)
return (short)0xFFFF;
j=0;
val1=1;
for( ; j <= MOD ; j++ )
{
if (val1 == val)
return j;
val1 <<= 1 ;
if ( val1 > 0x3FF )
{
if ( val1 & 8 ) val1 -= (0x400+7);
else val1 -= (0x400-9);
}
}
return 0;
}
/*----------------------------------------------------------------------------*/
static short convert_to_byte_patterns( short *locators, short *values,
short noferr, short *blocs, short *bvals )
{
static short mask[] = { 0x0, 0x1, 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff };
short i,j,n, n0, n1, tmp;
short n_bit, n_byte, k_bit, nb;
for( i = 0, nb = 0; i< noferr; i++)
{
n = locators[i];
tmp = values[i];
n_bit = n *10 - 6 ;
n_byte = n_bit >> 3;
k_bit = n_bit - (n_byte<<3);
n_byte++;
if( k_bit == 7 )
{
/* 3 corrupted bytes */
blocs[nb] = n_byte+1;
bvals[nb++] = tmp & 1 ? 0x80 : 0;
tmp >>= 1;
blocs[nb] = n_byte;
bvals[nb++] = tmp & 0xff;
tmp >>= 8;
bvals[nb++] = tmp & 0xff;
}
else
{
n0 = 8 - k_bit;
n1 = 10 - n0;
blocs[nb] = n_byte;
bvals[nb++] = (tmp & mask[n1]) << (8 - n1);
tmp >>= n1;
blocs[nb] = n_byte - 1;
bvals[nb++] = (tmp & mask[n0]);
}
}
for( i = 0, j = -1; i < nb; i++ )
{
if( bvals[i] == 0 ) continue;
if( (blocs[i] == blocs[j]) && ( j>= 0 ) )
{
bvals[j] |= bvals[i];
}
else
{
j++;
blocs[j] = blocs[i];
bvals[j] = bvals[i];
}
}
return j+1;
}
/*----------------------------------------------------------------------------*/
static short deg512( short x )
{
short i;
short l,m;
l = flog(x);
for( i=0;i<9;i++)
{
m = 0;
if( (l & 0x200) )
m = 1;
l = ( ( l << 1 ) & 0x3FF ) | m;
}
return alog(l);
}
/*----------------------------------------------------------------------------*/
static short decoder_for_2_errors( short s[], short lerr[], short verr[] )
{
/* decoder for correcting up to 2 errors */
short i,j,k,temp,delta;
short ind, x1, x2;
short r1, r2, r3, j1, j2;
short sigma1, sigma2;
short xu[10], ku[10];
short yd, yn;
ind = 0;
for(i=0;i<SYND_LEN;i++)
if( s[i] != 0 )
ind++; /* ind = number of nonzero syndrom symbols */
if( ind == 0 ) return 0; /* no errors */
if( ind < 4 )
goto two_or_more_errors;
/* checking s1/s0 = s2/s1 = s3/s2 = alpha**j for some j */
r1 = gfdiv( s[1], s[0] );
r2 = gfdiv( s[2], s[1] );
r3 = gfdiv( s[3], s[2] );
if( r1 != r2 || r2 != r3)
goto two_or_more_errors;
j = flog(r1);
if( j > 414 )
goto two_or_more_errors;
lerr[0] = j;
/* pattern = (s0/s1)**(510+1) * s1
or
pattern = (s0/s1)**(512 - 1 ) * s1 */
temp = gfi( r1 );
#ifndef NT5PORT
{
int i;
for (i = 0; i < 9; i++)
temp = gfmul( temp, temp ); /* deg = 512 */
}
#else /*NT5PORT*/
for (i = 0; i < 9; i++)
{
temp = gfmul( temp, temp ); /* deg = 512 */
}
#endif /*NT5PORT*/
verr[0] = gfmul( gfmul(temp, r1), s[1] );
return 1; /* 1 error */
two_or_more_errors:
delta = gfmul( s[0], s[2] ) ^ gfmul( s[1], s[1] );
if( delta == 0 )
return -1; /* uncorrectable error */
temp = gfmul( s[1], s[3] ) ^ gfmul( s[2], s[2] );
if( temp == 0 )
return -1; /* uncorrectable error */
sigma2 = gfdiv( temp, delta );
temp = gfmul( s[1], s[2] ) ^ gfmul( s[0], s[3] );
if( temp == 0 )
return -1; /* uncorrectable error */
sigma1 = gfdiv( temp, delta );
k = gfdiv( sigma2, gfmul( sigma1, sigma1 ) );
unpack( k, 10, ku );
if( ku[2] != 0 )
return -1;
xu[4] = ku[9];
xu[5] = ku[0] ^ ku[1];
xu[6] = ku[6] ^ ku[9];
xu[3] = ku[4] ^ ku[9];
xu[1] = ku[3] ^ ku[4] ^ ku[6];
xu[0] = ku[0] ^ xu[1];
xu[8] = ku[8] ^ xu[0];
xu[7] = ku[7] ^ xu[3] ^ xu[8];
xu[2] = ku[5] ^ xu[7] ^ xu[5] ^ xu[0];
xu[9] = 0;
x1 = pack( xu, 10 );
x2 = x1 | 1;
x1 = gfmul( sigma1, x1 );
x2 = gfmul( sigma1, x2 );
j1 = flog(x1);
j2 = flog(x2);
if( (j1 > 414) || (j2 > 414) )
return -1;
r1 = x1 ^ x2;
r2 = deg512( x1 );
temp = gfmul( x1, x1 );
r2 = gfdiv( r2, temp );
yd = gfmul( r2, r1 );
if( yd == 0 )
return -1;
yn = gfmul( s[0], x2 ) ^ s[1];
if( yn == 0 )
return -1;
verr[0] = gfdiv( yn, yd );
r2 = deg512( x2 );
temp = gfmul( x2, x2 );
r2 = gfdiv( r2, temp );
yd = gfmul( r2, r1 );
if( yd == 0 )
return -1;
yn = gfmul( s[0], x1 ) ^ s[1];
if( yn == 0 )
return -1;
verr[1] = gfdiv( yn, yd );
if( j1 > j2 ) {
lerr[0] = j2;
lerr[1] = j1;
temp = verr[0];
verr[0] = verr[1];
verr[1] = temp;
}
else
{
lerr[0] = j1;
lerr[1] = j2;
}
return 2;
}
/*------------------------------------------------------------------------------*/
/* Function Name: flDecodeEDC */
/* Purpose......: Trys to correct errors. */
/* errorSyndrom[] should contain the syndrom as 5 bytes and one */
/* parity byte. (identical to the output of calcEDCSyndrom()). */
/* Upon returning, errorNum will contain the number of errors, */
/* errorLocs[] will contain error locations, and */
/* errorVals[] will contain error values (to be XORed with the */
/* data). */
/* Parity error is relevant only if there are other errors, and */
/* the EDC code fails parity check. */
/* NOTE! Only the first errorNum indexes of the above two arrays */
/* are relevant. The others contain garbage. */
/* Returns......: The error status. */
/* NOTE! If the error status is NO_EDC_ERROR upon return, ignore */
/* the value of the arguments. */
/*------------------------------------------------------------------------------*/
EDCstatus flDecodeEDC(char *errorSyndrom, char *errorsNum,
short errorLocs[3*T], short errorVals[3*T])
{
short noferr; /* number of errors */
short dec_parity; /* parity byte of decoded word */
short rec_parity; /* parity byte of received word */
short realsynd[SYND_LEN]; /* real syndrom calculated from residue */
short locators[T], /* error locators */
values[T]; /* error values */
short reg[SYND_LEN]; /* register for main division procedure */
int i;
RTLeightToTen(errorSyndrom, (unsigned short *)reg);
rec_parity = errorSyndrom[5] & 0xFF; /* The parity byte */
residue_to_syndrom(reg, realsynd);
noferr = decoder_for_2_errors(realsynd, locators, values);
if(noferr == 0)
return NO_EDC_ERROR; /* No error found */
if(noferr < 0) /* If an uncorrectable error was found */
return UNCORRECTABLE_ERROR;
for (i=0;i<noferr;i++)
locators[i] = N512 - 1 - locators[i];
*errorsNum = (char)convert_to_byte_patterns(locators, values, noferr, errorLocs, errorVals);
for(dec_parity=i=0; i < *errorsNum; i++)/* Calculate the parity for all the */
{ /* errors found: */
if(errorLocs[i] <= 512)
dec_parity ^= errorVals[i];
}
if(dec_parity != rec_parity)
return UNCORRECTABLE_ERROR; /* Parity error */
else
return CORRECTABLE_ERROR;
}
/*------------------------------------------------------------------------------*/
/* Function Name: flCheckAndFixEDC */
/* Purpose......: Decodes the EDC syndrom and fixs the errors if possible. */
/* block[] should contain 512 bytes of data. */
/* NOTE! Call this function only if errors where detected by */
/* syndCalc or by the ASIC module. */
/* Returns......: The error status. */
/*------------------------------------------------------------------------------*/
EDCstatus flCheckAndFixEDC(char FAR1 *block, char *syndrom, FLBoolean byteSwap)
{
char errorsNum;
short errorLocs[3*T];
short errorVals[3*T];
EDCstatus status;
status = flDecodeEDC(syndrom, &errorsNum, errorLocs, errorVals);
if(status == CORRECTABLE_ERROR) /* Fix the errors if possible */
{
int i;
for (i=0; i < errorsNum; i++)
if( (errorLocs[i] ^ byteSwap) < BLOCK_SIZE ) /* Fix only in Data Area */
block[errorLocs[i] ^ byteSwap] ^= errorVals[i];
return NO_EDC_ERROR; /* All errors are fixed */
}
else
return status; /* Uncorrectable error */
}