553 lines
14 KiB
C
553 lines
14 KiB
C
/* 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 */
|
|
}
|