mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
776 lines
14 KiB
776 lines
14 KiB
/*++
|
|
|
|
Copyright (c) 1993 - Colorado Memory Systems, Inc.
|
|
All Rights Reserved
|
|
|
|
Module Name:
|
|
|
|
reedsolo.c
|
|
|
|
Abstract:
|
|
|
|
These routines perform the Reed-Solomon Error correction
|
|
required for QIC-40 rev D. Spec.
|
|
|
|
Revision History:
|
|
|
|
|
|
|
|
|
|
--*/
|
|
|
|
//
|
|
// Includes
|
|
//
|
|
|
|
#include <ntddk.h>
|
|
#include <ntddtape.h>
|
|
#include "common.h"
|
|
#include "q117.h"
|
|
#include "protos.h"
|
|
|
|
#define FCT_ID 0x0117
|
|
|
|
|
|
//
|
|
// Protos for entry points
|
|
//
|
|
|
|
|
|
UCHAR
|
|
q117RdsMultiplyTuples (
|
|
IN UCHAR tup1,
|
|
IN UCHAR tup2
|
|
);
|
|
|
|
UCHAR
|
|
q117RdsDivideTuples (
|
|
IN UCHAR tup1,
|
|
IN UCHAR tup2
|
|
);
|
|
|
|
UCHAR
|
|
q117RdsExpTuple (
|
|
IN UCHAR tup1,
|
|
IN UCHAR xpnt
|
|
);
|
|
|
|
VOID
|
|
q117RdsGetSyndromes (
|
|
IN OUT UCHAR *Array, // pointer to 32K data area (segment)
|
|
IN UCHAR Count, // number of good sectors in segment (4-32)
|
|
IN UCHAR *ps1,
|
|
IN UCHAR *ps2,
|
|
IN UCHAR *ps3
|
|
);
|
|
|
|
BOOLEAN
|
|
q117RdsCorrectFailure (
|
|
IN OUT UCHAR *Array, // pointer to 32K data area (segment)
|
|
IN UCHAR Count, // number of good sectors in segment (4-32)
|
|
IN UCHAR s1,
|
|
IN UCHAR s2,
|
|
IN UCHAR s3
|
|
);
|
|
|
|
BOOLEAN
|
|
q117RdsCorrectOneError (
|
|
IN OUT UCHAR *Array, // pointer to 32K data area (segment)
|
|
IN UCHAR Count, // number of good sectors in segment (4-32)
|
|
IN UCHAR ErrorLocation,
|
|
IN UCHAR s1,
|
|
IN UCHAR s2,
|
|
IN UCHAR s3
|
|
);
|
|
|
|
BOOLEAN
|
|
q117RdsCorrectTwoErrors (
|
|
IN OUT UCHAR *Array, // pointer to 32K data area (segment)
|
|
IN UCHAR Count, // number of good sectors in segment (4-32)
|
|
IN UCHAR ErrorLocation1,
|
|
IN UCHAR ErrorLocation2,
|
|
IN UCHAR s1,
|
|
IN UCHAR s2,
|
|
IN UCHAR s3
|
|
);
|
|
|
|
BOOLEAN
|
|
q117RdsCorrectThreeErrors (
|
|
IN OUT UCHAR *Array, // pointer to 32K data area (segment)
|
|
IN UCHAR Count, // number of good sectors in segment (4-32)
|
|
IN UCHAR ErrorLocation1,
|
|
IN UCHAR ErrorLocation2,
|
|
IN UCHAR ErrorLocation3,
|
|
IN UCHAR s1,
|
|
IN UCHAR s2,
|
|
UCHAR s3
|
|
);
|
|
|
|
BOOLEAN
|
|
q117RdsCorrectOneErrorAndOneFailure (
|
|
IN OUT UCHAR *Array, // pointer to 32K data area (segment)
|
|
IN UCHAR Count, // number of good sectors in segment (4-32)
|
|
IN UCHAR ErrorLocation1,
|
|
IN UCHAR s1,
|
|
IN UCHAR s2,
|
|
IN UCHAR s3
|
|
);
|
|
|
|
|
|
UCHAR rds_exptup[255*2+2];
|
|
UCHAR rds_tupexp[256];
|
|
UCHAR rds_xC0[256];
|
|
|
|
#define PASS 0
|
|
#define FAIL 1
|
|
|
|
#define ADD_TUPLES(a, b) ((UCHAR) ( (a) ^ (b) ))
|
|
|
|
|
|
VOID
|
|
q117RdsInitReed (
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
Context - Current context of driver
|
|
|
|
Return Value:
|
|
|
|
NONE
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG i;
|
|
ULONG tuple = 1, alpha_8 = 0x87;
|
|
|
|
for (i = 0; i <= 254; ++i) {
|
|
rds_exptup[i] = (UCHAR)tuple;
|
|
rds_tupexp[tuple] = (UCHAR)i;
|
|
if (tuple & 0x80) {
|
|
tuple = ((tuple << 1) ^ alpha_8) & 0xff;
|
|
} else {
|
|
tuple <<= 1;
|
|
}
|
|
}
|
|
for (i=0;i<255;++i) {
|
|
rds_exptup[i+255] = rds_exptup[i];
|
|
if (i<2) {
|
|
rds_exptup[i+255+255] = rds_exptup[i];
|
|
}
|
|
}
|
|
for (i = 0; i<=255; ++i) {
|
|
rds_xC0[i] = q117RdsMultiplyTuples((UCHAR)i,0xc0);
|
|
}
|
|
}
|
|
|
|
UCHAR
|
|
q117RdsMultiplyTuples (
|
|
IN UCHAR tup1,
|
|
IN UCHAR tup2
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
8-tuples to be multiplied.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
Result of multiply
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
if ( (tup1 == 0) || (tup2 == 0) ) {
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
return ( rds_exptup[rds_tupexp[tup1] + rds_tupexp[tup2]] );
|
|
}
|
|
|
|
UCHAR
|
|
q117RdsDivideTuples (
|
|
IN UCHAR tup1,
|
|
IN UCHAR tup2
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
8-tuples to be devided
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
Result of divide
|
|
|
|
--*/
|
|
|
|
{
|
|
if (tup2 == 0) {
|
|
return(0);
|
|
}
|
|
if (tup1 == 0) {
|
|
return(0);
|
|
}
|
|
|
|
return (UCHAR)((ULONG)rds_exptup[rds_tupexp[tup1] + 255 - rds_tupexp[tup2]]);
|
|
}
|
|
|
|
UCHAR
|
|
q117RdsExpTuple (
|
|
IN UCHAR tup1,
|
|
IN UCHAR xpnt
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Exponent routine.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
Result of tup1^xpnt
|
|
|
|
--*/
|
|
|
|
{
|
|
if (tup1 == 0)
|
|
return(0);
|
|
|
|
return (UCHAR)((ULONG)rds_exptup[(rds_tupexp[tup1] * xpnt ) % 255]);
|
|
}
|
|
|
|
VOID
|
|
q117RdsMakeCRC (
|
|
IN OUT UCHAR *Array, // pointer to 32K data area (segment)
|
|
IN UCHAR Count // number of sectors (1K blocks)(1-32)
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Add Reed Solomon codes to buffer
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG num;
|
|
UCHAR i,j,k,p0,p1,p2;
|
|
|
|
|
|
for ( num = 0;num < BYTES_PER_SECTOR;++num ) {
|
|
p0 = p1 = p2 = 0;
|
|
|
|
for ( i = 0; i < (UCHAR)(Count-3); ++i ) {
|
|
|
|
j = rds_xC0[k = (p2 ^ Array[i * BYTES_PER_SECTOR + num])];
|
|
p2 = j ^ p1;
|
|
p1 = j ^ p0;
|
|
p0 = k;
|
|
|
|
}
|
|
|
|
Array[i * BYTES_PER_SECTOR + num] = p2;
|
|
i++;
|
|
Array[i * BYTES_PER_SECTOR + num] = p1;
|
|
i++;
|
|
Array[i * BYTES_PER_SECTOR + num] = p0;
|
|
i++;
|
|
}
|
|
}
|
|
|
|
BOOLEAN
|
|
q117RdsReadCheck (
|
|
IN UCHAR *Array, // pointer to 32K data area (segment)
|
|
IN UCHAR Count // number of sectors (1K blocks)(1-32)
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
perform read check on buffer (fast check for CRC failures)
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
1 - Success
|
|
|
|
0 - Failure
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
LONG num;
|
|
UCHAR i,sum;
|
|
|
|
for ( num = 0; num < BYTES_PER_SECTOR; ++num ) {
|
|
|
|
sum = 0;
|
|
for ( i = 0; i < Count; ++i ) {
|
|
|
|
sum ^= Array[i * BYTES_PER_SECTOR + num];
|
|
|
|
}
|
|
if ( sum != 0 ) {
|
|
|
|
return FAIL;
|
|
|
|
}
|
|
}
|
|
|
|
return PASS;
|
|
}
|
|
|
|
BOOLEAN
|
|
q117RdsCorrect(
|
|
IN OUT UCHAR *Array, // pointer to 32K data area (segment)
|
|
IN UCHAR Count, // number of good sectors in segment (4-32)
|
|
IN UCHAR CRCErrors, // number of crc errors
|
|
IN UCHAR e1,
|
|
IN UCHAR e2,
|
|
IN UCHAR e3 // sectors where errors occurred
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
perform error Reed-Solomon error correction on segment
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
1 - Success
|
|
|
|
0 - Failure
|
|
|
|
--*/
|
|
|
|
{
|
|
USHORT num;
|
|
BOOLEAN ret;
|
|
UCHAR s1,s2,s3;
|
|
|
|
ret = PASS;
|
|
Count--;
|
|
e1 = Count-e1;
|
|
e2 = Count-e2;
|
|
e3 = Count-e3;
|
|
|
|
for ( num = 0; num < BYTES_PER_SECTOR; ++num ) {
|
|
q117RdsGetSyndromes(&Array[num],Count,&s1,&s2,&s3);
|
|
if ( s1 || s2 || s3 ) {
|
|
|
|
switch( CRCErrors ) {
|
|
|
|
case 0:
|
|
ret = q117RdsCorrectFailure(&Array[num],Count,s1,s2,s3);
|
|
break;
|
|
|
|
case 1:
|
|
ret = q117RdsCorrectOneError(&Array[num],Count,e1,s1,s2,s3);
|
|
break;
|
|
|
|
case 2:
|
|
ret = q117RdsCorrectTwoErrors(&Array[num],Count,e1,e2,s1,s2,s3);
|
|
break;
|
|
|
|
case 3:
|
|
ret = q117RdsCorrectThreeErrors(&Array[num],Count,e1,e2,e3,s1,s2,s3);
|
|
break;
|
|
|
|
default:
|
|
ret = FAIL;
|
|
break;
|
|
}
|
|
}
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
//
|
|
// Due to bug in CL386 version 0.00.45, turn off optimization
|
|
//
|
|
#if i386
|
|
#pragma optimize("",off)
|
|
#endif
|
|
|
|
|
|
VOID
|
|
q117RdsGetSyndromes (
|
|
IN OUT UCHAR *Array, // pointer to 32K data area (segment)
|
|
IN UCHAR Count, // number of good sectors in segment (4-32)
|
|
IN UCHAR *ps1,
|
|
IN UCHAR *ps2,
|
|
IN UCHAR *ps3
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
8-tuples to be multiplied.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
UCHAR q,r,s,s1,s2,s3,cx,al,ah;
|
|
|
|
q = r = s = 0;
|
|
|
|
for ( cx = 0; cx <= Count; ++cx ) {
|
|
|
|
al = rds_xC0[ah = q];
|
|
q = r ^ al;
|
|
r = s ^ al;
|
|
s = ah ^ Array[cx * BYTES_PER_SECTOR];
|
|
|
|
}
|
|
|
|
s1 = q117RdsMultiplyTuples(q,0xa2) ^ q117RdsMultiplyTuples(r,0xc3) ^ s;
|
|
s2 = q ^ r ^ s;
|
|
s3 = q117RdsMultiplyTuples(q,0x4) ^ q117RdsMultiplyTuples(r,2) ^ s;
|
|
*ps1 = s1;
|
|
*ps2 = s2;
|
|
*ps3 = s3;
|
|
}
|
|
#if i386
|
|
#pragma optimize("",on)
|
|
#endif
|
|
|
|
|
|
BOOLEAN
|
|
q117RdsCorrectFailure (
|
|
IN OUT UCHAR *Array, // pointer to 32K data area (segment)
|
|
IN UCHAR Count, // number of good sectors in segment (4-32)
|
|
IN UCHAR s1,
|
|
IN UCHAR s2,
|
|
IN UCHAR s3
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Correct one failure
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
1 - Success
|
|
|
|
0 - Failure
|
|
|
|
--*/
|
|
|
|
{
|
|
UCHAR errorloc,c1,y1,x1,ck;
|
|
|
|
//
|
|
// check for divide by zero
|
|
//
|
|
if (s1 == 0) {
|
|
return FAIL;
|
|
}
|
|
errorloc = rds_tupexp[q117RdsDivideTuples(s2,s1)];
|
|
if (errorloc > Count) {
|
|
return FAIL;
|
|
}
|
|
y1 = s2;
|
|
x1 = rds_exptup[errorloc];
|
|
c1 = ADD_TUPLES(s2,Array[(Count-errorloc) * BYTES_PER_SECTOR]);
|
|
ck = q117RdsMultiplyTuples(y1,x1);
|
|
if (ck != s3) {
|
|
return FAIL;
|
|
} else {
|
|
Array[(Count-errorloc) * BYTES_PER_SECTOR] = c1;
|
|
}
|
|
return PASS;
|
|
}
|
|
|
|
BOOLEAN
|
|
q117RdsCorrectOneError (
|
|
IN OUT UCHAR *Array, // pointer to 32K data area (segment)
|
|
IN UCHAR Count, // number of good sectors in segment (4-32)
|
|
IN UCHAR ErrorLocation,
|
|
IN UCHAR s1,
|
|
IN UCHAR s2,
|
|
IN UCHAR s3
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Correct one error.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
1 - Success
|
|
|
|
0 - Failure
|
|
|
|
--*/
|
|
|
|
{
|
|
UCHAR x1,y1,c1,ck;
|
|
|
|
x1 = rds_exptup[ErrorLocation];
|
|
y1 = s2;
|
|
c1 = ADD_TUPLES(s2,Array[(Count-ErrorLocation) * BYTES_PER_SECTOR]);
|
|
ck = q117RdsMultiplyTuples(y1,x1);
|
|
|
|
if ( ck != s3 ) {
|
|
|
|
return q117RdsCorrectOneErrorAndOneFailure(Array,Count,ErrorLocation,s1,s2,s3);
|
|
|
|
} else {
|
|
|
|
Array[(Count-ErrorLocation) * BYTES_PER_SECTOR] = c1;
|
|
|
|
}
|
|
return PASS;
|
|
}
|
|
|
|
BOOLEAN
|
|
q117RdsCorrectTwoErrors (
|
|
IN OUT UCHAR *Array, // pointer to 32K data area (segment)
|
|
IN UCHAR Count, // number of good sectors in segment (4-32)
|
|
IN UCHAR ErrorLocation1,
|
|
IN UCHAR ErrorLocation2,
|
|
IN UCHAR s1,
|
|
IN UCHAR s2,
|
|
IN UCHAR s3
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Correct two errors.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
1 - Success
|
|
|
|
0 - Failure
|
|
|
|
--*/
|
|
|
|
{
|
|
UCHAR y1,y2,x1,x2,c1,c2,ck;
|
|
|
|
x1 = rds_exptup[ErrorLocation1];
|
|
x2 = rds_exptup[ErrorLocation2];
|
|
|
|
y2 = q117RdsDivideTuples(
|
|
ADD_TUPLES(
|
|
q117RdsMultiplyTuples(s2, x1), s3 ), ADD_TUPLES(x1,x2)
|
|
);
|
|
|
|
y1 = ADD_TUPLES(y2,s2);
|
|
|
|
c1 = ADD_TUPLES( y1, Array[(Count-ErrorLocation1) * BYTES_PER_SECTOR] );
|
|
c2 = ADD_TUPLES( y2, Array[(Count-ErrorLocation2) * BYTES_PER_SECTOR] );
|
|
|
|
ck =x1 = q117RdsDivideTuples(
|
|
ADD_TUPLES(
|
|
q117RdsMultiplyTuples(y1,x2),
|
|
q117RdsMultiplyTuples(y2,x1)
|
|
), q117RdsMultiplyTuples(x1,x2));
|
|
|
|
if ( ck != s1 ) {
|
|
|
|
return FAIL;
|
|
|
|
} else {
|
|
|
|
Array[(Count-ErrorLocation1) * BYTES_PER_SECTOR] = c1;
|
|
Array[(Count-ErrorLocation2) * BYTES_PER_SECTOR] = c2;
|
|
|
|
}
|
|
|
|
return PASS;
|
|
}
|
|
|
|
BOOLEAN
|
|
q117RdsCorrectThreeErrors (
|
|
IN OUT UCHAR *Array, // pointer to 32K data area (segment)
|
|
IN UCHAR Count, // number of good sectors in segment (4-32)
|
|
IN UCHAR ErrorLocation1,
|
|
IN UCHAR ErrorLocation2,
|
|
IN UCHAR ErrorLocation3,
|
|
IN UCHAR s1,
|
|
IN UCHAR s2,
|
|
UCHAR s3
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Correct three errors.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
1 - Success
|
|
|
|
0 - Failure
|
|
|
|
--*/
|
|
|
|
{
|
|
UCHAR y1,y2,y3,z1,z2,z3,x1,x2,x3,c1,c2,c3,q1,q2,q3,q4;
|
|
|
|
x1 = rds_exptup[ErrorLocation1];
|
|
x2 = rds_exptup[ErrorLocation2];
|
|
x3 = rds_exptup[ErrorLocation3];
|
|
z1 = q117RdsDivideTuples(1,x1);
|
|
z2 = q117RdsDivideTuples(1,x2);
|
|
z3 = q117RdsDivideTuples(1,x3);
|
|
q1 = q117RdsDivideTuples(
|
|
ADD_TUPLES(q117RdsMultiplyTuples(x1,s2),s3),
|
|
ADD_TUPLES(x1,x2)
|
|
);
|
|
q2 = q117RdsDivideTuples(
|
|
ADD_TUPLES(q117RdsMultiplyTuples(z1,s2),s1),
|
|
ADD_TUPLES(z1,z2)
|
|
);
|
|
q3 = q117RdsDivideTuples(ADD_TUPLES(x1,x3),ADD_TUPLES(x1,x2));
|
|
q4 = q117RdsDivideTuples(ADD_TUPLES(z1,z3),ADD_TUPLES(z1,z2));
|
|
y3 = q117RdsDivideTuples(ADD_TUPLES(q1,q2),ADD_TUPLES(q3,q4));
|
|
y2 = ADD_TUPLES(q2,q117RdsMultiplyTuples(q4,y3));
|
|
y1 = ADD_TUPLES(ADD_TUPLES(y3,y2),s2);
|
|
c1 = ADD_TUPLES(y1,Array[(Count-ErrorLocation1) * BYTES_PER_SECTOR]);
|
|
c2 = ADD_TUPLES(y2,Array[(Count-ErrorLocation2) * BYTES_PER_SECTOR]);
|
|
c3 = ADD_TUPLES(y3,Array[(Count-ErrorLocation3) * BYTES_PER_SECTOR]);
|
|
|
|
Array[(Count-ErrorLocation1) * BYTES_PER_SECTOR] = c1;
|
|
Array[(Count-ErrorLocation2) * BYTES_PER_SECTOR] = c2;
|
|
Array[(Count-ErrorLocation3) * BYTES_PER_SECTOR] = c3;
|
|
|
|
return PASS;
|
|
}
|
|
|
|
BOOLEAN
|
|
q117RdsCorrectOneErrorAndOneFailure (
|
|
IN OUT UCHAR *Array, // pointer to 32K data area (segment)
|
|
IN UCHAR Count, // number of good sectors in segment (4-32)
|
|
IN UCHAR ErrorLocation1,
|
|
IN UCHAR s1,
|
|
IN UCHAR s2,
|
|
IN UCHAR s3
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Correct one error and one failure.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
1 - Success
|
|
|
|
0 - Failure
|
|
|
|
--*/
|
|
|
|
{
|
|
UCHAR y1,y2,x1,x2,c1,c2;
|
|
UCHAR errorLoc2;
|
|
|
|
x1 = rds_exptup[ErrorLocation1];
|
|
|
|
y1 = q117RdsDivideTuples(
|
|
q117RdsMultiplyTuples(
|
|
ADD_TUPLES(
|
|
q117RdsMultiplyTuples(s1,s3),
|
|
q117RdsExpTuple(s2,2)
|
|
),x1),
|
|
ADD_TUPLES(s3,
|
|
q117RdsMultiplyTuples(s1,q117RdsExpTuple(x1,2)))
|
|
);
|
|
|
|
y2 = ADD_TUPLES(y1,s2);
|
|
|
|
x2 = q117RdsDivideTuples(
|
|
q117RdsMultiplyTuples(y2,x1),
|
|
ADD_TUPLES(y1,q117RdsMultiplyTuples(s1,x1))
|
|
);
|
|
|
|
errorLoc2 = rds_tupexp[x2];
|
|
|
|
if ( errorLoc2 > Count ) {
|
|
|
|
return FAIL;
|
|
|
|
}
|
|
|
|
c1 = ADD_TUPLES(y1,Array[(Count-ErrorLocation1) * BYTES_PER_SECTOR]);
|
|
c2 = ADD_TUPLES(y2,Array[(Count-errorLoc2) * BYTES_PER_SECTOR]);
|
|
|
|
Array[(Count-ErrorLocation1) * BYTES_PER_SECTOR] = c1;
|
|
Array[(Count-errorLoc2) * BYTES_PER_SECTOR] = c2;
|
|
|
|
return PASS;
|
|
}
|