CRC/EDC checker system

Abstract

EDC/CRC checker (70) performs an EDC/CRC check as a block of data is being corrected during a correction pass, thereby obviating buffer access for EDC/CRC purposes subsequent to block correction. During the correction pass, an EDC/CRC sum is accumulated which, upon completion of the pass of the block, is zero if EDC/CRC bytes in the block confirm that the block has been corrected. During the single correction pass of the block, bytes of an uncorrected, most-recent codeword are added to the accumulated sum. Bytes of a previous codeword which have a byte synchronization relationship with the byte of the most-recent codeword are corrected (if necessary), and (when correction occurs) error pattern factors including error patterns used to correct the bytes of the previous codeword are also added to the accumulated sum. In the illustrated embodiment, the block is conceptualized as having columns of codewords and the byte synchronization relationship is such that when an uncorrected byte is being accumulated, correction occurs for a corresponding byte of a next previous codeword. Various embodiments of the invention are capable of handling a plurality of codewords simultaneously.

The embodiments of the invention in which an exclusive property or privilege is claimed are defined as follows: 
     
       1. A system for checking bytes of information stored in block form in a buffer, the system comprising: a correction unit which outputs error patterns for use in correcting specified bytes of the block during a correction access of the buffer;   a CRC/EDC checker which operates upon the bytes of the block during the correction access of the buffer and uses CRC/EDC information to confirm that the block is corrected.   
     
     
       2. The system of claim 1, wherein the CRC/EDC checker operates to sum the bytes of the block. 
     
     
       3. The system of claim 2, wherein during the correction access there is a byte position synchronization relationship between a byte being corrected and a byte being summed. 
     
     
       4. The system of claim 3, wherein during the correction pass the checker adds a selected byte from the block to the sum and thereafter, as the selected byte is being corrected using an error value for the selected byte, also adds to the sum a factor which includes the error value for the selected byte. 
     
     
       5. The system of claim 2, wherein during the correction pass the checker adds a selected byte from the buffer to the sum and thereafter, as the selected byte is being corrected using an error value for the selected byte, also adds to the sum a factor which includes the error value for the selected byte. 
     
     
       6. A system which checks bytes of information in a buffer in synchronization with correction of bytes in the buffer by a correction unit, the checker comprising: a memory device wherein a sum is accumulated;   an adder which adds to the sum accumulated in the memory the following: (1) a byte of the buffer that has not yet been corrected by the correction unit;   (2) an error pattern for a byte that has already been added to the sum;   an CRC/EDC checker which evaluates the sum to confirm correction by the correction unit.     
     
     
       7. The checker of claim 6, wherein the byte added to the sum has a byte location synchronization relationship with the byte for which the error pattern is being added. 
     
     
       8. The checker of claim 7, wherein the buffer is conceptualized as comprising a plurality of columns and rows, and wherein the byte added to the buffer and the byte for which the error pattern is added are in a same row. 
     
     
       9. The checker of claim 7, wherein the error pattern is included in an error pattern factor which is added to the accumulated sum, and wherein the error pattern factor further includes a constant multiple. 
     
     
       10. The checker of claim 9, wherein a value of the constant multiple is dependent upon the byte location synchronization relationship. 
     
     
       11. A method for checking bytes of information stored in a buffer, the method comprising: accessing a first selected byte in the buffer and adding the first selected byte to an accumulated sum;   using an error pattern for a second selected byte in the buffer to correct the second selected byte in the buffer;   adding the error pattern for the second selected byte to the accumulated sum;   using the sum to confirm that the error pattern corrects the second selected byte.   
     
     
       12. The method of claim 11, wherein there is a byte position synchronization relationship between the first selected byte and the second selected byte. 
     
     
       13. The method of claim 12, wherein the buffer is conceptualized as comprising a plurality of columns and rows, and wherein the first selected byte and the second selected byte are in a same row. 
     
     
       14. The method of claim 12, wherein the error pattern is included in an error pattern factor which is added to the accumulated sum, and wherein the error pattern factor further includes a constant multiple. 
     
     
       15. The method of claim 14, wherein a value of the constant multiple is dependent upon the byte location synchronization relationship. 
     
     
       16. A method of checking bytes of information stored in a buffer, the method comprising: sequentially accessing bytes in a buffer;   adding a first selected byte of the buffer to an accumulated sum, the first selected byte not yet having undergone correction if correction thereof is required;   correcting a second selected byte in the buffer using an error pattern for the second selected byte;   adding the error pattern for the second selected byte to the accumulated sum; and   using the accumulated sum to confirm correction of the second selected byte.   
     
     
       17. The method of claim 16, wherein there is a byte position synchronization relationship between the first selected byte and the second selected byte. 
     
     
       18. The method of claim 16 wherein the buffer is conceptualized as comprising a plurality of columns and rows, and wherein the byte added to the buffer and the byte for which the error pattern is added are in a same row. 
     
     
       19. The method of claim 16, wherein the error pattern is included in an error patter factor which is added to the accumulated sum, and wherein the error pattern factor further includes a constant multiple. 
     
     
       20. The method of claim 19, wherein a value of the constant multiple is dependent upon the byte location synchronization relationship. 
     
     
       21. A method of checking bytes of information stored in block format in a buffer during one pass of the buffer, the method comprising: adding a first selected byte to an accumulated sum during the one pass; then subsequently but during the same pass,   adding to the accumulated sum an error pattern for the first selected byte; and   using the accumulated sum to confirm that the error pattern corrects the first selected byte.   
     
     
       22. The method of claim 21, further comprising using the error pattern to correct the first selected byte after the first selected byte has been added to the accumulated sum. 
     
     
       23. The method of claim 22, wherein the error pattern is included in an error pattern factor which is added to the accumulated sum, and wherein the error pattern factor further includes a constant multiple. 
     
     
       24. The method of claim 23, wherein a value of the constant multiple is dependent upon the byte location synchronization relationship. 
     
     
       25. A method of checking bytes of information stored in block format in a buffer, the method comprising: sequentially accessing bytes in the buffer in a single pass access through the block;   adding, when accessed, a first byte to an accumulated sum; the first byte not yet having been corrected should correction be required;   correcting a second byte of the block using an error pattern for the second byte; the second byte as uncorrected already having been added to the accumulated sum;   adding an error pattern for the second byte to the accumulated sum; then subsequently but during the same pass,   adding a third byte to the accumulated sum;   correcting the first byte with an error pattern for the first byte;   adding an error pattern for the first byte to the accumulated sum; and   using the accumulated sum to confirm that the error pattern corrects the second byte.   
     
     
       26. The method of claim 25, wherein there is a byte position synchronization relationship between the first selected byte and the second selected byte. 
     
     
       27. The method of claim 26, wherein the buffer is conceptualized as comprising a plurality of columns and rows, and wherein the first selected byte and the second selected byte are in a same row. 
     
     
       28. The method of claim 26, wherein the error pattern is included in an error pattern factor added to the accumulated sum, and wherein the error pattern factor further includes a constant multiple. 
     
     
       29. The method of claim 28, wherein a value of the constant multiple is dependent upon the byte location synchronization relationship. 
     
     
       30. The method of claim 25, wherein upon completion of the single pass access through the block the accumulated sum is zero if the block has been properly corrected. 
     
     
       31. A method of performing an EDC/CRC check for bytes in a block of data in a buffer, the method comprising: sequentially accessing uncorrected data bytes in the block and adding each uncorrected data byte when accessed to an accumulated sum;   determining, as an uncorrected data byte is accessed, whether a location-related data byte in the block has an available error pattern, the location-related data byte already having been added to the accumulated sum; and, if an available error pattern exists,   adding the available error pattern for the location-related data byte to the accumulated sum; and   using the accumulated sum to confirm that the available error pattern corrects the location-related data byte.   
     
     
       32. The method of claim 31, further comprising correcting the location-related data byte during the sequential accessing of uncorrected data bytes in the block.   
     
     
       33. The method of claim 31, wherein the location-related data byte is in a byte synchronized relationship with the accessed uncorrected data byte. 
     
     
       34. A method of performing an EDC/CRC check for bytes in a block of data in a buffer, the bytes being organized into codewords, the method comprising: sequentially adding uncorrected data bytes for a most-recent codeword in the block to an accumulated sum;   determining, as an uncorrected data byte for the most-recent codeword is accessed, whether a corresponding data byte in a previous codeword has an available error pattern, the corresponding data byte of the previous codeword already having been added to the accumulated sum; and, if an available error pattern exists,   adding the available error pattern for the corresponding data byte of the previous codeword to the accumulated sum; and   using the accumulated sum to confirm that the block has been corrected.   
     
     
       35. The method of claim 34, further comprising correcting the corresponding data byte of the previous codeword while uncorrected data bytes of the most-recent codeword are being added to the accumulated sum.   
     
     
       36. The method of claim 34, wherein the corresponding data byte of the previous codeword is in a byte synchronized relationship with the data byte of the most-recent codeword which is being added to the accumulated sum.