![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to reedsolo.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / scsi / qic117|
Return to reedsolo.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / scsi / qic117 |
1.1 root 1: /*++
2:
3: Copyright (c) 1993 - Colorado Memory Systems, Inc.
4: All Rights Reserved
5:
6: Module Name:
7:
8: reedsolo.c
9:
10: Abstract:
11:
12: These routines perform the Reed-Solomon Error correction
13: required for QIC-40 rev D. Spec.
14:
15: Revision History:
16:
17:
18:
19:
20: --*/
21:
22: //
23: // Includes
24: //
25:
26: #include <ntddk.h>
27: #include <ntddtape.h>
28: #include "common.h"
29: #include "q117.h"
30: #include "protos.h"
31:
32: //
33: // Protos for entry points
34: //
35:
36:
37: UCHAR
38: q117RdsMultiplyTuples (
39: IN UCHAR tup1,
40: IN UCHAR tup2
41: );
42:
43: UCHAR
44: q117RdsDivideTuples (
45: IN UCHAR tup1,
46: IN UCHAR tup2
47: );
48:
49: UCHAR
50: q117RdsExpTuple (
51: IN UCHAR tup1,
52: IN UCHAR xpnt
53: );
54:
55: VOID
56: q117RdsGetSyndromes (
57: IN OUT UCHAR *Array, // pointer to 32K data area (segment)
58: IN UCHAR Count, // number of good sectors in segment (4-32)
59: IN UCHAR *ps1,
60: IN UCHAR *ps2,
61: IN UCHAR *ps3
62: );
63:
64: BOOLEAN
65: q117RdsCorrectFailure (
66: IN OUT UCHAR *Array, // pointer to 32K data area (segment)
67: IN UCHAR Count, // number of good sectors in segment (4-32)
68: IN UCHAR s1,
69: IN UCHAR s2,
70: IN UCHAR s3
71: );
72:
73: BOOLEAN
74: q117RdsCorrectOneError (
75: IN OUT UCHAR *Array, // pointer to 32K data area (segment)
76: IN UCHAR Count, // number of good sectors in segment (4-32)
77: IN UCHAR ErrorLocation,
78: IN UCHAR s1,
79: IN UCHAR s2,
80: IN UCHAR s3
81: );
82:
83: BOOLEAN
84: q117RdsCorrectTwoErrors (
85: IN OUT UCHAR *Array, // pointer to 32K data area (segment)
86: IN UCHAR Count, // number of good sectors in segment (4-32)
87: IN UCHAR ErrorLocation1,
88: IN UCHAR ErrorLocation2,
89: IN UCHAR s1,
90: IN UCHAR s2,
91: IN UCHAR s3
92: );
93:
94: BOOLEAN
95: q117RdsCorrectThreeErrors (
96: IN OUT UCHAR *Array, // pointer to 32K data area (segment)
97: IN UCHAR Count, // number of good sectors in segment (4-32)
98: IN UCHAR ErrorLocation1,
99: IN UCHAR ErrorLocation2,
100: IN UCHAR ErrorLocation3,
101: IN UCHAR s1,
102: IN UCHAR s2,
103: UCHAR s3
104: );
105:
106: BOOLEAN
107: q117RdsCorrectOneErrorAndOneFailure (
108: IN OUT UCHAR *Array, // pointer to 32K data area (segment)
109: IN UCHAR Count, // number of good sectors in segment (4-32)
110: IN UCHAR ErrorLocation1,
111: IN UCHAR s1,
112: IN UCHAR s2,
113: IN UCHAR s3
114: );
115:
116:
117: UCHAR rds_exptup[255*2+2];
118: UCHAR rds_tupexp[256];
119: UCHAR rds_xC0[256];
120:
121: #define PASS 0
122: #define FAIL 1
123:
124: #define ADD_TUPLES(a, b) ((UCHAR) ( (a) ^ (b) ))
125:
126:
127: VOID
128: q117RdsInitReed (
129: VOID
130: )
131:
132: /*++
133:
134: Routine Description:
135:
136:
137: Arguments:
138:
139: Context - Current context of driver
140:
141: Return Value:
142:
143: NONE
144:
145: --*/
146:
147: {
148: ULONG i;
149: ULONG tuple = 1, alpha_8 = 0x87;
150:
151: for (i = 0; i <= 254; ++i) {
152: rds_exptup[i] = (UCHAR)tuple;
153: rds_tupexp[tuple] = (UCHAR)i;
154: if (tuple & 0x80) {
155: tuple = ((tuple << 1) ^ alpha_8) & 0xff;
156: } else {
157: tuple <<= 1;
158: }
159: }
160: for (i=0;i<255;++i) {
161: rds_exptup[i+255] = rds_exptup[i];
162: if (i<2) {
163: rds_exptup[i+255+255] = rds_exptup[i];
164: }
165: }
166: for (i = 0; i<=255; ++i) {
167: rds_xC0[i] = q117RdsMultiplyTuples((UCHAR)i,0xc0);
168: }
169: }
170:
171: UCHAR
172: q117RdsMultiplyTuples (
173: IN UCHAR tup1,
174: IN UCHAR tup2
175: )
176:
177: /*++
178:
179: Routine Description:
180:
181: 8-tuples to be multiplied.
182:
183: Arguments:
184:
185:
186: Return Value:
187:
188: Result of multiply
189:
190: --*/
191:
192: {
193:
194: if ( (tup1 == 0) || (tup2 == 0) ) {
195:
196: return(0);
197:
198: }
199:
200: return ( rds_exptup[rds_tupexp[tup1] + rds_tupexp[tup2]] );
201: }
202:
203: UCHAR
204: q117RdsDivideTuples (
205: IN UCHAR tup1,
206: IN UCHAR tup2
207: )
208:
209: /*++
210:
211: Routine Description:
212:
213: 8-tuples to be devided
214:
215: Arguments:
216:
217:
218: Return Value:
219:
220: Result of divide
221:
222: --*/
223:
224: {
225: if (tup2 == 0) {
226: return(0);
227: }
228: if (tup1 == 0) {
229: return(0);
230: }
231:
232: return (UCHAR)((ULONG)rds_exptup[rds_tupexp[tup1] + 255 - rds_tupexp[tup2]]);
233: }
234:
235: UCHAR
236: q117RdsExpTuple (
237: IN UCHAR tup1,
238: IN UCHAR xpnt
239: )
240:
241: /*++
242:
243: Routine Description:
244:
245: Exponent routine.
246:
247: Arguments:
248:
249:
250: Return Value:
251:
252: Result of tup1^xpnt
253:
254: --*/
255:
256: {
257: if (tup1 == 0)
258: return(0);
259:
260: return (UCHAR)((ULONG)rds_exptup[(rds_tupexp[tup1] * xpnt ) % 255]);
261: }
262:
263: VOID
264: q117RdsMakeCRC (
265: IN OUT UCHAR *Array, // pointer to 32K data area (segment)
266: IN UCHAR Count // number of sectors (1K blocks)(1-32)
267: )
268:
269: /*++
270:
271: Routine Description:
272:
273: Add Reed Solomon codes to buffer
274:
275: Arguments:
276:
277:
278: Return Value:
279:
280:
281: --*/
282:
283: {
284: ULONG num;
285: UCHAR i,j,k,p0,p1,p2;
286:
287:
288: for ( num = 0;num < BYTES_PER_SECTOR;++num ) {
289: p0 = p1 = p2 = 0;
290:
291: for ( i = 0; i < (UCHAR)(Count-3); ++i ) {
292:
293: j = rds_xC0[k = (p2 ^ Array[i * BYTES_PER_SECTOR + num])];
294: p2 = j ^ p1;
295: p1 = j ^ p0;
296: p0 = k;
297:
298: }
299:
300: Array[i * BYTES_PER_SECTOR + num] = p2;
301: i++;
302: Array[i * BYTES_PER_SECTOR + num] = p1;
303: i++;
304: Array[i * BYTES_PER_SECTOR + num] = p0;
305: i++;
306: }
307: }
308:
309: BOOLEAN
310: q117RdsReadCheck (
311: IN UCHAR *Array, // pointer to 32K data area (segment)
312: IN UCHAR Count // number of sectors (1K blocks)(1-32)
313: )
314:
315: /*++
316:
317: Routine Description:
318:
319: perform read check on buffer (fast check for CRC failures)
320:
321: Arguments:
322:
323:
324: Return Value:
325:
326: 1 - Success
327:
328: 0 - Failure
329:
330: --*/
331:
332:
333: {
334: LONG num;
335: UCHAR i,sum;
336:
337: for ( num = 0; num < BYTES_PER_SECTOR; ++num ) {
338:
339: sum = 0;
340: for ( i = 0; i < Count; ++i ) {
341:
342: sum ^= Array[i * BYTES_PER_SECTOR + num];
343:
344: }
345: if ( sum != 0 ) {
346:
347: return FAIL;
348:
349: }
350: }
351:
352: return PASS;
353: }
354:
355: BOOLEAN
356: q117RdsCorrect(
357: IN OUT UCHAR *Array, // pointer to 32K data area (segment)
358: IN UCHAR Count, // number of good sectors in segment (4-32)
359: IN UCHAR CRCErrors, // number of crc errors
360: IN UCHAR e1,
361: IN UCHAR e2,
362: IN UCHAR e3 // sectors where errors occurred
363: )
364:
365: /*++
366:
367: Routine Description:
368:
369: perform error Reed-Solomon error correction on segment
370:
371: Arguments:
372:
373:
374: Return Value:
375:
376: 1 - Success
377:
378: 0 - Failure
379:
380: --*/
381:
382: {
383: USHORT num;
384: BOOLEAN ret;
385: UCHAR s1,s2,s3;
386:
387: ret = PASS;
388: Count--;
389: e1 = Count-e1;
390: e2 = Count-e2;
391: e3 = Count-e3;
392:
393: for ( num = 0; num < BYTES_PER_SECTOR; ++num ) {
394: q117RdsGetSyndromes(&Array[num],Count,&s1,&s2,&s3);
395: if ( s1 || s2 || s3 ) {
396:
397: switch( CRCErrors ) {
398:
399: case 0:
400: ret = q117RdsCorrectFailure(&Array[num],Count,s1,s2,s3);
401: break;
402:
403: case 1:
404: ret = q117RdsCorrectOneError(&Array[num],Count,e1,s1,s2,s3);
405: break;
406:
407: case 2:
408: ret = q117RdsCorrectTwoErrors(&Array[num],Count,e1,e2,s1,s2,s3);
409: break;
410:
411: case 3:
412: ret = q117RdsCorrectThreeErrors(&Array[num],Count,e1,e2,e3,s1,s2,s3);
413: break;
414:
415: default:
416: ret = FAIL;
417: break;
418: }
419: }
420: if (ret)
421: return ret;
422: }
423: return ret;
424: }
425:
426:
427: //
428: // Due to bug in CL386 version 0.00.45, turn off optimization
429: //
430: #if i386
431: #pragma optimize("",off)
432: #endif
433:
434:
435: VOID
436: q117RdsGetSyndromes (
437: IN OUT UCHAR *Array, // pointer to 32K data area (segment)
438: IN UCHAR Count, // number of good sectors in segment (4-32)
439: IN UCHAR *ps1,
440: IN UCHAR *ps2,
441: IN UCHAR *ps3
442: )
443:
444: /*++
445:
446: Routine Description:
447:
448: 8-tuples to be multiplied.
449:
450: Arguments:
451:
452:
453: Return Value:
454:
455:
456: --*/
457:
458: {
459: UCHAR q,r,s,s1,s2,s3,cx,al,ah;
460:
461: q = r = s = 0;
462:
463: for ( cx = 0; cx <= Count; ++cx ) {
464:
465: al = rds_xC0[ah = q];
466: q = r ^ al;
467: r = s ^ al;
468: s = ah ^ Array[cx * BYTES_PER_SECTOR];
469:
470: }
471:
472: s1 = q117RdsMultiplyTuples(q,0xa2) ^ q117RdsMultiplyTuples(r,0xc3) ^ s;
473: s2 = q ^ r ^ s;
474: s3 = q117RdsMultiplyTuples(q,0x4) ^ q117RdsMultiplyTuples(r,2) ^ s;
475: *ps1 = s1;
476: *ps2 = s2;
477: *ps3 = s3;
478: }
479: #if i386
480: #pragma optimize("",on)
481: #endif
482:
483:
484: BOOLEAN
485: q117RdsCorrectFailure (
486: IN OUT UCHAR *Array, // pointer to 32K data area (segment)
487: IN UCHAR Count, // number of good sectors in segment (4-32)
488: IN UCHAR s1,
489: IN UCHAR s2,
490: IN UCHAR s3
491: )
492:
493: /*++
494:
495: Routine Description:
496:
497: Correct one failure
498:
499: Arguments:
500:
501:
502: Return Value:
503:
504: 1 - Success
505:
506: 0 - Failure
507:
508: --*/
509:
510: {
511: UCHAR errorloc,c1,y1,x1,ck;
512:
513: //
514: // check for divide by zero
515: //
516: if (s1 == 0) {
517: return FAIL;
518: }
519: errorloc = rds_tupexp[q117RdsDivideTuples(s2,s1)];
520: if (errorloc > Count) {
521: return FAIL;
522: }
523: y1 = s2;
524: x1 = rds_exptup[errorloc];
525: c1 = ADD_TUPLES(s2,Array[(Count-errorloc) * BYTES_PER_SECTOR]);
526: ck = q117RdsMultiplyTuples(y1,x1);
527: if (ck != s3) {
528: return FAIL;
529: } else {
530: Array[(Count-errorloc) * BYTES_PER_SECTOR] = c1;
531: }
532: return PASS;
533: }
534:
535: BOOLEAN
536: q117RdsCorrectOneError (
537: IN OUT UCHAR *Array, // pointer to 32K data area (segment)
538: IN UCHAR Count, // number of good sectors in segment (4-32)
539: IN UCHAR ErrorLocation,
540: IN UCHAR s1,
541: IN UCHAR s2,
542: IN UCHAR s3
543: )
544:
545: /*++
546:
547: Routine Description:
548:
549: Correct one error.
550:
551: Arguments:
552:
553:
554: Return Value:
555:
556: 1 - Success
557:
558: 0 - Failure
559:
560: --*/
561:
562: {
563: UCHAR x1,y1,c1,ck;
564:
565: x1 = rds_exptup[ErrorLocation];
566: y1 = s2;
567: c1 = ADD_TUPLES(s2,Array[(Count-ErrorLocation) * BYTES_PER_SECTOR]);
568: ck = q117RdsMultiplyTuples(y1,x1);
569:
570: if ( ck != s3 ) {
571:
572: return q117RdsCorrectOneErrorAndOneFailure(Array,Count,ErrorLocation,s1,s2,s3);
573:
574: } else {
575:
576: Array[(Count-ErrorLocation) * BYTES_PER_SECTOR] = c1;
577:
578: }
579: return PASS;
580: }
581:
582: BOOLEAN
583: q117RdsCorrectTwoErrors (
584: IN OUT UCHAR *Array, // pointer to 32K data area (segment)
585: IN UCHAR Count, // number of good sectors in segment (4-32)
586: IN UCHAR ErrorLocation1,
587: IN UCHAR ErrorLocation2,
588: IN UCHAR s1,
589: IN UCHAR s2,
590: IN UCHAR s3
591: )
592:
593: /*++
594:
595: Routine Description:
596:
597: Correct two errors.
598:
599: Arguments:
600:
601:
602: Return Value:
603:
604: 1 - Success
605:
606: 0 - Failure
607:
608: --*/
609:
610: {
611: UCHAR y1,y2,x1,x2,c1,c2,ck;
612:
613: x1 = rds_exptup[ErrorLocation1];
614: x2 = rds_exptup[ErrorLocation2];
615:
616: y2 = q117RdsDivideTuples(
617: ADD_TUPLES(
618: q117RdsMultiplyTuples(s2, x1), s3 ), ADD_TUPLES(x1,x2)
619: );
620:
621: y1 = ADD_TUPLES(y2,s2);
622:
623: c1 = ADD_TUPLES( y1, Array[(Count-ErrorLocation1) * BYTES_PER_SECTOR] );
624: c2 = ADD_TUPLES( y2, Array[(Count-ErrorLocation2) * BYTES_PER_SECTOR] );
625:
626: ck =x1 = q117RdsDivideTuples(
627: ADD_TUPLES(
628: q117RdsMultiplyTuples(y1,x2),
629: q117RdsMultiplyTuples(y2,x1)
630: ), q117RdsMultiplyTuples(x1,x2));
631:
632: if ( ck != s1 ) {
633:
634: return FAIL;
635:
636: } else {
637:
638: Array[(Count-ErrorLocation1) * BYTES_PER_SECTOR] = c1;
639: Array[(Count-ErrorLocation2) * BYTES_PER_SECTOR] = c2;
640:
641: }
642:
643: return PASS;
644: }
645:
646: BOOLEAN
647: q117RdsCorrectThreeErrors (
648: IN OUT UCHAR *Array, // pointer to 32K data area (segment)
649: IN UCHAR Count, // number of good sectors in segment (4-32)
650: IN UCHAR ErrorLocation1,
651: IN UCHAR ErrorLocation2,
652: IN UCHAR ErrorLocation3,
653: IN UCHAR s1,
654: IN UCHAR s2,
655: UCHAR s3
656: )
657:
658: /*++
659:
660: Routine Description:
661:
662: Correct three errors.
663:
664: Arguments:
665:
666:
667: Return Value:
668:
669: 1 - Success
670:
671: 0 - Failure
672:
673: --*/
674:
675: {
676: UCHAR y1,y2,y3,z1,z2,z3,x1,x2,x3,c1,c2,c3,q1,q2,q3,q4;
677:
678: x1 = rds_exptup[ErrorLocation1];
679: x2 = rds_exptup[ErrorLocation2];
680: x3 = rds_exptup[ErrorLocation3];
681: z1 = q117RdsDivideTuples(1,x1);
682: z2 = q117RdsDivideTuples(1,x2);
683: z3 = q117RdsDivideTuples(1,x3);
684: q1 = q117RdsDivideTuples(
685: ADD_TUPLES(q117RdsMultiplyTuples(x1,s2),s3),
686: ADD_TUPLES(x1,x2)
687: );
688: q2 = q117RdsDivideTuples(
689: ADD_TUPLES(q117RdsMultiplyTuples(z1,s2),s1),
690: ADD_TUPLES(z1,z2)
691: );
692: q3 = q117RdsDivideTuples(ADD_TUPLES(x1,x3),ADD_TUPLES(x1,x2));
693: q4 = q117RdsDivideTuples(ADD_TUPLES(z1,z3),ADD_TUPLES(z1,z2));
694: y3 = q117RdsDivideTuples(ADD_TUPLES(q1,q2),ADD_TUPLES(q3,q4));
695: y2 = ADD_TUPLES(q2,q117RdsMultiplyTuples(q4,y3));
696: y1 = ADD_TUPLES(ADD_TUPLES(y3,y2),s2);
697: c1 = ADD_TUPLES(y1,Array[(Count-ErrorLocation1) * BYTES_PER_SECTOR]);
698: c2 = ADD_TUPLES(y2,Array[(Count-ErrorLocation2) * BYTES_PER_SECTOR]);
699: c3 = ADD_TUPLES(y3,Array[(Count-ErrorLocation3) * BYTES_PER_SECTOR]);
700:
701: Array[(Count-ErrorLocation1) * BYTES_PER_SECTOR] = c1;
702: Array[(Count-ErrorLocation2) * BYTES_PER_SECTOR] = c2;
703: Array[(Count-ErrorLocation3) * BYTES_PER_SECTOR] = c3;
704:
705: return PASS;
706: }
707:
708: BOOLEAN
709: q117RdsCorrectOneErrorAndOneFailure (
710: IN OUT UCHAR *Array, // pointer to 32K data area (segment)
711: IN UCHAR Count, // number of good sectors in segment (4-32)
712: IN UCHAR ErrorLocation1,
713: IN UCHAR s1,
714: IN UCHAR s2,
715: IN UCHAR s3
716: )
717:
718: /*++
719:
720: Routine Description:
721:
722: Correct one error and one failure.
723:
724: Arguments:
725:
726:
727: Return Value:
728:
729: 1 - Success
730:
731: 0 - Failure
732:
733: --*/
734:
735: {
736: UCHAR y1,y2,x1,x2,c1,c2;
737: UCHAR errorLoc2;
738:
739: x1 = rds_exptup[ErrorLocation1];
740:
741: y1 = q117RdsDivideTuples(
742: q117RdsMultiplyTuples(
743: ADD_TUPLES(
744: q117RdsMultiplyTuples(s1,s3),
745: q117RdsExpTuple(s2,2)
746: ),x1),
747: ADD_TUPLES(s3,
748: q117RdsMultiplyTuples(s1,q117RdsExpTuple(x1,2)))
749: );
750:
751: y2 = ADD_TUPLES(y1,s2);
752:
753: x2 = q117RdsDivideTuples(
754: q117RdsMultiplyTuples(y2,x1),
755: ADD_TUPLES(y1,q117RdsMultiplyTuples(s1,x1))
756: );
757:
758: errorLoc2 = rds_tupexp[x2];
759:
760: if ( errorLoc2 > Count ) {
761:
762: return FAIL;
763:
764: }
765:
766: c1 = ADD_TUPLES(y1,Array[(Count-ErrorLocation1) * BYTES_PER_SECTOR]);
767: c2 = ADD_TUPLES(y2,Array[(Count-errorLoc2) * BYTES_PER_SECTOR]);
768:
769: Array[(Count-ErrorLocation1) * BYTES_PER_SECTOR] = c1;
770: Array[(Count-errorLoc2) * BYTES_PER_SECTOR] = c2;
771:
772: return PASS;
773: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.